commit dbf06b504b525c7f6680c5709b63df6413616d2e Author: facebook-github-bot Date: Thu Jan 23 11:53:41 2020 -0800 Initial commit fbshipit-source-id: ad58e416e3ceeca85fae0583308968d04e78fe0d diff --git a/.circleci/check.sh b/.circleci/check.sh new file mode 100644 index 00000000..bdca2cab --- /dev/null +++ b/.circleci/check.sh @@ -0,0 +1,6 @@ +#!/bin/bash -e +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +# Run this script before committing config.yml to verify it is valid yaml. + +python -c 'import yaml; yaml.safe_load(open("config.yml"))' && echo OK diff --git a/.circleci/config.in.yml b/.circleci/config.in.yml new file mode 100644 index 00000000..aa0900f4 --- /dev/null +++ b/.circleci/config.in.yml @@ -0,0 +1,199 @@ +version: 2.1 + +#examples: +#https://github.com/facebookresearch/ParlAI/blob/master/.circleci/config.yml +#https://github.com/facebookresearch/hydra/blob/master/.circleci/config.yml +#https://github.com/facebookresearch/habitat-api/blob/master/.circleci/config.yml + +#drive tests with nox or tox or pytest? + +# ------------------------------------------------------------------------------------- +# environments where we run our jobs +# ------------------------------------------------------------------------------------- + + +setupcuda: &setupcuda + run: + name: Setup CUDA + working_directory: ~/ + command: | + # download and install nvidia drivers, cuda, etc + wget --no-verbose --no-clobber -P ~/nvidia-downloads 'https://s3.amazonaws.com/ossci-linux/nvidia_driver/NVIDIA-Linux-x86_64-430.40.run' + wget --no-verbose --no-clobber -P ~/nvidia-downloads http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run + sudo /bin/bash ~/nvidia-downloads/NVIDIA-Linux-x86_64-430.40.run --no-drm -q --ui=none + sudo sh ~/nvidia-downloads/cuda_10.2.89_440.33.01_linux.run --silent + echo "Done installing CUDA." + pyenv versions + nvidia-smi + pyenv global 3.7.0 + +gpu: &gpu + environment: + CUDA_VERSION: "10.2" + machine: + image: default + resource_class: gpu.medium # tesla m60 + +binary_common: &binary_common + parameters: + # Edit these defaults to do a release` + build_version: + description: "version number of release binary; by default, build a nightly" + type: string + default: "" + pytorch_version: + description: "PyTorch version to build against; by default, use a nightly" + type: string + default: "" + # Don't edit these + python_version: + description: "Python version to build against (e.g., 3.7)" + type: string + cu_version: + description: "CUDA version to build against, in CU format (e.g., cpu or cu100)" + type: string + wheel_docker_image: + description: "Wheel only: what docker image to use" + type: string + default: "pytorch/manylinux-cuda101" + environment: + PYTHON_VERSION: << parameters.python_version >> + BUILD_VERSION: << parameters.build_version >> + PYTORCH_VERSION: << parameters.pytorch_version >> + CU_VERSION: << parameters.cu_version >> + +jobs: + main: + <<: *gpu + machine: + image: ubuntu-1604:201903-01 + steps: + - checkout + - <<: *setupcuda + - run: pip3 install --progress-bar off wheel matplotlib 'pillow<7' + - run: pip3 install --progress-bar off torch torchvision + # - run: conda create -p ~/conda_env python=3.7 numpy + # - run: conda activate ~/conda_env + # - run: conda install -c pytorch pytorch torchvision + + - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/fvcore' + - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-10.2/lib64 python3 setup.py build_ext --inplace + - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-10.2/lib64 python -m unittest discover -v -s tests + - run: python3 setup.py bdist_wheel + + binary_linux_wheel: + <<: *binary_common + docker: + - image: << parameters.wheel_docker_image >> + resource_class: 2xlarge+ + steps: + - checkout + - run: packaging/build_wheel.sh + - store_artifacts: + path: dist + - persist_to_workspace: + root: dist + paths: + - "*" + + binary_linux_conda: + <<: *binary_common + docker: + - image: "pytorch/conda-cuda" + resource_class: 2xlarge+ + steps: + - checkout + # This is building with cuda but no gpu present, + # so we aren't running the tests. + - run: TEST_FLAG=--no-test packaging/build_conda.sh + - store_artifacts: + path: /opt/conda/conda-bld/linux-64 + - persist_to_workspace: + root: /opt/conda/conda-bld/linux-64 + paths: + - "*" + + binary_linux_conda_cuda: + <<: *binary_common + machine: + image: ubuntu-1604:201903-01 + resource_class: gpu.medium + steps: + - checkout + - run: + name: Setup environment + command: | + set -e + + curl -L https://packagecloud.io/circleci/trusty/gpgkey | sudo apt-key add - + curl -L https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add - + + sudo apt-get update + + sudo apt-get install \ + apt-transport-https \ + ca-certificates \ + curl \ + gnupg-agent \ + software-properties-common + + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - + + sudo add-apt-repository \ + "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ + $(lsb_release -cs) \ + stable" + + sudo apt-get update + export DOCKER_VERSION="5:19.03.2~3-0~ubuntu-xenial" + sudo apt-get install docker-ce=${DOCKER_VERSION} docker-ce-cli=${DOCKER_VERSION} containerd.io=1.2.6-3 + + # Add the package repositories + distribution=$(. /etc/os-release;echo $ID$VERSION_ID) + curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - + curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list + + export NVIDIA_CONTAINER_VERSION="1.0.3-1" + sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit=${NVIDIA_CONTAINER_VERSION} + sudo systemctl restart docker + + DRIVER_FN="NVIDIA-Linux-x86_64-410.104.run" + wget "https://s3.amazonaws.com/ossci-linux/nvidia_driver/$DRIVER_FN" + sudo /bin/bash "$DRIVER_FN" -s --no-drm || (sudo cat /var/log/nvidia-installer.log && false) + nvidia-smi + + - run: + name: Pull docker image + command: | + set -e + export DOCKER_IMAGE=pytorch/conda-cuda + echo Pulling docker image $DOCKER_IMAGE + docker pull $DOCKER_IMAGE >/dev/null + + - run: + name: Build and run tests + command: | + set -e + + cd ${HOME}/project/ + + export DOCKER_IMAGE=pytorch/conda-cuda + export VARS_TO_PASS="-e PYTHON_VERSION -e BUILD_VERSION -e PYTORCH_VERSION -e UNICODE_ABI -e CU_VERSION" + + docker run --gpus all --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${DOCKER_IMAGE} ./packaging/build_conda.sh + +workflows: + version: 2 + build_and_test: + jobs: + - main + {{workflows()}} + - binary_linux_conda: + cu_version: cu101 + name: binary_linux_conda_py3.7_cu101 + python_version: '3.7' + - binary_linux_conda_cuda: + name: testrun_conda_cuda_py3.7_cu100 + python_version: "3.7" + pytorch_version: "1.4" + cu_version: "cu100" diff --git a/.circleci/config.yml b/.circleci/config.yml new file mode 100644 index 00000000..ab91e87e --- /dev/null +++ b/.circleci/config.yml @@ -0,0 +1,258 @@ +version: 2.1 + +#examples: +#https://github.com/facebookresearch/ParlAI/blob/master/.circleci/config.yml +#https://github.com/facebookresearch/hydra/blob/master/.circleci/config.yml +#https://github.com/facebookresearch/habitat-api/blob/master/.circleci/config.yml + +#drive tests with nox or tox or pytest? + +# ------------------------------------------------------------------------------------- +# environments where we run our jobs +# ------------------------------------------------------------------------------------- + + +setupcuda: &setupcuda + run: + name: Setup CUDA + working_directory: ~/ + command: | + # download and install nvidia drivers, cuda, etc + wget --no-verbose --no-clobber -P ~/nvidia-downloads 'https://s3.amazonaws.com/ossci-linux/nvidia_driver/NVIDIA-Linux-x86_64-430.40.run' + wget --no-verbose --no-clobber -P ~/nvidia-downloads http://developer.download.nvidia.com/compute/cuda/10.2/Prod/local_installers/cuda_10.2.89_440.33.01_linux.run + sudo /bin/bash ~/nvidia-downloads/NVIDIA-Linux-x86_64-430.40.run --no-drm -q --ui=none + sudo sh ~/nvidia-downloads/cuda_10.2.89_440.33.01_linux.run --silent + echo "Done installing CUDA." + pyenv versions + nvidia-smi + pyenv global 3.7.0 + +gpu: &gpu + environment: + CUDA_VERSION: "10.2" + machine: + image: default + resource_class: gpu.medium # tesla m60 + +binary_common: &binary_common + parameters: + # Edit these defaults to do a release` + build_version: + description: "version number of release binary; by default, build a nightly" + type: string + default: "" + pytorch_version: + description: "PyTorch version to build against; by default, use a nightly" + type: string + default: "" + # Don't edit these + python_version: + description: "Python version to build against (e.g., 3.7)" + type: string + cu_version: + description: "CUDA version to build against, in CU format (e.g., cpu or cu100)" + type: string + wheel_docker_image: + description: "Wheel only: what docker image to use" + type: string + default: "pytorch/manylinux-cuda101" + environment: + PYTHON_VERSION: << parameters.python_version >> + BUILD_VERSION: << parameters.build_version >> + PYTORCH_VERSION: << parameters.pytorch_version >> + CU_VERSION: << parameters.cu_version >> + +jobs: + main: + <<: *gpu + machine: + image: ubuntu-1604:201903-01 + steps: + - checkout + - <<: *setupcuda + - run: pip3 install --progress-bar off wheel matplotlib 'pillow<7' + - run: pip3 install --progress-bar off torch torchvision + # - run: conda create -p ~/conda_env python=3.7 numpy + # - run: conda activate ~/conda_env + # - run: conda install -c pytorch pytorch torchvision + + - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/fvcore' + - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-10.2/lib64 python3 setup.py build_ext --inplace + - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-10.2/lib64 python -m unittest discover -v -s tests + - run: python3 setup.py bdist_wheel + + binary_linux_wheel: + <<: *binary_common + docker: + - image: << parameters.wheel_docker_image >> + resource_class: 2xlarge+ + steps: + - checkout + - run: packaging/build_wheel.sh + - store_artifacts: + path: dist + - persist_to_workspace: + root: dist + paths: + - "*" + + binary_linux_conda: + <<: *binary_common + docker: + - image: "pytorch/conda-cuda" + resource_class: 2xlarge+ + steps: + - checkout + # This is building with cuda but no gpu present, + # so we aren't running the tests. + - run: TEST_FLAG=--no-test packaging/build_conda.sh + - store_artifacts: + path: /opt/conda/conda-bld/linux-64 + - persist_to_workspace: + root: /opt/conda/conda-bld/linux-64 + paths: + - "*" + + binary_linux_conda_cuda: + <<: *binary_common + machine: + image: ubuntu-1604:201903-01 + resource_class: gpu.medium + steps: + - checkout + - run: + name: Setup environment + command: | + set -e + + curl -L https://packagecloud.io/circleci/trusty/gpgkey | sudo apt-key add - + curl -L https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add - + + sudo apt-get update + + sudo apt-get install \ + apt-transport-https \ + ca-certificates \ + curl \ + gnupg-agent \ + software-properties-common + + curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - + + sudo add-apt-repository \ + "deb [arch=amd64] https://download.docker.com/linux/ubuntu \ + $(lsb_release -cs) \ + stable" + + sudo apt-get update + export DOCKER_VERSION="5:19.03.2~3-0~ubuntu-xenial" + sudo apt-get install docker-ce=${DOCKER_VERSION} docker-ce-cli=${DOCKER_VERSION} containerd.io=1.2.6-3 + + # Add the package repositories + distribution=$(. /etc/os-release;echo $ID$VERSION_ID) + curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | sudo apt-key add - + curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list + + export NVIDIA_CONTAINER_VERSION="1.0.3-1" + sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit=${NVIDIA_CONTAINER_VERSION} + sudo systemctl restart docker + + DRIVER_FN="NVIDIA-Linux-x86_64-410.104.run" + wget "https://s3.amazonaws.com/ossci-linux/nvidia_driver/$DRIVER_FN" + sudo /bin/bash "$DRIVER_FN" -s --no-drm || (sudo cat /var/log/nvidia-installer.log && false) + nvidia-smi + + - run: + name: Pull docker image + command: | + set -e + export DOCKER_IMAGE=pytorch/conda-cuda + echo Pulling docker image $DOCKER_IMAGE + docker pull $DOCKER_IMAGE >/dev/null + + - run: + name: Build and run tests + command: | + set -e + + cd ${HOME}/project/ + + export DOCKER_IMAGE=pytorch/conda-cuda + export VARS_TO_PASS="-e PYTHON_VERSION -e BUILD_VERSION -e PYTORCH_VERSION -e UNICODE_ABI -e CU_VERSION" + + docker run --gpus all --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${DOCKER_IMAGE} ./packaging/build_conda.sh + +workflows: + version: 2 + build_and_test: + jobs: + - main + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu92 + name: binary_linux_conda_py3.6_cu92 + python_version: '3.6' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda92 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu100 + name: binary_linux_conda_py3.6_cu100 + python_version: '3.6' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda100 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu101 + name: binary_linux_conda_py3.6_cu101 + python_version: '3.6' + pytorch_version: '1.4' + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu92 + name: binary_linux_conda_py3.7_cu92 + python_version: '3.7' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda92 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu100 + name: binary_linux_conda_py3.7_cu100 + python_version: '3.7' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda100 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu101 + name: binary_linux_conda_py3.7_cu101 + python_version: '3.7' + pytorch_version: '1.4' + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu92 + name: binary_linux_conda_py3.8_cu92 + python_version: '3.8' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda92 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu100 + name: binary_linux_conda_py3.8_cu100 + python_version: '3.8' + pytorch_version: '1.4' + wheel_docker_image: pytorch/manylinux-cuda100 + - binary_linux_conda: + build_version: 0.1.0 + cu_version: cu101 + name: binary_linux_conda_py3.8_cu101 + python_version: '3.8' + pytorch_version: '1.4' + - binary_linux_conda: + cu_version: cu101 + name: binary_linux_conda_py3.7_cu101 + python_version: '3.7' + - binary_linux_conda_cuda: + name: testrun_conda_cuda_py3.7_cu100 + python_version: "3.7" + pytorch_version: "1.4" + cu_version: "cu100" \ No newline at end of file diff --git a/.circleci/regenerate.py b/.circleci/regenerate.py new file mode 100644 index 00000000..21e8d5de --- /dev/null +++ b/.circleci/regenerate.py @@ -0,0 +1,119 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +""" +This script is adapted from the torchvision one. +There is no python2.7 nor macos. +TODO: python 3.8 when pytorch 1.4. +""" + +import os.path +import jinja2 +import yaml + + +def workflows(prefix="", filter_branch=None, upload=False, indentation=6): + w = [] + # add "wheel" here for pypi + for btype in ["conda"]: + for python_version in ["3.6", "3.7", "3.8"]: + for cu_version in ["cu92", "cu100", "cu101"]: + w += workflow_pair( + btype=btype, + python_version=python_version, + cu_version=cu_version, + prefix=prefix, + upload=upload, + filter_branch=filter_branch, + ) + + return indent(indentation, w) + + +def workflow_pair( + *, btype, python_version, cu_version, prefix="", upload=False, filter_branch +): + + w = [] + base_workflow_name = ( + f"{prefix}binary_linux_{btype}_py{python_version}_{cu_version}" + ) + + w.append( + generate_base_workflow( + base_workflow_name=base_workflow_name, + python_version=python_version, + cu_version=cu_version, + btype=btype, + filter_branch=filter_branch, + ) + ) + + if upload: + w.append( + generate_upload_workflow( + base_workflow_name=base_workflow_name, + btype=btype, + cu_version=cu_version, + filter_branch=filter_branch, + ) + ) + + return w + + +def generate_base_workflow( + *, base_workflow_name, python_version, cu_version, btype, filter_branch=None +): + + d = { + "name": base_workflow_name, + "python_version": python_version, + "cu_version": cu_version, + "build_version": "0.1.0", + "pytorch_version": "1.4", + } + + if cu_version == "cu92": + d["wheel_docker_image"] = "pytorch/manylinux-cuda92" + elif cu_version == "cu100": + d["wheel_docker_image"] = "pytorch/manylinux-cuda100" + + if filter_branch is not None: + d["filters"] = {"branches": {"only": filter_branch}} + + return {f"binary_linux_{btype}": d} + + +def generate_upload_workflow( + *, base_workflow_name, btype, cu_version, filter_branch +): + d = { + "name": f"{base_workflow_name}_upload", + "context": "org-member", + "requires": [base_workflow_name], + } + + if btype == "wheel": + d["subfolder"] = cu_version + "/" + + if filter_branch is not None: + d["filters"] = {"branches": {"only": filter_branch}} + + return {f"binary_{btype}_upload": d} + + +def indent(indentation, data_list): + return ("\n" + " " * indentation).join( + yaml.dump(data_list, default_flow_style=False).splitlines() + ) + + +if __name__ == "__main__": + d = os.path.dirname(__file__) + env = jinja2.Environment( + loader=jinja2.FileSystemLoader(d), lstrip_blocks=True, autoescape=False + ) + + with open(os.path.join(d, "config.yml"), "w") as f: + f.write(env.get_template("config.in.yml").render(workflows=workflows)) diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..a757d4ff --- /dev/null +++ b/.clang-format @@ -0,0 +1,85 @@ +AccessModifierOffset: -1 +AlignAfterOpenBracket: AlwaysBreak +AlignConsecutiveAssignments: false +AlignConsecutiveDeclarations: false +AlignEscapedNewlinesLeft: true +AlignOperands: false +AlignTrailingComments: false +AllowAllParametersOfDeclarationOnNextLine: false +AllowShortBlocksOnASingleLine: false +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: Empty +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: true +AlwaysBreakTemplateDeclarations: true +BinPackArguments: false +BinPackParameters: false +BraceWrapping: + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Attach +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: false +ColumnLimit: 80 +CommentPragmas: '^ IWYU pragma:' +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DerivePointerAlignment: false +DisableFormat: false +ForEachMacros: [ FOR_EACH, FOR_EACH_ENUMERATE, FOR_EACH_KV, FOR_EACH_R, FOR_EACH_RANGE, ] +IncludeCategories: + - Regex: '^<.*\.h(pp)?>' + Priority: 1 + - Regex: '^<.*' + Priority: 2 + - Regex: '.*' + Priority: 3 +IndentCaseLabels: true +IndentWidth: 2 +IndentWrappedFunctionNames: false +KeepEmptyLinesAtTheStartOfBlocks: false +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: false +PenaltyBreakBeforeFirstCallParameter: 1 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 200 +PointerAlignment: Left +ReflowComments: true +SortIncludes: true +SpaceAfterCStyleCast: false +SpaceBeforeAssignmentOperators: true +SpaceBeforeParens: ControlStatements +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +Standard: Cpp11 +TabWidth: 8 +UseTab: Never diff --git a/.flake8 b/.flake8 new file mode 100644 index 00000000..13d6d72a --- /dev/null +++ b/.flake8 @@ -0,0 +1,6 @@ +[flake8] +ignore = E203, E266, E501, W503, E221 +max-line-length = 80 +max-complexity = 18 +select = B,C,E,F,W,T4,B9 +exclude = build,__init__.py diff --git a/.github/CODE_OF_CONDUCT.md b/.github/CODE_OF_CONDUCT.md new file mode 100644 index 00000000..f049d4c5 --- /dev/null +++ b/.github/CODE_OF_CONDUCT.md @@ -0,0 +1,76 @@ +# Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to make participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, sex characteristics, gender identity and expression, +level of experience, education, socio-economic status, nationality, personal +appearance, race, religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies within all project spaces, and it also applies when +an individual is representing the project or its community in public spaces. +Examples of representing a project or community include using an official +project e-mail address, posting via an official social media account, or acting +as an appointed representative at an online or offline event. Representation of +a project may be further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at . All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org + +For answers to common questions about this code of conduct, see +https://www.contributor-covenant.org/faq diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 00000000..35587246 --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,54 @@ +# Contributing to PyTorch3D +We want to make contributing to this project as easy and transparent as +possible. + +## Pull Requests +We actively welcome your pull requests. + +However, if you're adding any significant features, please make sure to have a corresponding issue to outline your proposal and motivation and allow time for us to give feedback, *before* you send a PR. +We do not always accept new features, and we take the following factors into consideration: + +- Whether the same feature can be achieved without modifying PyTorch3d directly. If any aspect of the API is not extensible, please highlight this in an issue so we can work on making this more extensible. +- Whether the feature is potentially useful to a large audience, or only to a small portion of users. +- Whether the proposed solution has a good design and interface. +- Whether the proposed solution adds extra mental/practical overhead to users who don't need such feature. +- Whether the proposed solution breaks existing APIs. + +When sending a PR, please ensure you complete the following steps: + +1. Fork the repo and create your branch from `master`. Follow the instructions + in [INSTALL.md](../INSTALL.md) to build the repo. +2. If you've added code that should be tested, add tests. +3. If you've changed any APIs, please update the documentation. +4. Ensure the test suite passes: + ``` + cd pytorch3d/tests + python -m unittest -v + ``` +5. Make sure your code lints by running `dev/linter.sh` from the project root. +6. If a PR contains multiple orthogonal changes, split it into multiple separate PRs. +7. If you haven't already, complete the Contributor License Agreement ("CLA"). + +## Contributor License Agreement ("CLA") +In order to accept your pull request, we need you to submit a CLA. You only need +to do this once to work on any of Facebook's open source projects. + +Complete your CLA here: + +## Issues +We use GitHub issues to track public bugs. Please ensure your description is +clear and has sufficient instructions to be able to reproduce the issue. + +Facebook has a [bounty program](https://www.facebook.com/whitehat/) for the safe +disclosure of security bugs. In those cases, please go through the process +outlined on that page and do not file a public issue. + +## Coding Style +We follow these [python](http://google.github.io/styleguide/pyguide.html) and [C++](https://google.github.io/styleguide/cppguide.html) style guides. + +For the linter to work, you will need to install `black`, `flake`, `isort` and `clang-format`, and +they need to be fairly up to date. + +## License +By contributing to PyTorch3D, you agree that your contributions will be licensed +under the LICENSE file in the root directory of this source tree. diff --git a/.github/ISSUE_TEMPLATE/bugs.md b/.github/ISSUE_TEMPLATE/bugs.md new file mode 100644 index 00000000..d10cb24b --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bugs.md @@ -0,0 +1,28 @@ +--- +name: "πŸ› Bugs / Unexpected behaviors" +about: Please report unexpected behaviors or bugs in PyTorch3d. + +--- + +If you do not know the root cause of the problem / bug, and wish someone to help you, please +post according to this template: + +## πŸ› Bugs / Unexpected behaviors + + +## Instructions To Reproduce the Issue: + +Please include the following (depending on what the issue is): + +1. Any changes you made (`git diff`) or code you wrote +``` + +``` +2. The exact command(s) you ran: +3. What you observed (including the full logs): +``` + +``` + +Please also simplify the steps as much as possible so they do not require additional resources to + run, such as a private dataset. diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 00000000..3ba13e0c --- /dev/null +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1 @@ +blank_issues_enabled: false diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md new file mode 100644 index 00000000..6b6ced73 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -0,0 +1,19 @@ +--- +name: "\U0001F680 Feature Request" +about: Submit a proposal/request for a new PyTorch3d feature + +--- + +## πŸš€ Feature + + +## Motivation + + + +## Pitch + + + +NOTE: we only consider adding new features if they are useful for many users. diff --git a/.github/ISSUE_TEMPLATE/questions-help.md b/.github/ISSUE_TEMPLATE/questions-help.md new file mode 100644 index 00000000..01adeba1 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/questions-help.md @@ -0,0 +1,18 @@ +--- +name: "❓ Questions" +about: How do I do X with PyTorch3d? How does PyTorch3d do X? + +--- + +## ❓ Questions on how to use PyTorch3d + + + +NOTE: + +1. If you encountered any errors or unexpected issues while using PyTorch3d and need help resolving them, + please use the "Bugs / Unexpected behaviors" issue template. + +2. We do not answer general machine learning / computer vision questions that are not specific to + PyTorch3d, such as how a model works or what algorithm/methods can be + used to achieve X. diff --git a/.github/bundle_adjust.gif b/.github/bundle_adjust.gif new file mode 100644 index 00000000..a162b9b0 Binary files /dev/null and b/.github/bundle_adjust.gif differ diff --git a/.github/camera_position_teapot.gif b/.github/camera_position_teapot.gif new file mode 100644 index 00000000..42bcea04 Binary files /dev/null and b/.github/camera_position_teapot.gif differ diff --git a/.github/dolphin_deform.gif b/.github/dolphin_deform.gif new file mode 100644 index 00000000..c3912ba2 Binary files /dev/null and b/.github/dolphin_deform.gif differ diff --git a/.github/pytorch3dlogo.png b/.github/pytorch3dlogo.png new file mode 100644 index 00000000..d8e435cc Binary files /dev/null and b/.github/pytorch3dlogo.png differ diff --git a/.github/render_textured_mesh.gif b/.github/render_textured_mesh.gif new file mode 100644 index 00000000..164651e0 Binary files /dev/null and b/.github/render_textured_mesh.gif differ diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..08eab94d --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +build/ +dist/ +*.egg-info/ +**/__pycache__/ diff --git a/INSTALL.md b/INSTALL.md new file mode 100644 index 00000000..0de6a4fe --- /dev/null +++ b/INSTALL.md @@ -0,0 +1,74 @@ +# Installation + + +## Requirements + +### Core library + +The core library is written in PyTorch. Several components have underlying implementation in CUDA for improved performance. A subset of these components have CPU implementations in C++/Pytorch. It is advised to use PyTorch3d with GPU support in order to use all the features. + +- Linux or macOS +- Python β‰₯ 3.6 +- PyTorch 1.4 +- torchvision that matches the PyTorch installation. You can install them together at pytorch.org to make sure of this. +- gcc & g++ β‰₯ 4.9 +- CUDA 9.2 or 10.0 or 10.1 +- [fvcore](https://github.com/facebookresearch/fvcore) + +These can be installed by running: +``` +conda create -n pytorch3d python=3.6 +conda activate pytorch3d +conda install -c pytorch pytorch torchvision cudatoolkit=10.0 +conda install -c conda-forge -c takatosp1 fvcore +``` + +### Tests/Linting and Demos + +For developing on top of PyTorch3d or contributing, you will need to run the linter and tests. If you want to run any of the notebook tutorials as `docs/tutorials` you will also need matplotlib. +- scikit-image +- black +- isort +- flake8 +- matplotlib +- tdqm +- jupyter +- imageio + +These can be installed by running: +``` +# Demos +conda install jupyter +pip install scikit-image matplotlib imageio + +# Tests/Linting +pip install black isort flake8 +``` + +## Build/Install Pytorch3d +After installing the above dependencies, run one of the following commands: + +### 1. Install from Anaconda Cloud + +``` +# Anaconda Cloud +conda install pytorch3d +``` + +### 2. Install from GitHub +``` +pip install 'git+https://github.com/facebookresearch/pytorch3d.git' +# (add --user if you don't have permission) +``` + +### 3. Install from a local clone +``` +git clone https://github.com/facebookresearch/pytorch3d.git +cd pytorch3d && pip install -e . +``` +To rebuild after installing from a local clone run, `rm -rf build/ **/*.so` then `pip install -e` .. You often need to rebuild pytorch3d after reinstalling PyTorch. + +**Install from local clone on macOS:** +``` +MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ pip install -e . +``` diff --git a/LICENSE b/LICENSE new file mode 100644 index 00000000..ba19f53d --- /dev/null +++ b/LICENSE @@ -0,0 +1,30 @@ +BSD License + +For PyTorch3d software + +Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * 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 Facebook nor 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. diff --git a/README.md b/README.md new file mode 100644 index 00000000..67b712ce --- /dev/null +++ b/README.md @@ -0,0 +1,77 @@ + + +[![CircleCI](https://circleci.com/gh/facebookresearch/pytorch3d.svg?style=svg)](https://circleci.com/gh/facebookresearch/pytorch3d) +[![Anaconda-Server Badge](https://anaconda.org/pytorch3d/pytorch3d/badges/version.svg)](https://anaconda.org/pytorch3d/pytorch3d) + +# Introduction + +PyTorch3d provides efficient, reusable components for 3D Computer Vision research with [PyTorch](https://pytorch.org). + +Key features include: + +- Data structure for storing and manipulating triangle meshes +- Efficient operations on triangle meshes (projective transformations, graph convolution, sampling, loss functions) +- A differentiable mesh renderer + +PyTorch3d is designed to integrate smoothly with deep learning methods for predicting and manipulating 3D data. +For this reason, all operators in PyTorch3d: + +- Are implemented using PyTorch tensors +- Can handle minibatches of hetereogenous data +- Can be differentiated +- Can utilize GPUs for acceleration + +Within FAIR, PyTorch3d has been used to power research projects such as [Mesh R-CNN](https://arxiv.org/abs/1906.02739). + +## Installation + +For detailed instructions refer to [INSTALL.md](INSTALL.md). + +## License + +PyTorch3d is released under the [BSD-3-Clause License](LICENSE). + +## Tutorials + +Get started with PyTorch3d by trying one of the tutorial notebooks. + +||| +|:-----------------------------------------------------------------------------------------------------------:|:--------------------------------------------------:| +| [Deform a sphere mesh to dolphin](https://github.com/fairinternal/pytorch3d/blob/master/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb)| [Bundle adjustment](https://github.com/fairinternal/pytorch3d/blob/master/docs/tutorials/bundle_adjustment.ipynb) | + +| | +|:------------------------------------------------------------:|:--------------------------------------------------:| +| [Render textured meshes](https://github.com/fairinternal/pytorch3d/blob/master/docs/tutorials/render_textured_meshes.ipynb)| [Camera position optimization](https://github.com/fairinternal/pytorch3d/blob/master/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb)| + +## Documentation + +Learn more about the API by reading the PyTorch3d [documentation](https://pytorch3d.readthedocs.org/). + +We also have deep dive notes on several API components: + +- [Heterogeneous Batching](https://github.com/facebookresearch/pytorch3d/tree/master/docs/notes/batching.md) +- [Mesh IO](https://github.com/facebookresearch/pytorch3d/tree/master/docs/notes/meshes_io.md) +- [Differentiable Rendering](https://github.com/facebookresearch/pytorch3d/tree/master/docs/notes/renderer_getting_started.md) + +## Development + +We welcome new contributions to Pytorch3d and we will be actively maintaining this library! Please refer to [CONTRIBUTING.md](./.github/CONTRIBUTING.md) for full instructions on how to run the code, tests and linter, and submit your pull requests. + + +## Contributors + +PyTorch3d is written and maintained by the Facebook AI Research Computer Vision Team. + +## Citation + +If you find PyTorch3d useful in your research, please cite: + +```bibtex +@misc{ravi2020pytorch3d, + author = {Nikhila Ravi and Jeremy Reizenstein and David Novotny and Taylor Gordon + and Wan-Yen Lo and Justin Johnson and Georgia Gkioxari}, + title = {PyTorch3D}, + howpublished = {\url{https://github.com/facebookresearch/pytorch3d}}, + year = {2020} +} +``` diff --git a/dev/linter.sh b/dev/linter.sh new file mode 100755 index 00000000..5923a6d9 --- /dev/null +++ b/dev/linter.sh @@ -0,0 +1,30 @@ +#!/bin/bash -e +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +# Run this script at project root by "./dev/linter.sh" before you commit + +{ + V=$(black --version|cut '-d ' -f3) + code='import distutils.version; assert "19.3" < distutils.version.LooseVersion("'$V'")' + python -c "${code}" 2> /dev/null +} || { + echo "Linter requires black 19.3b0 or higher!" + exit 1 +} + +DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +DIR="${DIR}/.." + +echo "Running isort..." +isort -y -sp "${DIR}" + +echo "Running black..." +black -l 80 "${DIR}" + +echo "Running flake..." +flake8 "${DIR}" + +echo "Running clang-format ..." +find "${DIR}" -regex ".*\.\(cpp\|c\|cc\|cu\|cuh\|cxx\|h\|hh\|hpp\|hxx\|tcc\|mm\|m\)" -print0 | xargs -0 clang-format -i + +(cd "${DIR}"; command -v arc > /dev/null && arc lint) || true diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 00000000..edcd0a80 --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,7 @@ +source +_build +_static +_template +*-checkpoint.ipynb +.ipynb_checkpoints +.ipynb_checkpoints/** diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 00000000..999fabd4 --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,21 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +# Minimal makefile for Sphinx documentation + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 00000000..3ef8ba77 --- /dev/null +++ b/docs/README.md @@ -0,0 +1,78 @@ + +## Setup + +### Install dependencies + +``` +pip install -U recommonmark mock sphinx sphinx_rtd_theme sphinx_markdown_tables +``` + +### Add symlink to the root README.md + +We want to include the root readme as an overview. Before generating the docs create a symlink to the root readme. + +``` +cd docs +ln -s ../README.md overview.md +``` + +In `conf.py` for deployment this is done using `subprocess.call`. + +### Add a new file + +Add a new `.md` or `.rst` file and add the name to the doc tree in `index.rst` e.g + +``` +.. toctree:: + :maxdepth: 1 + :caption: Intro Documentation + + overview +``` + +To autogenerate docs from docstrings in the source code, add the import path for the function e.g. + +``` +Chamfer Loss +-------------------- + +.. autoclass:: loss.chamfer.chamfer_distance + :members: + :undoc-members: + + .. automethod:: __init__ + +```` + +### Build + +From `pytorch3d/docs` run: + +``` +> make html +``` + +The website is generated in `_build/html`. + +### Common Issues + +Sphinx can be fussy, and sometimes about things you weren’t expecting. For example, you might encounter something like: + +WARNING: toctree contains reference to nonexisting document u'overview' +... +checking consistency... +/docs/overview.rst:: +WARNING: document isn't included in any toctree + +You might have indented overview in the .. toctree:: in index.rst with four spaces, when Sphinx is expecting three. + + +### View + +Start a python simple server: + +``` +> python -m http.server +``` + +Navigate to: `http://0.0.0.0:8000/` diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 00000000..7428dd9d --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,200 @@ +# -*- coding: utf-8 -*- +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + +# flake8: noqa + +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +import os +import sys + +import pytorch3d # isort: skip + +import mock +from recommonmark.parser import CommonMarkParser +from recommonmark.states import DummyStateMachine +from sphinx.builders.html import StandaloneHTMLBuilder +from sphinx.ext.autodoc import between + +# Monkey patch to fix recommonmark 0.4 doc reference issues. +orig_run_role = DummyStateMachine.run_role + + +def run_role(self, name, options=None, content=None): + if name == "doc": + name = "any" + return orig_run_role(self, name, options, content) + + +DummyStateMachine.run_role = run_role + + +StandaloneHTMLBuilder.supported_image_types = [ + "image/svg+xml", + "image/gif", + "image/png", + "image/jpeg", +] + +# -- Path setup -------------------------------------------------------------- + + +sys.path.insert(0, os.path.abspath("../")) +sys.path.insert(0, os.path.abspath("../pytorch3d")) +sys.path.insert(0, os.path.abspath("../../")) + +DEPLOY = os.environ.get("READTHEDOCS") == "True" +needs_sphinx = "1.7" + + +# The short X.Y version +version = pytorch3d.__version__ +# The full version, including alpha/beta/rc tags +release = version + +try: + import torch # noqa +except ImportError: + for m in [ + "torch", + "torchvision", + "torch.nn", + "torch.autograd", + "torch.autograd.function", + "torch.nn.modules", + "torch.nn.modules.utils", + "torch.utils", + "torch.utils.data", + "torchvision", + "torchvision.ops", + ]: + sys.modules[m] = mock.Mock(name=m) + +for m in ["cv2", "scipy", "numpy", "pytorch3d._C", "np.eye", "np.zeros"]: + sys.modules[m] = mock.Mock(name=m) + +# -- Project information ----------------------------------------------------- + +project = "PyTorch3D" +copyright = "2019, facebookresearch" +author = "facebookresearch" + +# The full version, including alpha/beta/rc tags +release = "v0.1" + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. + +extensions = [ + "sphinx_markdown_tables", + "sphinx.ext.autodoc", + "sphinx.ext.mathjax", + "sphinx.ext.napoleon", + "sphinx.ext.intersphinx", + "sphinx.ext.todo", + "sphinx.ext.coverage", + "sphinx.ext.viewcode", + "sphinx.ext.githubpages", +] + +# -- Configurations for plugins ------------ +napoleon_google_docstring = True +napoleon_include_init_with_doc = True +napoleon_include_special_with_doc = True +napoleon_numpy_docstring = False +# napoleon_use_param = False +napoleon_use_rtype = False +autodoc_inherit_docstrings = False +autodoc_member_order = "bysource" + +source_parsers = {".md": CommonMarkParser} + + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# +source_suffix = [".rst", ".md"] + +# The master toctree document. +master_doc = "index" + +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = ["_build", "Thumbs.db", ".DS_Store", "build", "README.md"] + +# The name of the Pygments (syntax highlighting) style to use. +pygments_style = "sphinx" + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = "sphinx_rtd_theme" + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] + +html_theme_options = {"collapse_navigation": True} + + +def url_resolver(url): + if ".html" not in url: + url = url.replace("../", "") + return ( + "https://github.com/facebookresearch/pytorch3d/blob/master/" + url + ) + else: + if DEPLOY: + return "http://pytorch3d.readthedocs.io/" + url + else: + return "/" + url + + +def setup(app): + # Add symlink to root README + if DEPLOY: + import subprocess + + subprocess.call(["ln", "-s", "../README.md", "overview.md"]) + + from recommonmark.transform import AutoStructify + + app.add_config_value( + "recommonmark_config", + { + "url_resolver": url_resolver, + "auto_toc_tree_section": "Contents", + "enable_math": True, + "enable_inline_math": True, + "enable_eval_rst": True, + "enable_auto_toc_tree": True, + }, + True, + ) + + # Register a sphinx.ext.autodoc.between listener to ignore everything + # between lines that contain the word IGNORE + app.connect( + "autodoc-process-docstring", between("^.*IGNORE.*$", exclude=True) + ) + app.add_transform(AutoStructify) + + return app diff --git a/docs/figs/architecture_overview.png b/docs/figs/architecture_overview.png new file mode 100644 index 00000000..898d689a Binary files /dev/null and b/docs/figs/architecture_overview.png differ diff --git a/docs/figs/batch_intro.png b/docs/figs/batch_intro.png new file mode 100644 index 00000000..976a82be Binary files /dev/null and b/docs/figs/batch_intro.png differ diff --git a/docs/figs/batch_modes.gif b/docs/figs/batch_modes.gif new file mode 100644 index 00000000..fe9c2b51 Binary files /dev/null and b/docs/figs/batch_modes.gif differ diff --git a/docs/figs/fullset_batch_size_16.png b/docs/figs/fullset_batch_size_16.png new file mode 100644 index 00000000..1f8336dd Binary files /dev/null and b/docs/figs/fullset_batch_size_16.png differ diff --git a/docs/figs/meshrcnn.png b/docs/figs/meshrcnn.png new file mode 100644 index 00000000..a5622407 Binary files /dev/null and b/docs/figs/meshrcnn.png differ diff --git a/docs/figs/opengl_coordframes.png b/docs/figs/opengl_coordframes.png new file mode 100644 index 00000000..ee06ab49 Binary files /dev/null and b/docs/figs/opengl_coordframes.png differ diff --git a/docs/figs/p3d_naive_vs_coarse.png b/docs/figs/p3d_naive_vs_coarse.png new file mode 100644 index 00000000..2e6a3f40 Binary files /dev/null and b/docs/figs/p3d_naive_vs_coarse.png differ diff --git a/docs/figs/p3d_vs_softras.png b/docs/figs/p3d_vs_softras.png new file mode 100644 index 00000000..09540489 Binary files /dev/null and b/docs/figs/p3d_vs_softras.png differ diff --git a/docs/figs/transformations_overview.png b/docs/figs/transformations_overview.png new file mode 100644 index 00000000..893900a0 Binary files /dev/null and b/docs/figs/transformations_overview.png differ diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 00000000..f7cd28f6 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,17 @@ +Welcome to PyTorch3D's documentation! +===================================== + +PyTorch3D is a library of reusable components for Deep Learning with 3D data. + +Table of Contents +================= + +.. toctree:: + :maxdepth: 2 + + overview + +.. toctree:: + :maxdepth: 2 + + modules/index diff --git a/docs/modules/index.rst b/docs/modules/index.rst new file mode 100644 index 00000000..cb35988c --- /dev/null +++ b/docs/modules/index.rst @@ -0,0 +1,13 @@ +API Documentation +================== + +.. toctree:: + + structures + io + loss + ops + renderer/index + transforms + utils + \ No newline at end of file diff --git a/docs/modules/io.rst b/docs/modules/io.rst new file mode 100644 index 00000000..a30c6dd5 --- /dev/null +++ b/docs/modules/io.rst @@ -0,0 +1,7 @@ +pytorch3d.io +=========================== + +.. automodule:: pytorch3d.io + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/modules/loss.rst b/docs/modules/loss.rst new file mode 100644 index 00000000..3ae9fdcb --- /dev/null +++ b/docs/modules/loss.rst @@ -0,0 +1,9 @@ +pytorch3d.loss +==================== + +Loss functions for meshes and point clouds. + +.. automodule:: pytorch3d.loss + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/modules/ops.rst b/docs/modules/ops.rst new file mode 100644 index 00000000..148b6b3d --- /dev/null +++ b/docs/modules/ops.rst @@ -0,0 +1,6 @@ +pytorch3d.ops +=========================== + +.. automodule:: pytorch3d.ops + :members: + :undoc-members: \ No newline at end of file diff --git a/docs/modules/renderer/blending.rst b/docs/modules/renderer/blending.rst new file mode 100644 index 00000000..0233a0c3 --- /dev/null +++ b/docs/modules/renderer/blending.rst @@ -0,0 +1,7 @@ +blending +=========================== + +.. automodule:: pytorch3d.renderer.blending + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/modules/renderer/cameras.rst b/docs/modules/renderer/cameras.rst new file mode 100644 index 00000000..33e634dc --- /dev/null +++ b/docs/modules/renderer/cameras.rst @@ -0,0 +1,7 @@ +cameras +=========================== + +.. automodule:: pytorch3d.renderer.cameras + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/modules/renderer/index.rst b/docs/modules/renderer/index.rst new file mode 100644 index 00000000..48dffc31 --- /dev/null +++ b/docs/modules/renderer/index.rst @@ -0,0 +1,15 @@ +pytorch3d.renderer +=========================== + +.. toctree:: + + rasterizer + cameras + lighting + materials + texturing + blending + shading + shader + renderer + utils \ No newline at end of file diff --git a/docs/modules/renderer/lighting.rst b/docs/modules/renderer/lighting.rst new file mode 100644 index 00000000..e33c22c6 --- /dev/null +++ b/docs/modules/renderer/lighting.rst @@ -0,0 +1,6 @@ +lighting +=========================== + +.. automodule:: pytorch3d.renderer.lighting + :members: + :undoc-members: \ No newline at end of file diff --git a/docs/modules/renderer/materials.rst b/docs/modules/renderer/materials.rst new file mode 100644 index 00000000..b01d9fd8 --- /dev/null +++ b/docs/modules/renderer/materials.rst @@ -0,0 +1,7 @@ +materials +=========================== + +.. automodule:: pytorch3d.renderer.materials + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/modules/renderer/rasterizer.rst b/docs/modules/renderer/rasterizer.rst new file mode 100644 index 00000000..f6dfa1fd --- /dev/null +++ b/docs/modules/renderer/rasterizer.rst @@ -0,0 +1,10 @@ +rasterizer +=========================== + +.. automodule:: pytorch3d.renderer.mesh.rasterize_meshes + :members: + :undoc-members: + +.. automodule:: pytorch3d.renderer.mesh.rasterizer + :members: + :undoc-members: \ No newline at end of file diff --git a/docs/modules/renderer/shader.rst b/docs/modules/renderer/shader.rst new file mode 100644 index 00000000..076492bb --- /dev/null +++ b/docs/modules/renderer/shader.rst @@ -0,0 +1,7 @@ +shader +=========================== + +.. automodule:: pytorch3d.renderer.mesh.shader + :members: + :undoc-members: + \ No newline at end of file diff --git a/docs/modules/renderer/shading.rst b/docs/modules/renderer/shading.rst new file mode 100644 index 00000000..f9bcac4a --- /dev/null +++ b/docs/modules/renderer/shading.rst @@ -0,0 +1,7 @@ +shading +=========================== + +.. automodule:: pytorch3d.renderer.mesh.shading + :members: + :undoc-members: + diff --git a/docs/modules/renderer/texturing.rst b/docs/modules/renderer/texturing.rst new file mode 100644 index 00000000..2375a5fe --- /dev/null +++ b/docs/modules/renderer/texturing.rst @@ -0,0 +1,7 @@ +texturing +=========================== + +.. automodule:: pytorch3d.renderer.mesh.texturing + :members: + :undoc-members: + \ No newline at end of file diff --git a/docs/modules/renderer/utils.rst b/docs/modules/renderer/utils.rst new file mode 100644 index 00000000..9c96613d --- /dev/null +++ b/docs/modules/renderer/utils.rst @@ -0,0 +1,6 @@ +utils +=========================== + +.. automodule:: pytorch3d.renderer.utils + :members: + :undoc-members: \ No newline at end of file diff --git a/docs/modules/structures.rst b/docs/modules/structures.rst new file mode 100644 index 00000000..1f73a559 --- /dev/null +++ b/docs/modules/structures.rst @@ -0,0 +1,8 @@ +pytorch3d.structures +==================== + +.. automodule:: pytorch3d.structures + :members: + :undoc-members: + + diff --git a/docs/modules/transforms.rst b/docs/modules/transforms.rst new file mode 100644 index 00000000..3962f7f1 --- /dev/null +++ b/docs/modules/transforms.rst @@ -0,0 +1,7 @@ +pytorch3d.transforms +=========================== + +.. automodule:: pytorch3d.transforms + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/modules/utils.rst b/docs/modules/utils.rst new file mode 100644 index 00000000..3aaf1df1 --- /dev/null +++ b/docs/modules/utils.rst @@ -0,0 +1,7 @@ +pytorch3d.utils +==================== + +.. automodule:: pytorch3d.utils + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/notes/batching.md b/docs/notes/batching.md new file mode 100644 index 00000000..c3628307 --- /dev/null +++ b/docs/notes/batching.md @@ -0,0 +1,27 @@ +# Batching + +In deep learning, every optimization step operates on multiple input examples for robust training. Thus, efficient batching is crucial. For image inputs, batching is straighforward; N images are resized to the same height and width and stacked as a 4 dimensional tensor of shape `N x 3 x H x W`. For meshes, batching is less straighforward. + +batch_intro + +## Batch modes for meshes + +Assume you want to construct a batch containing two meshes, with `mesh1 = (v1: V1 x 3, f1: F1 x 3)` containing `V1` vertices and `F1` faces, and `mesh2 = (v2: V2 x 3, f2: F2 x 3)` with `V2 (!= V1)` vertices and `F2 (!= F1)` faces. The [Meshes][meshes] data structure provides three different ways to batch *heterogeneous* meshes. If `meshes = Meshes(verts = [v1, v2], faces = [f1, f2])` is an instantiation of the data structure, then + +* List: Returns the examples in the batch as a list of tensors. Specifically, `meshes.verts_list()` returns the list of vertices `[v1, v2]`. Similarly, `meshes.faces_list()` returns the list of faces `[f1, f2]`. +* Padded: The padded representation constructs a tensor by padding the extra values. Specifically, `meshes.verts_padded()` returns a tensor of shape `2 x max(V1, V2) x 3` and pads the extra vertices with `0`s. Similarly, `meshes.faces_padded()` returns a tensor of shape `2 x max(F1, F2) x 3` and pads the extra faces with `-1`s. +* Packed: The packed representation concatenates the examples in the batch into a tensor. In particular, `meshes.verts_packed()` returns a tensor of shape `(V1 + V2) x 3`. Similarly, `meshes.faces_packed()` returns a tensor of shape `(F1 + F2) x 3` for the faces. In the packed mode, auxiliary variables are computed that enable efficient conversion between packed and padded or list modes. + +batch_modes + +## Use cases for batch modes + +The need for different mesh batch modes is inherent to the way pytorch operators are implemented. To fully utilize the optimized pytorch ops, the [Meshes][meshes] data structure allows for efficient conversion between the different batch modes. This is crucial when aiming for a fast and efficient training cycle. An example of this is [Mesh R-CNN][meshrcnn]. Here, in the same forward pass different parts of the network assume different inputs, which are computed by converting between the different batch modes. In particular, [vert_align][vert_align] assumes a *padded* input tensor while immediately after [graph_conv][graphconv] assumes a *packed* input tensor. + +meshrcnn + + +[meshes]: https://github.com/facebookresearch/pytorch3d/blob/master/pytorch3d/structures/meshes.py +[graphconv]: https://github.com/facebookresearch/pytorch3d/blob/master/pytorch3d/ops/graph_conv.py +[vert_align]: https://github.com/facebookresearch/pytorch3d/blob/master/pytorch3d/ops/vert_align.py +[meshrcnn]: https://github.com/facebookresearch/meshrcnn diff --git a/docs/notes/meshes_io.md b/docs/notes/meshes_io.md new file mode 100644 index 00000000..771cabb9 --- /dev/null +++ b/docs/notes/meshes_io.md @@ -0,0 +1,67 @@ +# Meshes and IO + +The Meshes object represents a batch of triangulated meshes, and is central to +much of the functionality of pytorch3d. There is no insistence that each mesh in +the batch has the same number of vertices or faces. When available, it can store +other data which pertains to the mesh, for example face normals, face areas +and textures. + +Two common file formats for storing single meshes are ".obj" and ".ply" files, +and pytorch3d has functions for reading these. + +## OBJ + +Obj files have a standard way to store extra information about a mesh. Given an +obj file, it can be read with + +``` + verts, faces, aux = load_obj(filename) +``` + +which sets `verts` to be a (V,3)-tensor of vertices and `faces.verts_idx` to be +an (F,3)- tensor of the vertex-indices of each of the corners of the faces. +Faces which are not triangles will be split into triangles. `aux` is an object +which may contain normals, uv coordinates, material colors and textures if they +are present, and `faces` may additionally contain indices into these normals, +textures and materials in its NamedTuple structure. A Meshes object containing a +single mesh can be created from just the vertices and faces using +``` + meshes = Meshes(verts=[verts], faces=[faces.verts_idx]) +``` + +If there is texture information in the `.obj` it can be used to initialize a +`Textures` class which is passed into the `Meshes` constructor. Currently we +support loading of texture maps for meshes which have one texture map for the +entire mesh e.g. + +``` +verts_uvs = aux.verts_uvs[None, ...] # (1, V, 2) +faces_uvs = faces.textures_idx[None, ...] # (1, F, 3) +tex_maps = aux.texture_images + +# tex_maps is a dictionary of {material name: texture image}. +# Take the first image: +texture_image = list(tex_maps.values())[0] +texture_image = texture_image[None, ...] # (1, H, W, 3) + +# Create a textures object +tex = Textures(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image) + +# Initialise the mesh with textures +meshes = Meshes(verts=[verts], faces=[faces.verts_idx], textures=tex) +``` +## PLY + +Ply files are flexible in the way they store additional information, pytorch3d +provides a function just to read the vertices and faces from a ply file. +The call +``` + verts, faces = load_ply(filename) +``` +sets `verts` to be a (V,3)-tensor of vertices and `faces` to be an (F,3)- +tensor of the vertex-indices of each of the corners of the faces. Faces which +are not triangles will be split into triangles. A Meshes object containing a +single mesh can be created from this data using +``` + meshes = Meshes(verts=[verts], faces=[faces]) +``` diff --git a/docs/notes/renderer.md b/docs/notes/renderer.md new file mode 100644 index 00000000..2b2089da --- /dev/null +++ b/docs/notes/renderer.md @@ -0,0 +1,115 @@ +# Differentiable Rendering + +Differentiable rendering is a relatively new and exciting research area in computer vision, bridging the gap between 2D and 3D by allowing 2D image pixels to be related back to 3D properties of a scene. + +For example, by rendering an image from a 3D shape predicted by a neural network, it is possible to compute a 2D loss with a reference image. Inverting the rendering step means we can relate the 2D loss from the pixels back to the 3D properties of the shape such as the positions of mesh vertices, enabling 3D shapes to be learnt without any explicit 3D supervision. + +We extensively researched existing codebases for differentiable rendering and found that: +- the rendering pipeline is complex with more than 7 separate components which need to interoperate and be differentiable +- popular existing approaches [[1](#1), [2](#2)] are based on the same core implementation which bundles many of the key components into large CUDA kernels which require significant expertise to understand, and has limited scope for extensions +- existing methods either do not support batching or assume that meshes in a batch have the same number of vertices and faces +- existing projects only provide CUDA implementations so they cannot be used without GPUs + +In order to experiment with different approaches, we wanted a modular implementation that is easy to use and extend, and supports [heterogeneous batching](batching.md). + +Taking inspiration from existing work [[1](#1), [2](#2)], we have created a new, modular, differentiable renderer with **parallel implementations in PyTorch, C++ and CUDA**, as well as comprehensive documentation and tests, with the aim of helping to further research in this field. + +Our implementation decouples the rasterization and shading steps of rendering. The core rasterization step (based on [[2]](#2)) returns several intermediate variables and has an optimized implementation in CUDA. The rest of the pipeline is implemented purely in PyTorch, and is designed to be customized and extended. With this approach, the PyTorch3d differentiable renderer can be imported as a library. + +## Get started + +To learn about more the implementation and start using the renderer refer to [renderer_getting_started.md](renderer_getting_started.md), which also contains the [architecture overview](../figs/architecture_overview.png) and [coordinate transformation conventions](../figs/transformations_overview.png). + + +## Key features + +### 1. CUDA support for fast rasterization of large meshes + +We implemented modular CUDA kernels for the forward and backward pass of rasterization, adaptating a traditional graphics approach known as "coarse-to-fine" rasterization. + +First, the image is divided into a coarse grid and mesh faces are allocated to the grid cell in which they occur. This is followed by a refinement step which does pixel wise rasterization of the reduced subset of faces per grid cell. The grid cell size is a parameter which can be varied (`bin_size`). + +We additionally introduce a parameter `faces_per_pixel` which allows users to specify the top K faces which should be returned per pixel in the image (as opposed to traditional rasterization which returns only the index of the closest face in the mesh per pixel). The top K face properties can then be aggregated using different methods (such as the sigmoid/softmax approach proposed by Li et at in SoftRasterizer [[2]](#2)). + +We compared PyTorch3d with SoftRasterizer to measure the effect of both these design changes on the speed of rasterization. We selected a set of meshes of different sizes from ShapeNetV1 core, and rasterized one mesh in each batch to produce images of different sizes. We report the speed of the forward and backward passes. + +**Fig 1: PyTorch3d Naive vs Coarse-to-fine** + +This figure shows how the coarse-to-fine strategy for rasterization results in significant speed up compared to naive rasterization for large image size and large mesh sizes. + + + + +For small mesh and image sizes, the naive approach is slightly faster. We advise that you understand the data you are using and choose the rasterization setting which suits your performance requirements. It is easy to switch between the naive and coarse-to-fine options by adjusting the `bin_size` value when initializing the [rasterization settings](https://github.com/facebookresearch/pytorch3d/blob/master/pytorch3d/renderer/mesh/rasterizer.py#L26). + +Setting `bin_size = 0` will enable naive rasterization. If `bin_size > 0`, the coarse-to-fine approach is used. The default is `bin_size = None` in which case we set the bin size based on [heuristics](https://github.com/facebookresearch/pytorch3d/blob/master/pytorch3d/renderer/mesh/rasterize_meshes.py#L92). + +**Fig 2: PyTorch3d Coarse-to-fine vs SoftRasterizer** + +This figure shows the effect of the _combination_ of coarse-to-fine rasterization and caching the faces rasterized per pixel returned from the forward pass. For large meshes and image sizes, we again observe that the PyTorch3d rasterizer is significantly faster, noting that the speed is dominated by the forward pass and the backward pass is very fast. + +In the SoftRasterizer implementation, in both the forward and backward pass, there is a loop over every single face in the mesh for every pixel in the image. Therefore, the time for the full forward plus backward pass is ~2x the time for the forward pass. For small mesh and image sizes, the SoftRasterizer approach is slightly faster. + + + + + +### 2. Support for Heterogeneous Batches + +PyTorch3d supports efficient rendering of batches of meshes where each mesh has different numbers of vertices and faces. This is done without using padded inputs. + +We again compare with SoftRasterizer which only supports batches of homogeneous meshes and test two cases: 1) a for loop over meshes in the batch, 2) padded inputs, and compare with the native heterogeneous batching support in PyTorch3d. + +We group meshes from ShapeNet into bins based on the number of faces in the mesh, and sample to compose a batch. We then render images of fixed size and measure the speed of the forward and backward passes. + +We tested with a range of increasingly large meshes and bin sizes. + +**Fig 3: PyTorch3d heterogeneous batching compared with SoftRasterizer** + + + +This shows that for large meshes and large bin width (i.e. more variation in mesh size in the batch) the heterogeneous batching approach in PyTorch3d is faster than either of the workarounds with SoftRasterizer. + +(settings: batch size = 16, mesh sizes in bins ranging from 500-350k faces, image size = 64, faces per pixel = 100) + +--- + +**NOTE: CUDA Memory usage** + +The SoftRasterizer forward CUDA kernel only outputs one `(N, H, W, 4)` FloatTensor compared with the PyTorch3d rasterizer forward CUDA kernel which outputs 4 tensors: + + - `pix_to_face`, LongTensor `(N, H, W, K)` + - `zbuf`, FloatTensor `(N, H, W, K)` + - `dist`, FloatTensor `(N, H, W, K)` + - `bary_coords`, FloatTensor `(N, H, W, K, 3)` + +where **N** = batch size, **H/W** are image height/width, **K** is the faces per pixel. The PyTorch3d backward pass returns gradients for `zbuf`, `dist` and `bary_coords`. + +Returning intermediate variables from rasterization has an associated memory cost. We can calculate the theoretical lower bound on the memory usage for the forward and backward pass as follows: + +``` +# Assume 4 bytes per float, and 8 bytes for long + +memory_forward_pass = ((N * H * W * K) * 2 + (N * H * W * K * 3)) * 4 + (N * H * W * K) * 8 +memory_backward_pass = ((N * H * W * K) * 2 + (N * H * W * K * 3)) * 4 + +total_memory = memory_forward_pass + memory_backward_pass + = (N * H * W * K) * (5 * 4 * 2 + 8) + = (N * H * W * K) * 48 +``` + +We need 48 bytes per face per pixel of the rasterized output. In order to remain within bounds for memory usage we can vary the batch size (**N**), image size (**H/W**) and faces per pixel (**K**). For example, for a fixed batch size, if using a larger image size, try reducing the faces per pixel. + +--- + + +### 3. Modular design for easy experimentation and extensibility. + +We redesigned the rendering pipeline from the ground up to be modular and extensible and challenged many of the limitations in existing libraries. Refer to [renderer_getting_started.md](renderer_getting_started.md) for a detailed description of the architecture. + + +### References + +[1] Kato et al, 'Neural 3D Mesh Renderer', CVPR 2018 + +[2] Liu et al, 'Soft Rasterizer: A Differentiable Renderer for Image-based 3D Reasoning', ICCV 2019 diff --git a/docs/notes/renderer_getting_started.md b/docs/notes/renderer_getting_started.md new file mode 100644 index 00000000..7e7debcc --- /dev/null +++ b/docs/notes/renderer_getting_started.md @@ -0,0 +1,81 @@ +# Renderer Getting Started + +### Architecture Overview + +The renderer is designed to be modular, extensible and support batching and gradients for all inputs. The following figure describes all the components of the rendering pipeline. + + + +##### Fragments + +The **rasterizer** returns 4 output tensors in a named tuple. + +- **`pix_to_face`**: LongTensor of shape `(N, image_size, image_size, faces_per_pixel)` specifying the indices of the faces (in the packed faces) which overlap each pixel in the image. +- **`zbuf`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel)` giving the z-coordinates of the nearest faces at each pixel in world coordinates, sorted in ascending z-order. +- **`bary_coords`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel, 3)` + giving the barycentric coordinates in NDC units of the nearest faces at each pixel, sorted in ascending z-order. +- **`pix_dists`**: FloatTensor of shape `(N, image_size, image_size, faces_per_pixel)` giving the signed Euclidean distance (in NDC units) in the x/y plane of each point closest to the pixel. + + +See the renderer API reference for more details about each component in the pipeline. + +--- + +**NOTE:** + +The differentiable renderer API is experimental and subject to change!. + +--- + +### Coordinate transformation conventions + +Rendering requires transformations between several different coordinate frames: world space, view/camera space, NDC space and screen space. At each step it is important to know where the camera is located, how the x,y,z axes are aligned and the possible range of values. The following figure outlines the conventions used PyTorch3d. + + + + + +--- + +**NOTE: PyTorch3d vs OpenGL** + +While we tried to emulate several aspects of OpenGL, the NDC coordinate system in PyTorch3d is **right-handed** compared with a **left-handed** NDC coordinate system in OpenGL (the projection matrix switches the handedness). + +In OpenGL, the camera at the origin is looking along `-z` axis in camera space, but it is looking along the `+z` axis in NDC space. + + + +--- +### A simple renderer + +A renderer in PyTorch3d is composed of a **rasterizer** and a **shader**. Create a renderer in a few simple steps: + +``` +# Imports +from pytorch3d.renderer import ( + OpenGLPerspectiveCameras, look_at_view_transform, + RasterizationSettings, BlendParams, + MeshRenderer, MeshRasterizer, PhongShader +) + +# Initialize an OpenGL perspective camera. +R, T = look_at_view_transform(2.7, 10, 20) +cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + +# Define the settings for rasterization and shading. Here we set the output image to be of size +# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1 +# and blur_radius=0.0. Refer to rasterize_meshes.py for explanations of these parameters. +raster_settings = RasterizationSettings( + image_size=512, + blur_radius=0.0, + faces_per_pixel=1, + bin_size=0 +) + +# Create a phong renderer by composing a rasterizer and a shader. Here we can use a predefined +# PhongShader, passing in the device on which to initialize the default parameters +renderer = MeshRenderer( + rasterizer=MeshRasterizer(cameras=cameras, raster_settings=raster_settings), + shader=PhongShader(device=device, cameras=cameras) +) +``` diff --git a/docs/tutorials/bundle_adjustment.ipynb b/docs/tutorials/bundle_adjustment.ipynb new file mode 100644 index 00000000..250dc4cf --- /dev/null +++ b/docs/tutorials/bundle_adjustment.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + " \"Open\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Absolute camera orientation given set of relative camera pairs\n", + "\n", + "This tutorial showcases the `cameras`, `transforms` and `so3` API.\n", + "\n", + "The problem we deal with is defined as follows:\n", + "\n", + "Given an optical system of $N$ cameras with extrinsics $\\{g_1, ..., g_N | g_i \\in SE(3)\\}$, and a set of relative camera positions $\\{g_{ij} | g_{ij}\\in SE(3)\\}$ that map between coordinate frames of randomly selected pairs of cameras $(i, j)$, we search for the absolute extrinsic parameters $\\{g_1, ..., g_N\\}$ that are consistent with the relative camera motions.\n", + "\n", + "More formally:\n", + "$$\n", + "g_1, ..., g_N = \n", + "{\\arg \\min}_{g_1, ..., g_N} \\sum_{g_{ij}} d(g_{ij}, g_i^{-1} g_j),\n", + "$$,\n", + "where $d(g_i, g_j)$ is a suitable metric that compares the extrinsics of cameras $g_i$ and $g_j$. \n", + "\n", + "Visually, the problem can be described as follows. The picture below depicts the situation at the beginning of our optimization. The ground truth cameras are plotted in green while the randomly initialized estimated cameras are plotted in blue:\n", + "![Initialization](./data/bundle_adjustment_initialization.png)\n", + "\n", + "Our optimization seeks to align the estimated (blue) cameras with the ground truth (green) cameras, by minimizing the discrepancies between pairs of relative cameras. Thus, the solution to the problem should look as follows:\n", + "![Solution](./data/bundle_adjustment_final.png)\n", + "\n", + "In practice, the camera extrinsics $g_{ij}$ and $g_i$ are represented using objects from the `SfMPerspectiveCameras` class initialized with the corresponding rotation and translation matrices `R_absolute` and `T_absolute` that define the extrinsic parameters $g = (R, T); R \\in SO(3); T \\in \\mathbb{R}^3$. In order to ensure that `R_absolute` is a valid rotation matrix, we represent it using an exponential map (implemented with `so3_exponential_map`) of the axis-angle representation of the rotation `log_R_absolute`.\n", + "\n", + "Note that the solution to this problem could only be recovered up to an unknown global rigid transformation $g_{glob} \\in SE(3)$. Thus, for simplicity, we assume knowledge of the absolute extrinsics of the first camera $g_0$. We set $g_0$ as a trivial camera $g_0 = (I, \\vec{0})$.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Import Modules" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": { + "bento_obj_id": "139627658883376" + }, + "output_type": "execute_result" + } + ], + "source": [ + "# imports\n", + "import torch\n", + "from pytorch3d.transforms.so3 import (\n", + " so3_exponential_map,\n", + " so3_relative_angle,\n", + ")\n", + "from pytorch3d.renderer.cameras import (\n", + " SfMPerspectiveCameras,\n", + ")\n", + "\n", + "# add path for demo utils\n", + "import sys\n", + "import os\n", + "sys.path.append(os.path.abspath(''))\n", + "from utils import plot_camera_scene\n", + "\n", + "# set for reproducibility\n", + "torch.manual_seed(42)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Set up Cameras and load ground truth positions" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# load the SE3 graph of relative/absolute camera positions\n", + "camera_graph_file = './data/camera_graph.pth'\n", + "(R_absolute_gt, T_absolute_gt), \\\n", + " (R_relative, T_relative), \\\n", + " relative_edges = \\\n", + " torch.load(camera_graph_file)\n", + "\n", + "# create the relative cameras\n", + "cameras_relative = SfMPerspectiveCameras(\n", + " R = R_relative.cuda(),\n", + " T = T_relative.cuda(),\n", + " device = \"cuda\",\n", + ")\n", + "\n", + "# create the absolute ground truth cameras\n", + "cameras_absolute_gt = SfMPerspectiveCameras(\n", + " R = R_absolute_gt.cuda(),\n", + " T = T_absolute_gt.cuda(),\n", + " device = \"cuda\",\n", + ")\n", + "\n", + "# the number of absolute camera positions\n", + "N = R_absolute_gt.shape[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Define optimization functions\n", + "\n", + "### Relative cameras and camera distance\n", + "We now define two functions crucial for the optimization.\n", + "\n", + "**`calc_camera_distance`** compares a pair of cameras. This function is important as it defines the loss that we are minimizing. The method utilizes the `so3_relative_angle` function from the SO3 API.\n", + "\n", + "**`get_relative_camera`** computes the parameters of a relative camera that maps between a pair of absolute cameras. Here we utilize the `compose` and `inverse` class methods from the PyTorch3d Transforms API." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def calc_camera_distance(cam_1, cam_2):\n", + " \"\"\"\n", + " Calculates the divergence of a batch of pairs of cameras cam_1, cam_2.\n", + " The distance is composed of the cosine of the relative angle between \n", + " the rotation components of the camera extrinsics and the l2 distance\n", + " between the translation vectors.\n", + " \"\"\"\n", + " # rotation distance\n", + " R_distance = (1.-so3_relative_angle(cam_1.R, cam_2.R, cos_angle=True)).mean()\n", + " # translation distance\n", + " T_distance = ((cam_1.T - cam_2.T)**2).sum(1).mean()\n", + " # the final distance is the sum\n", + " return R_distance + T_distance\n", + "\n", + "def get_relative_camera(cams, edges):\n", + " \"\"\"\n", + " For each pair of indices (i,j) in \"edges\" generate a camera\n", + " that maps from the coordinates of the camera cams[i] to \n", + " the coordinates of the camera cams[j]\n", + " \"\"\"\n", + "\n", + " # first generate the world-to-view Transform3d objects of each \n", + " # camera pair (i, j) according to the edges argument\n", + " trans_i, trans_j = [\n", + " SfMPerspectiveCameras(\n", + " R = cams.R[edges[:, i]],\n", + " T = cams.T[edges[:, i]],\n", + " device = \"cuda\",\n", + " ).get_world_to_view_transform()\n", + " for i in (0, 1)\n", + " ]\n", + " \n", + " # compose the relative transformation as g_i^{-1} g_j\n", + " trans_rel = trans_i.inverse().compose(trans_j)\n", + " \n", + " # generate a camera from the relative transform\n", + " matrix_rel = trans_rel.get_matrix()\n", + " cams_relative = SfMPerspectiveCameras(\n", + " R = matrix_rel[:, :3, :3],\n", + " T = matrix_rel[:, 3, :3],\n", + " device = \"cuda\",\n", + " )\n", + " return cams_relative" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Optimization\n", + "Finally, we start the optimization of the absolute cameras.\n", + "\n", + "We use SGD with momentum and optimize over `log_R_absolute` and `T_absolute`. \n", + "\n", + "As mentioned earlier, `log_R_absolute` is the axis angle representation of the rotation part of our absolute cameras. We can obtain the 3x3 rotation matrix `R_absolute` that corresponds to `log_R_absolute` with:\n", + "\n", + "`R_absolute = so3_exponential_map(log_R_absolute)`\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139627339758864" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBpY/Do4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139627220918224" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXd4HPW5PX6mbF+tepcsWcVFlm2M\nCzbGkAAmtiEOLU64gdgUJyGEQEiAJDiFBAiBewO/EEIKN3BpMSZAfoGEUEIv7t3IWL231Wp7nZn3\n+4c8w+xqV1ppV2vL7HmefaSdnT6fOfPOW87LEBHSSCONNNJIDdgTvQNppJFGGp8lpEk3jTTSSCOF\nSJNuGmmkkUYKkSbdNNJII40UIk26aaSRRhopBD/O7+nUhjTSSCONiYOJ9UPa0k0jjTTSSCHSpJtG\nGmmkkUKctKSr1+vx4osvnrDtb968GZdeeukJ234aU4u3334bDMPAarUCJ8F4S+Ozg5OWdP1+Py65\n5BIAQFtbG5555pkp3V7kNv785z/jhRdemNJtxsKLL74IhmHw+OOPK9OcTie+/vWvo7S0FHl5ebj4\n4ovR29ur/N7d3Y2LL74YBQUFKC4uxte//nW4XK4Tsv/TEerxNhYkScK9996bkn1KFvx+P2666Saw\nLIu//e1vcS/X2dmJjIwMbNq0SZkWCoVw++23o6KiAmazGfPmzcOjjz6q/E5E+PWvf42amhqYzWbM\nnz8fTz/9dEL7P97Y7+rqwle+8hUUFhYiNzcXF110EY4dO5bQNqcSJy3pqvH8889POemmYhvxwOl0\n4uabb4bJZAqb/s1vfhNdXV3YtWsXGhsbodfrcfnllyu/X3755TAajTh69Cj27t2Ljo4OfOtb3zoB\nR3BqY9++fbjrrrtO9G7Ejb6+PixZsgRerxcTLfn/9re/DY7jwqb96le/wrZt2/DGG2/A6XTigQce\nwPXXX4///Oc/AIDf/va3ePDBB7Ft2zbY7Xbcfvvt2LhxI/bu3TvpYxhv7K9fvx4AcPToUTQ1NUGn\n02HDhg2T3t6Ug4jG+pwwAKDnnnuOfvnLXxLLssSyLOl0Ourq6iJJkujee++lWbNmkcFgoFmzZtET\nTzyhLLtx40b62te+Rl/84hcpIyODiIiGh4fpa1/7GhUWFpLZbKbly5fT9u3biYiibmPjxo104YUX\nKuv817/+RYsXLyaTyURFRUV0yy23UDAYJCKixx57jGpra+n555+n2tpaMhqN9LnPfY66u7uJiOi6\n664jnU4X9aPebyKi66+/nq6//nqqqKigxx57jIiIBgcHieM4+uCDD5T5Ojo6CADt27eP9u3bRwCo\nq6tL+f3dd98ljuPIarUSEdHq1avp5ptvjnm+Dx48SOeccw6ZTCYqLy+ne+65R/mtvb2d1q9fT3l5\neWSxWOi8886jTz75RPm9oqKCfvvb39LatWvJaDTSnDlz6MCBA3TnnXdSXl4e5eXl0YMPPqjM73A4\n6Nprr6WysjIyGo105pln0s6dO8PW94tf/ILmzp1L69atIyKiAwcO0Lnnnks5OTmUnZ1Nl1xyCfX2\n9sY1loiI9uzZQ4sXLyaj0UjLli2jRx55hADQ4OAgkWq8ERHt3LmTVq5cSRaLhbKysmjdunXU0dFB\n77zzDvE8TwBIp9PRM888Q0REv//972nWrFlkMploxowZ9Otf/1rZ7nhjg4joueeeo3nz5pHRaKT6\n+np66aWXlN8aGhpozZo1lJubSxaLhb785S9Tf38/ERE98cQTMcfVddddR0REhw4doq1bt446xvHw\n7LPP0vz58+nKK6+kjRs3KtPXrVtH11xzTdi81dXV9N///d9ERPTggw/Sk08+GfZ7RUUFPfDAA0RE\n4967kRhv7A8PD9PVV19N7e3tyu9vvfUWASCbzRbXsU4RYvLqSU+6dJxE1QT4u9/9jsrKyujgwYMk\nCAL985//JK1WS7t27VLmz8nJoaeffppEUSQios2bN9OKFSvIbrdTIBCg7373u1RWVqasM3Ib6u9H\njhwhlmXpiSeeoEAgQPv376eysjK68847iY7fWGazma6++mqy2+3U3d1NFRUV9L3vfW9Cx/zBBx9Q\naWkp2e32MNJ97bXXCAD5fL6w+fPz8+lPf/oT/elPf6LCwsKw3zweDwGg1157bdztejweKi0tpZ/+\n9Kfk9XrpwIEDlJWVpZDK6tWr6bLLLiOv10sej4cuu+wyOuuss5TlKyoqqLa2lvbu3UtOp5NOP/10\nKisro/vuu48CgQDdc889pNPpyOFwEBHR5ZdfTqtXr6a+vj7y+Xz085//nPLz88nr9Srrq66upoMH\nD5IkSUREVFtbSzfddBMFg0Gy2Wx05pln0pVXXhnXeRVFkSorK+mb3/wmeb1e+vjjj6m+vj4m6dbW\n1tKWLVsoFAqRw+GgK6+8kjZs2EB0/FqbTKawa8ayLH300UdERPT+++8Tz/P0xhtvKPOPNTb27NlD\ner2eXnrpJQqFQvTUU0+RTqej1tZW8vl8VF5eTrfffjt5vV4aHBykiy66iC666KK4jjsS8ZLu8PAw\nlZSU0EcffUQbN24MI90//OEPVFZWRocOHSJRFOmVV14ho9FIhw4diroul8tFZrNZ2e54924kxhv7\n0fDYY4+RxWIhQRDGPdYpxKlFuvPnzw+zJoiILr30UrrhhhuU+WtqasJ+DwQC5HK5lO8ffPABAVCs\npbFI9+abb6aVK1eGre/OO++kuXPnEh2/yJGW5tVXX01r1qyJ+3iDwSDNmzdPOWY16T799NOk1+tH\nLTN79my655576O6776Y5c+aM+l1tjY2FF154gYxGI/n9fmXam2++Sfv27SMiIq/XqxCivD86nU75\nXlFRQd/5zneU77feeitlZWUpD7wjR44QADp06BANDg4SwzC0Y8cOZX5Jkig3Nzfs2GVLTYbL5Qrb\nv7vvvptmz5497rEREW3fvp0AUGdnpzLtgQceiEm6+fn59Ktf/UqZVz4OikK6kiTR8PBw2PZqa2uV\n5ccbG9/97nfpvPPOC1v+2Wefpa6uLnr++efJbDaHkcfBgweJYRgaGBiI69jViJd0r7vuurB7SU26\nREQ33XQTASCGYUiv19Pjjz8edT2SJNEVV1xBCxYsoFAoRBTHvRuJ8cZ+JNrb26mgoIDuu+++cY9z\nihGTV6eFTzcSx44dw5YtW6DX65XPSy+9hI6ODmWemTNnhi3T2tqKr3zlK8jNzYVOp8PnP/954HiQ\nYTy0tLSgrq4ubFpNTQ1aWlqU73q9HqWlpcp3o9EIn88X9zHde++9qKqqCvNVjQciAsPEzMEe93cZ\nzc3NKC4uhk6nU6Z9/vOfx2mnnQYAOHDgANauXYusrCzo9Xps2rQJgUAgbB3l5eXK/0ajEcXFxWBZ\nVvmO4+e6qakJRISzzz5buXYGgwEOhwPt7e3KOiKv3zvvvINVq1bBYrFAr9fjZz/7WVzXDscDLVqt\nFmVlZcq0efPmxZz/vvvuw1133YU5c+bgxhtvxHvvvRdzXkmS8Ktf/QoVFRUwGAzQ6/VoamoK27ex\nxkZzczMqKyvD1rlhwwaUlpbi2LFj8Hg8MJlMyrlaunQpWJYNO1fJxLvvvot///vfuOeee6L+fv/9\n9+PVV1/F/v374fV68cILL+C73/0uXn311bD5AoEAvvrVr2L37t14+eWXwfMjdVjx3LvxINrYPnTo\nEFauXIlLL70Ut95664SPPVWYlqRrMBjwxz/+EX6/X/kEg0H84x//UObRarXK/5IkYd26ddDpdDh0\n6BACgQDefffduLcX7eaODEpEBhzU2Lx5c9ggU3+efPJJfPLJJ3jooYfw8MMPR12+sLAQfr8fHo8n\nbLrVakVhYSEKCwuV1CcZLpcLwWAQhYWF4x4fwzCQJCnqbw6HA2vWrEFdXR2am5vh9/vx5JNPjppP\nJthY32UYDAYAQENDQ9j1C4VC+P73v6/Mp75+x44dw6WXXor169eju7sbfr9/QsGsQCAw6vhiHS8A\nbNq0CV1dXdiyZQsGBwfxhS98AT/84Q+jzvvLX/4Sjz32GJ555hm43W74/X7Mnj07bJ6xxsZY595g\nMKC8vDzsPPn9fgiCgCVLluDJJ5+MOa42b948zlkZjUAggG984xv43e9+B4vFEnWe3/zmN/je976H\nhQsXQq/XY+3atVi/fj3+93//V5nH6XTivPPOQ09PDz788MOwB/J49676GO66665xx76Mt956C6tW\nrcK3v/1tPPLIIxM+9lRiWpJubW0t9u/fHzato6MDoihGnX9gYAAtLS248cYbUVJSAgDYs2dP3Nur\nqanBoUOHwqYdOXIEtbW1cS3/5z//edSNI3+uuuoqbN26FQ6HA4sWLUJeXh7y8vLQ2dmJG2+8EV/6\n0pewaNEi8DyP3bt3K+tsamqCzWbDihUrsGzZMlitVrS1tSm/79ixAzqdDosXL47r+Lq7u+F2u5Vp\n//rXv/DKK6+goaEBDocDt956K3Jzc4EJnrtIzJw5ExzHjbp+ra2tMZfZu3cvRFHED3/4Q2RkZEx4\nH0pLSyEIAnp6epRpkddTDavViqysLFx55ZXYunUrfv/738e8kbdv3461a9di5cqV4DgONpttzGOJ\nRE1NDT755JOwaX/84x9x+PBh1NbWoqenB4ODg8pvfr8ffX19AICrrroq5rj685//HPc+qI/l2LFj\nuPbaa5VxuHXrVmzduhV5eXnA8ZSxyPtM/dYTDAZx0UUXIT8/H2+88YaynIzx7l31MWzZsmXcsQ8A\nu3fvxiWXXIJHHnkEP/rRjyZ83KnGtCBdg8GAzs5O2O12BINB3HDDDfjLX/6C119/HYIg4KOPPsLi\nxYvx0ksvRV0+Ly8PZrMZH3zwAYLBIF599VVl3u7u7qjbUGPTpk3YuXMnnn76aQiCgD179uDRRx/F\nNddck5Tj+973vofm5mbs379f+ZSUlOAXv/gFHn30UeTk5OCKK67Ali1b0NPTg6GhIdx222244IIL\nMGfOHMyfPx+rVq3CrbfeCpvNhu7ubvzsZz/Dxo0bY1osaqxduxb5+fn4yU9+Ao/Hg4aGBlxzzTUY\nGhrCjBkzwLIs3n//ffj9fvz1r3/F9u3bw87dRGCxWHDVVVdhy5YtaGxshCAI+Mtf/oL6+vowUlRj\n5syZEEURH330EdxuNx566CG0tbVheHgYXq933G2eccYZyM3NxT333AOfz4fDhw+H5UCr0dXVhZKS\nEjz//PMQRRE+nw/79+9XHrAGgwE+nw/t7e3weDyYOXMmDh48CKfTiba2NnzrW99CRUVF3Ofmmmuu\nwc6dO7F161aEQiG8+OKLuPnmm2EwGHDBBRegsrISN954I4aGhpR0wrVr18a17niwc+dOzJkzB3a7\nHcuXL0dHR0fYOFy/fj3Wr1+vEOUll1yChx56CEePHoUgCHjzzTfxz3/+UykkeuCBB+ByufDss8+G\nuatkTPTeHW/si6KIa665BnfccQeuuOKKpJ2XKcV0CKS99957lJ+fT2azmXbv3k2SJNE999xD5eXl\npNfradasWfTII48oy0YGxYiI/vrXv1JpaSmZzWa69NJLyWq10rnnnksmk4l27tw5ahuR69i6dSud\ndtppZDabadasWfQ///M/SmQ9MrhCRHTDDTfQOeecM+njVwfS6Hgg6eqrr6bMzEzKyMigL3/5y0o6\nGBFRX18fXXLJJWQ2mykrK4s2b94cFvwaL2Xs2LFjtHLlStLr9VRRUREWpPjNb35D+fn5lJmZSZs3\nb6bBwUGaP38+ZWZmKtH4+++/X5n/Zz/7Gc2bN0/53traSgCUCLXD4aCrr76acnJylPS9t99+O+zY\n1esjIvr+979PWVlZlJeXRz/+8Y+ptbWVKioqKC8vL67z+eGHH9LChQvJYDDQ0qVL6amnnooZSHvu\nueeovr6ejEYj5eTk0Lp16+jo0aNERGS1Wqm+vp60Wi099NBD1NHRQWeddRYZjUaqq6uj//znP/SH\nP/yBjEYj3XLLLXGNjZdeeolqa2vJYDDQggULwlLGjhw5QqtXr1b25eKLL6a2tra4jpmOp0PKaWQA\nSKPRkE6no9WrVxOp0qvk8xCJyECay+Wim2++mSoqKshkMlFdXR09/PDDyu/V1dXEcVzMFLbx7t1o\nGGvsv/feewSAtFrtqG2+8847cZ+nKUBMXmXGSZhOq4ydInj33Xfx8ssv47777kvqeokIwWAQgiCA\n53lwHAeO4+IK4KWRximMmDfAeNKOaZwieOGFF3DBBRckbX2SJKG/vx8cx8FsNkMQBIiiiM7OTuh0\nOhQUFIBlWTAMoxCxTMZpQk7js4y0pZvGhCCKIkRRhCRJaGtrA8Mw8Hq9EAQBZrMZbrcbZrMZpaWl\nYBhGyfJQp/gkk4x37tyJs88+e8x5Dh48iFmzZk3yiNNIY1KIOZjTpJvGuCAiSJKkkC0AeDweHDx4\nEIIgoKamBjzPw+v1oq+vD6FQSCFVk8kEk8kEo9EIk8kEnU6nkKvi44ogY5ZlFVdF2jJOY5oiTbpp\nTBwy2QqCoFisTqcTLS0tEAQBJpMJGRkZKCkpgSAIYBgGXV1dYFlWmeb1euHxeJRPIBAAy7KjyFiv\n148iYxzPY02TcRrTEGmfbhrxg4gUN4JMgHa7HS0tLWBZFlVVVcjKykJHR8eoyiC1S4HneVgsllFp\na6IoKmTscDjQ09MDv98PlmUVEpYJ2WAwKPsgiiKCwSCcTiecTqeSzsYwjELG8vc00jhZkSbdNBRE\nki0ADA4OorW1FXq9HrNnz1aKE3DcHRCZKD9WhZUMjuOQkZERti4cJ2OfzwePxwOn04ne3l6lGlBN\nxoIgKNMlSQIRIRQKKdtXW8ccx4Hn+TQZp3HSIE26aYCIlOwD+XtfXx/a29thsVgwf/58RT9BDbVV\nO9a0eCFnQpjN5rDpkiQpZOx2uzE8PKxYyQaDIcwyNhqNCvHLx+X3+9NknMZJgzTpfoZBRBgYGIDJ\nZALP8yAidHd3o6OjA7m5uVi0aBH0en3M5WMR7GRJNxbUPmAAyMrKgtVqRXV1tVKX7/F4MDg4qIh1\nq8nYZDLBYDCA47gwMpbLVyPJOJ1rnMZUIk26n0HIpCNJEtrb21FZWamUDxcVFWHp0qVhgjOxEMvS\nTRVkH7DRaER+fr4ynYjg8/kUv/HQ0BC8Xi8kSYJerw8jY6PROIqM5WPq7u5GSUkJtFptmozTSBrS\npPsZgpyJIPtcQ6EQ3G43Dhw4gBkzZmD58uWKBF88YFl2FOmyLDuuT3eqwTCMQsZqwRUigt/vV8hY\n1m4QRRE6nW4UGdtsNqXIQ03GY1nGaUJOYzykSfczAHVBA46rQrW1tWFoaAg8z6Ourg7Z2dkTXm+s\noFmy3QvRMJltMAwDg8EAg8GgKKZBVcrsdrvh9XrR09Oj+I+PHDmCjIyMMDLWaDRhuctTVfiRxqmJ\nNOmeoohW0ODz+dDa2gqn04nKykrMmjULR48enfQ2TpR7IdnbYBgGOp0OOp0ujIz37duH2tpaBINB\npfDD4/FAEARoNJowy9hkMilkLGeBpAs/0oiGNOmeYohW0OB2u9HS0gK/34+ZM2eirq4ujAwm6w6Q\nSTdWnu6pAJ1OB7PZjJycnLDpwWAQHo8HXq8XAwMD8Hg8CIVC4Hl+XDIOBoNh599msyE3N1fxHafJ\n+NRGmnRPEUTLsXU4HGhpaYEkSaiqqkJ2dvaomzkZpDvetFMRWq0WWq12lFsmFAop2RRWqxXt7e0I\nBoNhJdHyR6vVgojQ3NwMi8UCQRCAKLnGGo0GLMum09tOEaRJd5ojGtkODQ2htbUVPM+juroamZmZ\nMZdPhCSjBdJOJdKNt8ecGhqNBllZWcjKygqbLgiCQsY2mw2dnZ0IBALgOA4+nw9dXV0wm82KPgXS\nhR+nLNKkO00hpzcNDQ2ht7cXc+fOxcDAAFpbW2EymTB37txRRQbRkLZ0x0ayyIzneWRmZo56AIqi\niF27dkGr1cJutys94CJLomV9CqjIOF34MT2RJt1phsjqMYZh4HK58NFHHyErKwsLFy5Umj/Gg0RJ\nN3LZVJBuqogkFQ8POcOhuLg4bHqkPkVvby98Pp+SDhdZ+IE4yFgmZI1GkybjE4g06U4TqAsa5GBZ\nV1eX0rp62bJlUXtSjYd4tBLGWvZEWbqp2saJIqdY+hSSJClk7HK50N/fr7Rzj1aFpy6Jbm9vh16v\nR0FBgULA6Sq81CNNuic5IgsaRFFER0cHenp6UFxcjIULF6K5uXlShIsYftl4wTAMRFFEc3Mz7HY7\nTCYTOI5DMBiEJEkx27CnMXmwLDuuPoW6JBrH25qbTCZ4PB6lHXykPkW68CN1SJPuSYrIgoZQKIS2\ntjYMDg6irKwMK1asAMdxCAQCCVWARVMKiwfBYBAdHR2wWq3IyclBdXU1fD4fbDYb3G630iJdvuHl\nIJHBYJg2ZHwiLd2JIlKfQoYkSYo+xfDwMKxWK/r7+2OWRMsP4XThx9QhTbonEaIVNPj9fqXdeEVF\nBWpqasJIa7KkqV5ejo7HA3U1W1FREXJyclBeXo5gMKgEewRBQF1dnaKBIFtfAwMDo16F1WR8Mt68\nJ+M+TQRqfYrh4WEUFBQgKytLKYlWZ1So9SkidY1lQaSxCj/SZBwf0qR7EiBaQYPX60VLSws8Hg8q\nKysxZ86cqIM4Ua2DeN0Lfr8fra2tGB4eRmVlJWpraxEIBGC328PmU/t01RoIakGaSKlGtV9SfbOb\nzeawjhJpJAZRFMPcC3JJdKQ+RSAQUMi4u7s7TJ8iMogXi4ybmppQU1OjCMunq/A+RZp0TyBkS9Bu\ntysVTy6XCy0tLQgGg6iqqkJubu6YgzRR0h0vkCaXDjscDsycOTOM/CcbSBvrVVgdJOrr64PP5xuV\nPiX7ItOYGOLxszMMA71eD71eH1WfQibj3t5eeDweiKIIjUYDs9kcdo3sdrsytuQqPETkGstk/Fkr\n/EiT7gmAuqDB6/Wiq6sLDMOgpaUFDMMo1WPxINGBGou0ZUvb7XZj5syZmDt37qhtJVtPN1aQKDJ9\nyuFwKFay2uoym83QarXT6uZV94ObaiQS3FTrU6hLouXiDZmM+/v7lf/37dsX1gdPrsKT9yUWGTOn\nePulNOmmEJE5tjheqmu1WgFgVDucVCDSveDxeNDc3Ayfz4eqqirMmzcv5qBPleBNZPqU0+lET08P\namtrlRt8eHgYXV1dSpVXtJLbk/HmJaKUBRbV7oVkgWGYqCXRu3btQn19fVg2RVtbW5g+RSwyVmdU\nnIqFH2nSTQGikW1fXx/a2tqUQbdw4cITsm/yK6Db7UZzczMCgUBcbg1EWMnqoEqqLDeO46I2vlSX\n3A4NDaGjowPBYDCqGE08Yu1TiVRmSKQ6jS9WSXQoFAoTmJevj/phKRNyZEl0tMIPt9sNi8UCjUaj\nBKEnUiCUaqRJdwoRWdBAROjp6UFHRwdycnKwaNEi8DyvpFedCPh8PgwMDMDtdqO6unqUmtZYSLZ7\nIVmIVXIr3+xut3uU5SVnUaiVwVIBSZJOOdIdL8ag0WiiXh9BEMIE5uU3F3UMQCZjdUn00aNHUV9f\nD41Gg8HBQfj9fsybN29KjzERpEl3ChCtoKGrqwvd3d0oKCjAkiVLFAtL9u+mGg6HA83NzQgGgzCb\nzVi8ePGE1zHdtBdi3exyBw21T1IQBPh8PjQ2No6K1icTqXQvpMqqnqwbg+f5qG8ukT79np6eMH0K\nr9cLh8MBSZKUN5qpQCAQwMMPPwyHw4FQKITLLrtsUvdNmnSTiMiCBkEQ0NHRgb6+PpSUlOCMM84Y\nNSCSdRPEe0MNDw8rAbvq6mqwLIvW1tZJbfNU0dPVaDTIzs4eFbzcsWMH8vLy4Ha7w6L1Wq12lGU8\nWV9pKkkXKco7FkUxqcQXqyRaFEX4fD4MDw/D5XLhlVdeQXt7OwwGAyorK1FWVoY1a9ZE7WQ9GezZ\nswfV1dX40pe+hMHBQdx1111p0j0RiFbQEAwG0dbWBqvVivLycixfvjzpAQw1opFfJGw2G5qbm8Hz\nPGpraxVrwuPxJKS9EGtfphKpInaWZUeRcWTqVGQeq7rgQ256ORZS6V5IFaYiYBcNHMfBbDZDo9Gg\nqqoKN9xwg6Kyp9Vq0dXVlVTyP/PMM5X/h4aGJuSKUyNNupOETLYdHR0wm83IyMgIa4dTUVGB2tra\nlFgxckArcltEhKGhIbS0tECn02HOnDmjrIVkN5KcjpbuRDBW6pS6qCCywkud1iaX22KalRrHi1SR\nLqLED0RRhMFgQElJCcrLy6dkm1u2bMHQ0BB++MMfTmr5NOlOEJGi4XKblra2Nvh8vlHtcFIBuYW4\neh+tVitaWlpgMBgwb968UYUIMpKdbXCqk24sjFVUoC63HRoags/nAxFBr9dDo9EolvNU61Kk6rqk\nknQlSQrbllysMZW466670NbWhoceegj333//hO/1NOnGCZls1S1VHA4H+vv7AQBz585FTk7OpMk2\nEYtH1l8gIkXI3Gw2Y/78+eP6sxKRdoy1vs8i6cbCWOW2Pp8PVqsVTqcTbW1tiipYNInGRMk4ldck\nlaQrCEKYCyHZ/mQ1WlpaYLFYkJeXh8rKSoiiCKfTOWZnlmhIk+44iJZja7PZ0NLSAp7nkZ+fD6PR\nGGbdTBTyK/5kByrDMOjv70dvby8yMzMnJGQ+Fe6FNMaHrEuRmZkJn8+H2bNnA1EkGtUiQdHEy+M9\n39O9CCMWopHuVFm6H3/8MaxWKzZt2gS73Q6/3z+pYqY06cZANLIdGBhAW1sbDAaD0g6nu7t7Qipd\n0cBx3KQGqiRJ6Ovrg81mA8uyWLRokZK/GC+SRbpp/dzJIfINJ1FdCjmHNZKMU3l9TiTpRn5PJi64\n4AI88sgj+OlPf4pgMIhrr712Uuc0TboRkDMRZLIlIqV6LCsra9QrO8/z8Pv9CW0z0icbzz7KRRa5\nubnIz89HRUXFhAkXSXAHiKKIffv2we12K0GmQCCAvr6+UUGjNEYjXjKMV5dCncMaWeyRStKdKuKL\nRCrdC1qtFjfddFPC60mT7nFEFjRIkoTu7m50dnYiLy8PixcvjtqdgeM4xc87WcSriSvvU0dHB/Lz\n85Uii4aGhkkXWEzWHeByudCvivJ9AAAgAElEQVTU1AS/34/6+nqYzWZIkoRAIIB9+/YhEAjAZrPB\n4/EASdbPPZX8xolmL4yVw6rWpXA6nXC5XNizZ8+U61IIgjApA2Cy25JJVs4oSpWVPVl85kk3sqBB\nFEV0dnaiu7sbxcXFWLZs2Zg+Itk1kAjGW4dc0dbV1YXCwsJR+5Rsv+xYcLlcaG5uhiAISreI7Oxs\nhEIhJYLP8zwqKiqUZdR+yshXY3Uq1cksTDNVmKo83UhdCo/Hg7a2NsyePVsphZ4qXYoT5V4QBGFa\n9Hn7TJKu/EQcHByEz+dDcXExQqEQ2tvbMTAwgNLSUqUdznjgeT5hSzcW6aofAEVFRVEr2pAi0pXJ\nNhQKoaamJm7pSUT4KQsKCpTp8qux2+2GzWYLIwCZhOW/qXpdTTVSFeCS3RixSm2TqUuRatKVrepU\nujUSwcm/h0lEZIeGUCgEu90Oh8OB4eFhzJgxAytWrJjQTTAVlq5cPtzb2xuzfDhy+akiXbfbjaam\nJoRCoQkL4oyHWK/Gsj6r2+1GX18f3G53WMUXz/MIhUKnRPAuVRVp4xHhWLoU6g4fsi6FLFweTZfi\nRFm6adI9iRBZ0MAwDLxeLzo7O+FwOFBXVxezHc544Hk+KaQrSZJibff396OsrCzu8uFE+6RFw0TI\nNtn+1WiSgHL5rWwVezwe7N27F0Q0Jf3WUuUzTrWlO1HEkmeM1UVCq9XC5/NhaGgIkiQp/dWmCtHc\nCyc7TmnSjUz7YhgmrB1OUVEReJ5HUVHRpLeRjEAaAHR3d6OxsRHl5eUTtraT6V5Q6+rW1NSMa9mm\nKqilLr/V6XQIhUJhzS/dbrdiGatTqdRuipPRX5yqMuBkvxVEEy6XH4wHDx5Ugr6RuhTqUuhkEGQk\n6aYt3ROEaGQrq2sBUNrhyBVBiSARwpM76/b09CAvL2/CZKveh0QtXTXZVldXx13scaIyCaI1v1RD\n7S9Wa7PKASP1q3E0H+V0JcNYEEVxyrcjPxhZlsWMGTMUUo3Upejs7IxLlyIepN0LJxjRChqsVita\nW1uh1WrD1LWQpCDYZG7MyM66NTU1Cd18HMdNukDD4/HA5/PhyJEjimU7kWM6EaQbz/6N5y+O1M6N\ntMRS1YU4leSeSj0E9ViOV5dCdhupXUZq8fJo90ekpZsq8flEcEqQbmRBAwD09/ejra0NZrM5puBL\nMkh3IlB31lW3Ve/t7VVKPSeDyVi66l5oWq0WS5YsmdRNOd1yZsfzF8uWmEwEhw4dCnNRJMNfrEYq\nuzmcbLq94+lSyNfAarXG1KUQBEE5LtmnfLJjWpNuZI6tuh1OdnY2TjvttDGTtFPl35M767pcLlRV\nVY3qrJtoBsREXBxqspXdCDt37pz0tuPR8j3ZofYXy5aYIAg4cOAAqqurlei9rIMguzSS4S9OpaU7\nHV69EeEyys/PV6bH0qXYvXs39uzZA57nMXv2bJjNZhQUFCT9IfPUU0+hoaEBkiTh4osvxhlnnDGp\n9UyPqxABURTR09Oj1JxLkqQUD0S2w0kVot08Ho8HLS0t8Hg8Y3bWTTTlKx7S9Xq9aG5uhtfrVchW\n3hdZaWwylm6iYj0nM2Ld/OrS28guxJH5xeO97qbSpxutonI6IZouxc6dO7F48WJkZ2fjwIED6Onp\nUYRp7r777qSNy8OHD6OzsxN33303XC4Xbrvtts8O6QqCAEEQYLfbIQgC+vv7x2yHkwrIlqq8bTko\n5ff7RxFcNCQaCBuLtNVkW1VVhby8vFH7kkgwcKzmlNPZ+h1r/2P5i+UuxLJV7Ha7IQjCmO19TrWA\nXSpdTfK5Y1kWNTU1EEURM2bMCCvASRbq6upQU1MDADCZTAgEApM+p9OOdFmWRTAYhN1uR09PD6qq\nqhJqhyNbeYkMSDlX1+fzKVVbVVVVcQelkuFeiFxedmnIXX6jka16+cneLGr3gjqj4FQm3ViI1oVY\n3d7H7Xaju7tbaZFkMBgQCASUQNNUipin0qI+UQpjU+lCYVlWcVW++eabWLRo0aTP57QjXYfDgf37\n98NisaCgoAAzZsxIaH1yMC0Rd4QkSTh48KDS7HEiJbJIsk83kmxjuTTUSETI/ER0BE5lbnAy1hGr\nvY/cbTgQCKC1tVUJpqotYrPZDJ1Ol/C+pIoMT7Ss41RnL+zatQtvvvkmtmzZMul1TDvStVgsWLFi\nBQYGBuByuRJeXyKka7fb0dzcDI/Hg9raWpSWlk5qH5JBuqFQCIcPH4bb7R7Tfxxr+elEuqlAKppr\nGo1G6PV6FBUVKdaxrJvrdrvhcDjQ3d2t+IvVvmK5IWO8+CxYulOdp7t//3688MILuOOOOxLqMDzt\nSJdlWTAMk7R0r8mU8UZ21u3u7k7oIiQSSPP5fGhqaoLdbseCBQsmRLYyEiFdlmXh9XrR3t6uiKNI\nkpQy1bOpxInwtcbSzVX7iwcHB9Ha2jpKA0H+G4300qSbGLxeL5566in85Cc/GXVtJoppR7oyNBpN\nwh0bMIFcXSJSyFar1YZ11u3r60voATAZS9fn86GlpUXpPOzz+SYdQJisZerz+WC32+F0OjFz5kxI\nkgS32w2fz4d9+/aFWWfyZzokryPF2gvxkHs0fzGOayDI+cVqf7Ferw8j41RUpCHFpbiRWrpTSbof\nfvghXC4XHnjgAWXad77znbD84ngx7UhXHqDJtHTHIu/Izrp1dXWjnnSJugcm4lP1+/1obm6G0+lE\ndXU16urqlFbwk8VELd1AIICWlhbY7XYYDAZUV1cjIyNDWYfT6cScOXPA83xU60yO5sufk7G7xHTJ\nKtBqtcjJyRnlL/b7/QoZDw4OYnh4GIcOHRqlX5zsyrsTqTA2lVq6559/Ps4///ykrGvakS6Ok9RU\nW7oT6ayb6AMgnoHi9/vR0tICh8OBqqqqsDbviQrexLt8MBhEa2srhoaGUFVVhTlz5qChoWHUfPJ+\nRQppI6L6SxbSlquNIgsOkhFAmixSRbpTsR11pZecX7x3717U19cr517d2kd+I4kUk58MUk268rZS\nud1EMS1JF0m2dNXrISL09/ejtbUVFoslrs66ydDUjYVIso2sZkMSfI/jkW4oFEJbWxsGBgZQWVmJ\nWbNmhRVWRAukxVpftOovjBFAiiZofiohlWXAPM8rbxlqyP5i2SqWBczj9RercaIEzKeLwhimM+km\nyzqQG0sSEXp7e9HW1obs7OwJddbleR7BYDAp+yNDTbYzZ86MSrbJQiyfriAIaG9vR19fX0yB92g5\nvpPZz1gBpFAopLwmy7qtoVAIgiCgpaVFWSbZmgjT2dKNhrHE0uP1F8syjbIymEzEavdQqptSygQ/\nXbR0MV1JN5kpSRzHwWazobe3Fzk5OTEbUI63jmQJ56gVyGJZtslGpKUrtwnq6uoaV0w9llWbrOuj\n0WiQnZ0dlvvs9Xpx7NgxZGRkKNVfXq9XKRON1EQ4mZFKIZqJjqOx/MWyr14tRmM0GhEMBpGRkQGf\nzzflSm3qvFxRFKdNkHZakq4ak7UUZJHl1tZW8DyfkF5DMtwLkiShoaFBIdvJdrKYDGTSlTUsOjs7\nUVxcjOXLl49rtZyo4giO45Cfnz9KE0Emg6GhIbS3tyMUCkGr1YZlUZhMpnGJ7lSzdJO1jVjKYLJ7\nqKWlBX6/H42NjYq/OJo4UDIQ6dNNuxemEJEZDBN5wqk76xYUFGD+/Pno6upKaCAk0rJHzgTw+Xyw\nWCwpJVs1hoaG0NraisLCwglpWKgJViaQE1UcES1wB9VrstvtVmQbiUghg2iR/JPhtX86QXYP6fV6\nFBQUKNKZsR6EGo1mlJj8RElTfe+nfbopgpzBEA/pql+Z1a3VfT5fUrr5TnQdcumnzWbDzJkz4Xa7\nkZ+fn9ANOFGiICL09fWhvb0dZrMZS5cunfDDJ5rOwomsSCMiOHoIniEJpQtGhne012RZJjBaJN9s\nNit++lTczKcC6cqI9K2O9SCUyVjdY20inSTUQbvpImCO6Uq6E8nVlTvr9vT0oLS0dNQr81S2UI8G\nNdlWVlZi9uzZYBgGfX19Cef6xku6cjpcS0sLsrKyUFlZCYZhJmXtxwqkpYp03YMSrM0SxCABDAMh\nQDj2poCmtwWsu1MPTguY81kUzmHBsJ+eG7VMYGFhoTJdEATFV+nz+XDgwIFRwSM5cJcMX2wqLOpU\nPgDjzV6I1WMtEAgowTt1OqHBYAhzUej1+jB/uCiKCVWFphLTknRljJWrGwqF0NHRgb6+PpSWlmLF\nihVRB0MygmDxELc6x1VNtjISlXeU/bJjEYFc6NHc3IyMjAwlQ6OnpweBQGBS240WSJtq0n3zVyLc\nvlz05fhhKWZQXM/BmMOCCGjfIeK0yzQ4Y5MWHz0axJfuM8DVL6H5vZHrozEwKF3IgdfFjuRnZWWB\nYRiIoojZs2ePCh4NDg6GidOoCz1OxsBdKhXfEvGtqtv6RPqL5bcSl8uF3t5e+P1+eL1eNDQ0oKmp\nCRzHYeHChVN2rB0dHbj//vtx4YUXYs2aNQmta1qTbjSyCwaDaG9vx8DAAMrLy8eVfUxE1lDGWJZu\nJNmqc1zjXUe8+zBWru3Q0BCamppgNBqxYMGCMKsgEZJMdSDN7yQY8xiUf86KBQtKIIYIIR/g7JXQ\n+JaA6lU8Gt8OoaSeQ1YZg6c3ebBisw4sz4AI8NkJ7z4UgBAELvhxfCmBsYJH6uaXkf7KePNbp0PV\n20QwFXm60cTLAWDHjh0oLS1FW1sbGhsb8fHHH8Pn8yEvLw+33XZb0rbv9/vx2GOPob6+Pinrm5ak\nKw9UtaUrk5vVakVFRcWkO+smsj9qqMm2oqICtbW1Y+7PVGjq4rgSWmNjIzQaDebNmxdVrGM6qYz1\nfSyicA4D+VHLaRj47BKGOyWs/OZIyxzvMKH6LB4152iw68kRC75q5adDfc4FGjS/P/abSTwWUywx\n81h6CHKnE9kqjjcPPFGksmAh1cI6FosFa9euRWVlpdIwIJF+g9Gg0Wjwox/9CH//+9+Tsr5pSboy\neJ6Hz+fD0aNHYbPZ4iK3qUYwGERbW5tC/vHuT7L7pDmdTjQ2NoJhmDBxnniWnQhSTbq9h0XMWsOg\n2zby3d4lYahFxOzzowdRll6lw8t3+FAwi4U5X3Udxtm9eF9Tdz0VgL2ToDECWWUszHkMGI4FYAFg\ngRaAdmSFCDgDGPb70ev3w++3IxgMoX9fHt6/yYUvb3PE3eJnojgZm1Imikg3hjpPd7wK0omC47ik\nPrSmJekyDAO/34++vj5FXCXSRzpRJOoLIiIcO3YMg4ODSlv1iQz0ZPVJc7vdaGxshCiKqK2tHVVl\nFGtZNUk+sdGB3iMC1v3cBINl7GOwWjkMfAI0GXzwOgWE3IDDnglGYrFqswCGA0gaITmikb+SBHiH\nCM4+CXVrNcgojP88ua0EUx4D2IChVhGufkL12WOT1Lo79Xj+Jh8uf8gQFkxLBuydhNU/0iPoIdi7\nJbgHaeR4AYAZOV5eD2SVccgoMIHlRt402rYLOPSPECTvMGaePTL21C1+dDpdmIsiEVGgVJNuKhAK\nhVIuYJ4sTEvSDQaD2L9/P/Lz86HX61FcXJzQ+iaT76vel7a2Nng8noTcGokG0iRJwieffAJJklBb\nWzuh7hWRwbAzrzXAnM/i/65yAAC+dK8ZnEadEvbpso4uDq3/YRHy+lH/lQDqL9NjcMCNof1ZcA8S\nRGFkfoYZISGGARgWyChkkD2Dh2uAkFGICYFhGDg7tMguIVQuH38IszyD1T/S49W7/Fjz0/isoHgf\nwgwLSAJBa2JQMItDwazR84R8I4Tctl1C+04Bh18Kofx0DkXzOGSd0wf/vrowAXx1FD+WKJA6cDfe\nfqZK1jGViGbppvN0pxBarRbLly+Hy+VCa2trwuubDOmqRWAqKiqQkZGB4uLiSQ/uyboX5L5sw8PD\nqKysVNK/JoJo7oWiuTzmr9fh9A16/N9VDlSeocGGhzLC1t38fgDuoSAsc30omc9h/5+ycOBJoHS1\nAE1GP/ILemDJjk0QHpsEV9/E3BAMA/QdkUACg/LT4x++WWUsZq7gsf9vQdSt00AzDvfGS7pF8zj0\nNUgomR/79ZPXjQTwmt8VkD+LxfX/NoPXMmh+T4BNL8IfMf9YUXw5cDc8PIzOzk4Eg0FFFEhd6KF+\nHU5Vt+ZUpqZF09JNay9MIaIF0hLBRHJ1I8lWtmx7e3sTuvAcx03oWNSCONXV1eB5HhkZGZNykcTK\n4CACiubwuH1XLpreDeK+pTacdqkOX/ixGcPDw/jgOTtKP2dHZY4Ji1bNxOc2htCxU8RHz2TD3c7D\nfC4Hnc4TRhByZN9sNoMNmiGRHkD856z7oIiypSwMBUGIAoHjRx8vH0M6Y/ZqDd7+//xofFtA6YLk\n3KAVyzgcfikUlXQlkdCxS0THbgGWYharbtBBb1Hv74grIt5LNp4oULTGl2azWSGlqU4dS6VFrSZd\n2X0yVdtuaWnBE088gcHBQXAch+3bt+MHP/jBpDtITEvSxXHinSp5x2hQk200xa1EG1xyHAe/P9Lm\nGY1gMIiWlhbYbLYwQRyHwxG3T1gIEJz9Epx9Ehw9IhrfE1D79U+XJRpttdScrcXtu3PxweN2/HrJ\nEGovHUZ2Vi4yORMsxU5l/oozeHR3BiC6GPTuMWDobzxWXJePmtM4Zf9lgrB2d8PeG0K31w+j0YiM\njIxx810vvt8A93AA/Uc16NwtQop4OZB3e1R2wvHp5afz+MftPtz49tg3TLwElVHAwj0Yfq7EEKF9\np4ieQwKMOQwWXKJFVuloQjDkEJwHjMguT4wsookCyY0vPR6P0k9w165dYaJAye7mkWqFMXlbU101\nWFVVhZ///OdJW9+0JV0kUcd2LNINhUJob29Hf39/THnDZOzLeIE0mfTlQJ06cCiGCO5uDWyHCPmX\nEAKukSCVa0ACSZ8SkcwhJAHDXSJMOSxyKzmwBh4ifbpthgXadoRQuezTm9Hr9aKpqQnaeQF84/Ua\n7P1LMXa/4AejY5A5N7IMmEX16hBcn7CYdR6PY28I2N4exKobdMgs+bQkN8cgwZNLyK9llNdmm80W\nJlQT2WEis4SFPpeFVQigcuHkhu/3PoydyTEpHD+/IT+hfYcAn4PAsgx6D0nIq2ax47EAOA2D4nkc\n9BaA4RhkFDDQZwLWfZmY87XkW2hy40uj0QhJkmAymVBZWRmmhZDsbh6p1tKVH8zTybWA6Uy6srBK\nMhCNdAVBQFtbG/r7+1FeXj5ugCwR0RuMEUhTa9qWl83AnPKlGG4lvP03LzxWCRmFLFiOQV+bDgwD\n5OaFoMtgYClikVelAXv89VsSCV37BfgcEjR6Bosu10OjH/nN8YYfgsqy1egZ7H/Bjy/+0oxAIIDm\n5mY4HA7U1tYiNzcXDMPgvO8DQQ+h92M/Pr4yG1/9fQiFx3PHGYYBwxFmn6cZyaudy2H5NVq8/4cA\n3AOEs2/UwZzPjrxaj/HaHAwG4XK5RgWTDAYDfD4fbDbblFWBTeRVPOQjNL4dAggQQ0BmCYvyxRx6\nDon4/C0jubhiiNB7WITfSZCCBHs3gdVKsB40wbuGlIo5MEBGPoOsMhZaU3LGt9qnO5luHmrLeKxu\nHqkmXbnAZzqJ3WA6k24yoSbdMJKLg2xlJFpOHGkpu4ZC+PijXvR12pCXl4f8/MUItrMQihlULOVh\nyvk0uwAANEYNFm0KoubscAIaaBQw3CmCYRmULeRhzB79KskgPHtBYwD8bglNLY2wWq2xO1ZwwGlf\nZaAtG8TbD/DQZwJnXa8Dy39K4EV1HPxOwtHXBSz5Ly20ZgbvPhRAwEVYfIUWzBinVqvVIjc3d1SH\nieHhYTQ1NYVVgel0OoUcMjIyEtZGmAjpzrtIg5CPQARwGiDkA5rfFRDwEIQAgdcx4DQMyhZ9ers5\neyX0fCyABAa8nkHJfA56CwOSCMMdEl76sQ8du0TMv1iD829LrIhivJSxyXTziJTKlI2OE9Uf7WQn\n3Q0bNuwGcO+2bdv+dnLv6RhQt4tJNA9RLrJobm6eMNnKmKx7IeQnWFtEDLYz6B/QgB/wY2hoCA5f\nP6oWZWPJ2vlRB3LRXB4bn8xE594QZp2rxZH3+/Her3XY+fshAEBuFYdV3zQgv5bH7HPHFmVnVNkL\noiii39oNh32k9HX58uXKeQj5CT67BJ+d4LVLsHeJ4MwA79Rg+TV6CCERL9/hw8o7JBB9Slh6C4M5\nq3nYOiQMd0moWMZD8BOeu8GLr/xxYiIlLMsiIyMDer0etbW1wBiWGsMwKelGXLFs9G30yRshVJ7B\noXu/CEFuKnL8lLAcYClmUL4UYDWEGUs5NLwSwt5tIbgHJJjzWdSczYNhgbO/MzFB/WiYrMD3WIG7\naAphLMsq+cZyR4mpCtyl0qebJDwD4L8ATF/SlZFoAEsQBFitVlitVlRXV4+r1TDWfkyUdH+9ZEj5\nf/4lHLR1Dli1e1C0qAjLKhaMO5Cc/RL0lhErqngBg3N/6cHStTMgCYT7l9vw77s9AABTHosv/tKM\nwtnR18ceF3fp7OxER0cHMo2lqF6Ui0CrFi2tn7728joGxiwGhmwGOZUaHH45gDlrGLjEAMrLNLB1\nSTjnJj2sLR7YWwBf7qeWP8sCpjwGuZUcdBkjD8vZq5NDgLEstVj+S7nwQO2/jCSHRCP9HbtEnHeb\nDiw3eh2iQLC1S9j/nAhTcQhv/NqP7DIWl/yPAZYiFvv/FsSCizV49S4/tMYx9sHvhHbnXwAwEPNn\njVwkljnuY2aOkzwD8+AAtDodOFeWwvxMyAsm6AFYHlzPfgg150KoPTeuY9NoNMjKylI0c3H8fHV3\nd8PhcCjBu6ns5hFJutOgMOJZAHdt2LAhc9qTrpw2NtELKUs+9vb2Ijs7G0VFRaioqJj0fkzGvXDr\n9hwc/U8AlDGMj98dQuOfSuEfHLFsOI0DZYs0qFymwZzztcgqC38QHHsrgKK5PCxFWhz+ZwDIYKHL\nHkk5Y3lGSe0CAGe/iH/+1I2BxpGHwswVGlxwuwl6y0iqmN1uhzPkRG5uriJgXr9s/P2v/ZwWQ80C\nbDYtzD4R+lwGM5aw0A2KkCQJZWVTN7ziyQmN5b9UFx4MDg6OIgez2QxBEBKrUJRoFOE6eiUMHhPR\nf1SCd5iQNxuov9qGJWcXhM1nzmew4/Eglm2KMqaJwPYeBNu9D6yzD9BnQLP7CbCliwBOCybgBsTg\nSDSUYQGWRbYvAF6jhUarAxgGDAgIuMEIAXADx7s5C4G4STca5G4eFosF5eXlynT5wSdLNUaKAqkf\nfBMxdqK1Xz+ZsW3btu4NGzbsBHDptCXdiWjqqqHW15X7f3k8HrS3tye0PxzHTUgekYgwYO2HPaMF\n0kAhFqysQMW5DVi2bITtPEMS2neF0PJhEH+6zAsSR+6h7DIWtg4JS67Qo2juyOWbe4EW/76fRfUl\nomr9n27LUsjhij9+Wg7c/H4Q/3eVA16HCGJEZFUSajYaldf1eDHnfB2czgD4Dj/K52kQDJ7YzhHx\nIFbhQaRVbLPZIAgC7HZ7GDnE1QAz5APjGQTT0IyeY1oE29rQ610MyshDXn0m5q/XwFLMwuVyobMz\nPGNlxMIGbO0Scis59Q/gOneB8Q1D+9Z/g3X1QihfCmjNIF0muM5dCKz4NkhvAQOACbhGPn4nRLEL\nGsEF1tYDaI0Ay4MYBtxAw4hRzOng/+L9CZ/baOQXbzcPr9eriALF6uYRa1uy3vE0wF8BfHnakq6M\neAskBEFAZ2enImau1tdNRr4vz/PweDzjzidr2jY1NSEzMxOnn3469Ho9hrtDaHjeCOE0Aq9lYMpl\nUbdGh7o1Olz0i5Hsg6E2Ee/8zouzvmWEo0fCi7e6YO8RwbCAb5iFsYLHnLnj72vOPA8W3dEI0Z4B\ng78Mh/9/Cc6mDNA5E3+lPhF6ulOBSHLo7e1FKBRCfn6+Qg79/f3w+Xxhvk6z2QyzyQitrQWsswcA\nQLwOPa0L8OGHZ2LmCh4CU4Z5FV5kFvSC630NbEMXgpZrQaQZFTdw9RN6P5ZQ+/njtyZJ4Np3gAm4\nIJYthmbfM5BKFgJdIUhF8yCWLQbjtcHw6s+gaXwNQtU5aGuegZLqALRiCOxwO7TOHhhcHZAMOfCf\nfTN07z0IztkH4nQI1V2IwBfuTMo5VGcUjIfJdPNQv4mo3T/TqCnlcwDun7akG6+lK5Ntd3d3zM62\nqeoeoda0XbhwYdgAzS7VIO80J469GUTpAh6ZJeH7yHIMLIUstOYR8RROy2DZVQbs2erHaZfpIPE+\ndDQw2PmUD9llHBw9Irr2h1A4h1dSw1wuFw7vbYKz2YCiotkomWVCfg2P09YDH37omdTr9IloTJkK\nEBFYllV0dCMbYHoH2iB17IDf54HdH4BPY4FGb0Im44dRr8HXtnyIoMeE/kMmMAAc7x+BuWoYWn8j\nmIALmv3Pguq/Nop0rc0ShjsknPUNDlzLu2CdvZCyK0C8DmzvIUimApA2A1JWGXQ7HoWvaB6k/Fnw\nrb0H2vceBBP04o1t9ZhZ2YQZszhANwt8y+vIm78YGbNmwvjyrSCWB2kM8F35NKTc6qSds0Rf88fq\n5iG/hfT396O5uRlerxcHDx7EgQMHoNfrcfrpp6O4uHhK3AyPP/64oti3adMm1NTUTGo927Zts23Y\nsOHdaUu6MmJZuqIooqOjA93d3WN2jkASLd1YpCunOGm1WtTX148SY5bB8kDdGh3ad4fg6JVQdhqP\nvgYBtnYRtnYJQ20ibO0iTDkMiuZocOjlAJb8lx4hP6FyBQemxA2Tm0NeFYfMEg45FRzEIMHv92LH\nPzsR8IiYOacSZ2zMihrgmQxOVdKNCr8Dhn/+CGTMgcGcD6mwDpQ7YqmRPhM+TSacpMeAb+TV2Qcf\nuGoRhaEemEo0GHi3G+7Z3wIV1yK/6RGIc0c3pbQ2i8itYqF7+zeQcmdCzJ8NshSBTHkjAwQAf+x1\nhCouBzgeutfvRnDJ14/qJbUAACAASURBVMENNQGcBpoD21A2dy2Wf1WDtrcMqBMfRuOazfC+9waG\nDroA6RwIlWfDtO4y5GZzSGZuwVT5VnmeR2ZmpqKYR0TYtWsXampq4HA4cPToUbz22mv461//ivz8\nfPzgBz9I2rY//vhj9PX14e6770ZXVxceeeQR3H333YmssuOUIF21aHEk2cbTRjxZ3SMiidvhcKCp\nqQksy46raass0yMi4JTQc0TA7md8qFqpQV4Vj7lf0OGtB73QGHlYijgceSUAXQaDvJk8bO2iIlpT\ntUKLI68EIAaB/mYfWo70wR/y4PQvlKCoLDfpKTwnqgX7VJN61OwFfSYgBuE//w5EU8zRAcg//oEk\ngGvfDsnnhCujBlL7bnjXrIW27z/oNbhh8lpx9F/DkCQG1OdBxekG6EwsdjwexA2vmxFgfwD+8N8h\nFc8fyTGTj909AAq4oX/5NlniDNrtf0bggp8Ctauhfe9BsM4eWLr+hfk1LBq6v42St/6E3NxBoMAM\n71cfh5RVDkc3oeUDUXH+6zIYFM7llLeiySBVAS05L9doNGLVqlXIzs7GvHnzYLFYEpJHjYZDhw5h\n6dKlAICysjJ4PB54vd5J9WPbsGFDLYB105Z0I90L6m6/8ZJtMqF2L7hcLjQ1NUGSJNTU1IypaRtw\nS+g+JMBjldD2YR74+iCySlks/ooehkwWR98IwlLMguMZhHwjAi+NbwfBsIS8mRrkVnJhpAsA1Z9j\n0HxgGG0DvZj3hRkoLKyasnzJaAplp4KlK7sXIuFb/xsY/nELfJc9En3BoAd820cACELFCjBBN7I6\n90BYcQUsQgBcDo+q3r1gsrrAl22Hx+sFubRoeWgIdt0s5FfNQ2+vAxkWC0w1q6H75FWIFcvBH3kJ\njLMHjGcY4LUgYy5Inwmh9nxod/4vGPcAQmdcC3agAczbNhAY8O3vYT7zEbrEKuw33YLCi84BTyw4\nL2AuYJBZyinjwu8k9BwQIQRGrhvLM8ifxcKcF3+ueqpINzIvV10ckWzRG7vdjqqqKuW7xWKB3W6f\nMOlu2LDhFwCuAvCdaUu6MjiOg81mw+DgIIqLi1NOtjLklt0HDhxAMBhETU1NVE1bSSD0HRXgHhhp\nMSMECTkVHLLLOcxYZ8WyVeGCrPUX6tC6PQhn7wixuQcleO0SyhdpkFMR3upaFEW0tLSgt7cXp19Z\ngZKSJVOu+iQH0uSIv5xulWyLI2FIAhiPFZRRlNh69BYEz9gM7Tu/QfCcW5TJjKsfXM9+kMYIxt0P\n1tkLrultgCRQbhU0e58G6TMh5VRCKpwDXdPbYGrOBvn8mFlVA2Z5G6SAB/WCH1LnAfj8PrRriqD1\nDaNy162QMkvAm3PBzl0JtnIZGI0e/LHXIVSuBBN0Q3P479Duehyh0/8LYFloj70GyZANKWsG+k7/\nLwjDKxFwM/DYCGJQghgEhONeORIJ3mGCZ4jgs498Bj4RYe8aIeBLfmOIS7f4ZCDdZCPSeJhs/va2\nbdt+CuCnmO5lwO3t7WhvbwfHcUp+aSKY7An1er1obm6Gy+VS9AnUsHeL6D8qQAwBkgh0Hwhh/wuj\n08tYbS26TnOgdKEGWSUseD0DXjtCbPYuER17QxD8hPNuMYURLpGEnp5eDA8PIy8vb9IFHpOBy+WC\n0+lEX18fcnJy4PF4YLPZ4PV64XA4wpTDxmrQmFQQgbF3grW1jPwfcIFvfR+SpRjBs74b9roeexWx\nx4JYdjrY3kPgP3kNwqzzwR97HWTKhzDrAoBhoPn7TRBqzoOUVQbKLB0RZJBCYEQBkEIgrRnsUDP0\nnR+CkVhwUicAQPfJa+BnXwCW94Hv/Q9quvchOPdCuM76BgKBEHq0xXC73QjsOziioWsqQ/HuF6HJ\nKUeOexAAoP3gYUDagpCog63mRjhKL0bn3mYwvQRjdjiBSKGRkmP3IMGQxcCYzSB3JgtjNoOW9xk4\n+wirvqNDZnF8D+4TQbpENKUVaTk5ObDb7cr34eHhsKKQyWBaky7HcVi8eDEaGhoSPulyIGwi61Fr\n2tbU1MDpdI4iXL9Twh+/ZB+1bMEsDlllLDJLOFgKWUgS0HSoG3wgHwde8MMzFP31XJ/B4OnrHCOC\nNtUcMqo86G21o+5CDiajGZWVlZM4+hFM5KHj8XjQ2NiIUCgEg8GA+fPnIxgMoqCgAFlZWbBarais\nrByl80pEccs4xgvG1Q928BgYMQQ6vv+UVQ5x5ipw3XtBYOC/8F4g6AXX9iHEqlUJbQ8AQks3Qv/y\nbRCL5kGY/YVPf/A7IeVUgfFaIdWvH5lGEtiBY8dTygjEaeG+/g247T4Eg0GIhdngeg6AjDlgh9vB\n+BwILt8MqektBM65BVpdBgxtHyI72wCqHsk2CIVC6DzkQt97LjDe93DY/E2U9L4DidXi6OC5yK9f\njuwiM7K4Y8iudUFr5sDxI/wvg9czmHW+BpnFjNLG6Mi/Qti3LYQlV2pRPG9iBHoiSHeqtXQXLlyI\nbdu2YfXq1WhtbUV2dnbCPdimLekyDIPy8nKIophUIfN4SDcQCKC1tXWUpm1jY+OoefUWFrfvzkXA\nPVLsAIZBST2P7oMhtO8Kwd4loq9BgDmPheDRoHgWg8VfMUOfwcLvkpSbZMcTPgx3iFizxTzyOt/l\nQkdDP4Y+MqN3Vz7Ky/Xo7BLQ4AtAox25gUoX8jBkxjcYZT/seKQrq445nU6lB9uePXtGrQsxdF5l\nERWXyzVKsEYWqxmzCMHnAN9zCDmDn4BvHB5Zpzkf4owzAP7/sffeYZLcV7n/p6qr43T35Jxz2DSb\nldNKtmXJSbbB4IttbGwwwcB1gAsCky7hPr9LuGAbw9XFGLANCEdZcpBk5V1t1sYJPTnn6Zyq6vv7\no6dqe2YnT88su+Z9nnm0mt2u0N31fs/3nPe85xp5S+EZlKtPo1UeQngXxjnZ3UhqPMU8ltV1net5\nL2KP/CnOr32Y6E8+AbIFedqHPNtH4u5P4PjGr6Dn1SIJgZAk9MIm1OKFji8tiWXsIq6RXhxCx0IN\nenEbWiKKpe/lVFFMVrBe+S7YU8VXreYOlKtPozqzwZaFLTjCnuMfJHnHY0A29hN/TPSnPo2/5Z3k\n/pZgPhpn5lQvhcMvEPa0EAydZ+K0k6rWCPUHNGzV9Qh3ken3OfC6yhvfSNL2sMLb/mTzpLITQyl3\nshutubmZuro6Hn/8cSRJ4iMf+ciWj3nTkq6BTCgP2ICRuTHmfamn7Vqwu2Wa7rejqYKBk0mEDrf/\nrBNPkQUhBINnVK6ci1JzMI/x8yrzows50YVbGz6n0vKQjfzdqQjTu9fJOx9rYPh1C6V/qODKlUg+\n76fxHhuKLXPTIwwYVpeTk5PU1taaC42u6xsqpC1nopLemhsMBs0mBEMU7/F4yNb9FH73V9Ga30Si\noBmQEAsWZVJkBkv/awsnB6X7OaydPyD8gX+/RrjGfdTehaXvVbSG+1Z9P9YV9UsysUf/FMdTn0Ft\nfjPyTC96YSOK73n0vBqwuVGrDqdad6d9WLqfSx3bYkUv2UNQKkZSYxTEepHHL6E23o+wKKDryFMd\naEXNi6+95S0ol76F0vcKlsGTRN/3JfSCVOSbuPtXAMgC3vwbOhNXs2h8NJ/sv/kwJ/Z/Fj1QxCtP\n5FD6vlFePKNieb6T0uJXsCpOLvywhdo9Qd7xCQlR0AD852402Gmzm/e///0ZPd5NTbqZrJKvRrrp\ndo/V1dWLnLc2CosiUXeHDSEEoxdVRi6o5FVbqD5kZU5OEJzUKWqyc9uHrIsm1179YZxAeIb+/jna\n2tpwu90MnE6SV3OtwmzN0jdFuKQVxJZGDbquMzw8zNDQkNlckn7v6Z9BuvPbRj6XlVpzVVU10xOD\nQbDYSrmYdS8O4SDozseT13JdekKa7QfFQehXXsX2yl8jzw+TOPRB9LK9qX9gdaRWsmRs4c+rX9da\nEJ4SknvfgxSaJHHoA6k2W4CGB3A89WlAIMVDaAUNqA0PXHOST0TIGvw+kmJHPfCoGXlr1bdhGXgN\na8f3iT38R0suSEZteghJ6MTe/r9XvKacChl3oUTH89CaKEGzeYgOKZTXhsgbjNB+Z4jgnIWnv3gY\nizVB3ZFucsqGGTo1izf6JWyKjOzOR/EUohRUI4qaETkVrOrDuYO4mb10udlJN5NYjnQNze/o6Oi6\n7B43YjMpSRLle1MP2ky/RsezcfzzTvYe03FZFTqeTeAplslrTKbSFnIpOQVe9uyqRrFJjF9Vsbmk\nxf35W8BS6ZcQgomJCXp7eyksLFyxULkcMWVqMVQUZZGblcX2YW4L9jNb9SauXr16XXoix5IgPzaE\ns7gdWbKQuOfXQQisp/8R2+l/RG19BLXxAbTau1B6XkRtenDFc2/k+rWa26//pSQhnHno+XWpxgYD\nyShK36sIi0Kg9Ag2h4vs9FSH1YmkJlLjPZYr+NndJPe+e81rUuwSbQ9bGT1zL3NdbhRbAWN9SSbC\nhbz2lxquXIl3ft6BYpOI+usZOaeSlMPktY4gwj7ic2NEZsaxdb9G8dRJADrf9mUcRTXL5uFv1FDK\nm8HsZiluatI1Hnhj6sJW3vx00tV13dT8lpWVrVsNYMi2NhoF59dYyK+xED+p0/OiTk6eSuVRnavn\nezn7/zR23VmB1SrRcHsWQ2eTZJdZiAXFonE6W0V6emF2dpbu7m7cbjcHDx7Ebt+4p+t2PIRa/b04\nvvmrZO1+FzabbZGfbjI4i3b1h/hthQzHFAKnTpnpCXfZQ3iaHyNn8AUc3/4kWtVRdG8JxENgX35W\nWiaGOMbv+TUcz/1xKmJNxlD6XkHICmr9vWCxovf3o6gR5MkOpNAkxsA3KTyN2vTQls5tQGm/m6H/\n6yWnMYQsZDqfCvHuT/qIBBT6n3TizU9QWh+muUJCs2Uz2FNKYs5OoddN+ci/g9VB6L3/l2DBbqRg\ncMVxStvpnbsUS0n3JvFdMHFTk64Bq9WKqqpbJt1kMml6ypaUlGxYhmYoIDb7JXDlyrgrE8xN9/Gj\nr8UoKijh2PsLCIzpaGqA4maF1/4+QtMDNpru37q5dTokSSIYDHL58mVkWV61XXk9x9quyCdx+EPY\nT38JbAeunU9XcQ28hHrkJ3BKMoYSNz09MTo6SlesDFH6Pkr8PVRd+HusIkn4p768LeN+gFSqQY1j\ne+VvkMIzCxGxwNL3CgDuiUns3jxE1S70ggazzXcjrsxSaBopNIEUmYElufXBKx5is6CFLVS0xQn5\nvVS0u7DtvxsbkLMwweLqpThutZvKukka7CdQIq8wHjrK+donsRd4qKi04LZI15mZL7XIDIfDnDp1\n6jrj+Ey/vzehgfki3FxXuwTpXWnGFnMzEEIQDAaZnJykoqKCI0eObIo4tzKyx7ARHBkZoaGhgUc+\n2oiExOBZlb7XErS/20FgPPVQNd638pd4MxFaLBYjEAjg8/lobW3dlA5x8WDK7SNdvXw/9pP/AFX7\nU78QAuXqd1FbH7ku52imJ7IcyNI0siWALgQJp5f57Pczayth/vJlM2pLl7Hp+vW+CJtB7KHHkaL+\nlF53SbogIPfi9XoR2QUrvn4tSOFpZmaLCEUasdgtWKypaRTD5zQK6i30XImT5TyLs6oJ6fUEF76Z\nJLtCJisrjDzbD0LHJisEJ2d47fk4WSUtVL7v58gqUGi0S8QCgt6FycoV+5VFI+TTjeOj0Sg+n49d\nu3aZ5jTbNU7pZhvVsxQ319WugPXaOy5Fet7S4XBQVla2YU/ZdGxmZE96ocrpdFJfX09FRYX599WH\nrFQfurYArJZSWK/sy0AymaS3t5eZmRmcTictLS3X+Z5uBtvdBhy9/RepefnLcPAgSsczqQKVIRfT\nksjTPciBEXNKglDs6EXNqOXtsPClz174IW3cjzEEc2pqivn5eaamppiZmVkUtW14N+XIRjiWbwPf\n6pgpAL24hex8QVYCtIQgGRV0/UijdJeFiU6dyKwgLjwc/2IQiZSBeaJngPmYh9zWBpSu51AjCeL5\n+0nWVdE/rHH6Uwli/lhq+MRCMVdoEJ2PkV0m8eEnr0/JGOk9Y5xSus9I+jilYDDI9PQ00Wh00+OU\nlka6m92R3SjcEqS7UZcwIQRTU1P09PSYnrbhcJipqakduw4hBGNjY/T19VFcXMzRo0cZGxvbElkZ\nxbC1HuT0AmF1dTVNTU1cvnw5Y0S5LtJd0KoqXc+iFbeg7nr7uo8vChtxRsZQup5FuPKxDJ9BWjif\nkC3oBQ2oRWlKgXVcrxG1GeqJnp4ePB4PdrudYDDI2NgYoVBokdG2ERlvZYe11Wg6FhCMXEgt9Gpc\nMNGh0XCPgitXxp4lOPJzEi/+oQNLYJZQtJDi3VZGh4pwxy8x0jeGpfpeKu7MoqDCQlY+WB02FHvq\n2gZOagy8rhILCSwWiaZjVuruXJ4yVos4Mz1OKd0X479yujuMdBH+eiJdIQQzMzP09PSQlZVFe3u7\n2V0Sj8d3xFM3nfBzc3M5fPiwmfPa6PSJ5c6/mueBEILR0VH6+/tNnwojclvOuGZTEAI5Oot36gL2\n73+d+L2/Do5U9CzNDWKZ9qVkVKEp0FUShz+IPNODFJ5BZOWveXgDPQ0/xYG5AdSG+9DzajMuZxJC\nXGcpSJrRdjAYZG5ujqGhIRKJhFlUMoh4PYWlTES6Dq9E/V0KoSmdwTMqh3/GhhqFeFgwN6Sjyzqz\nk0Xc/bCPl7+Vz8Hyr0B2KTPuYwSnwFMkMfC6xuApzVws54Z04iGRmmC8z0JOqYy3VKJ098pR/mZq\nKpsZp+TxeFBV1Rz5s1PqhStXrvDnf/7nfPzjH+fgwYNbOtZNTboG1hNhzs3N0d3djcPhWLZItN2e\nuqSpApYSvoG1SHMtGCqOpUifVrGU6NNfu+FzR2aRpnzkT59D7opiUVWk6DyWyW6sCReJ2z6cMnpZ\nGJqo51Si1t2N0vMCemETWkWqGKa5i1LdVm2PrPvUcUc+iYNv2tj1ZgDpRtuLrietuSOdKIxozePx\nmKPKDWw20p0f0Znpu/ZZyRZ45Qtx9r7TyvAZDVmRsLshu0yi/JBAUiRqsn5AR00liYMfRFakVHql\nXDDdq+PIhmnfNQ+G2tsVnNkS8TDMDeic/dfUOONX/jbBx59ZXu2RKfJbzzglVVW5cOEC//Ef/4HD\n4aCtrY3W1lZqa2sXmZ9nCuPj4zz11FO0tLRk5Hg3NemmR7orjcrx+/10d3djsVhobW1d0dM2U9Mj\nljtGIBCgu7sbWZbZtWvXdVVgAyuR5nqxHHH6/X66urqw2+3LEr2B5cbumIjOI011I8UCi34tnDmI\n4hZmClRETj7SeBeSGiNZuhdteBg5OIbIrUZtPJa6vtE3UHw/SkmmlLQtuSShlexKTUYo3bPp+88k\nNkqIK22fjYgtfVS5kZ6IRqOoqrrhc+WUy+SUX4uQNVWwd9xKSZuF6JxAU1Njf0bOaVz5nkCNSnzp\nK79KbqXE0GkNZ66E3QNTXTpqDKwuaLjPSla+BEIw8kZqegWAM1fiY09lkZW3dspqOyNOIyp2u92M\njo5y8OBB9u/fz/Hjx3E6nQwPD9Pf38/73ve+jJ87NzeXT33qU3zhCyvYeW4QNzXpGjAkY+kIBoN0\nd3cjhKCpqWnNAtFyx9goLBbLojSHYQqjqqrpU7DW6zNFupFIhK6uLlRVpbm5ec37X6kNWPn2ZxDF\nLWh7H0M4l6gadBWp/wQVgz/AMhFCbXkLWsUxVHsu0/FLVFbtxzJ8BnmqG3mqC610D2rZvmXPL/Jq\nsHQ8g17cakqnMgIhkGd7UXwvopW3m9H12i/ber7VYrFcl54QQhCJRAiFQoyPj9PX14fP58NqtZqp\niY1U90NTOhOdOjG/wO6WKKiTsVhT121zS7zxnQQlBxLYcJNTKTE/rDPRKdDVlHlSeFYQntXp/KGK\nEKmeDOPnwd+ws+cd65N77aTZTXpKzOPx0N7evq3FtM3m7FfCLUG6hmQMIBQK4fP5SCaTNDY2rlv+\nlImcpqIoxGIxYrHYqlaPK2G9pCuE4LUnoniKZHa/1Y6spB6yZMBKLBZnaGjINKRZ77lXun/1Lb+H\n7W/uQzv64Wu/jM4jD7yeShnU3M5QhaDyjT+ih0qkwRGSFYdJJBLEImGyInMoA6+TuOPjaxa21Pr7\nUHwvrNopth5IgbFUw4FI3Y+eW4PuKcZ24u9S5uMbKLBlGkbFPisri8nJSerr63G5XIvymDMzM0Qi\nESRJWjU9AeAulHEXyqgxgRoTDJ3R0RZiB9+LSaauSsT8dkp3CXpf0Tn0fhsOr0TfcZXwlCC/Vqbl\nTQqN9ytc/HaS2LxATaRSFnk1GzMw34mClqqqi86TaZ3uc889x/PPP7/od+9973tpb2/P2DluatJN\nTy/EYjEuXrxIJBKhoaFh3WSTSQghmJycZGJigvr6etra2jb04K6HdHVNcPmZOPV32tBUQcdzCQpq\nZeRgPxe/ZmeweYjyylL2v6kFu2v9D82Ki47NlfIpECKVYpjpRTiz0ZseREgyoyPDJAIz+OvfktJ1\nenPQer9B7tQI2SfOMFF4CElWiL/yVZwOB06nMxU5OHOujzqtztQI8eAEwrNybu669zTqxzJ2AWnB\nkk33FKHV3WPqYpXu51IFt/x6bC//Zao9eA3sRFtrehV+tep+MBhkfHycUCiEpmk4nc5FUbHNZkNx\npLxwC+oXJkEEBWe+Gqfm3iS27Dj+zhxsYTj3rwkEqX+bjAvmR3QmOjS6n1epPmqh8qBCTqVMfo1M\nZE7Q+WySoiYLuVU3Nr1gID3SFUJkXKd77Ngxjh07lrHjLYebmnRZEPb39PQwPz/Pvn37KCgo2LF2\nRAOGIc7IyAgOh4PDhw9v6hrWKqQlY4Kr34/T+mY7sgUGTiZoq3oB37+e4vLQQQr2V3Dk3eXk5RQy\ncCpleF5Qr6ztz6Al8fb/iOyRV+Ht/xO8i6craEc+gP2PU45Xevl+9Lq78M9MMDo6SpbbQ6FQ8bY/\njOW5P0W0/zR64zGCP/oS8Yd+kYKpTqTeV9EmjhPHSiKZJKJqSLKE1fplrIoVS1Y2ctluKG5FK9+f\nMgdfraiWjJAzcxml2w+AcHivs3Y0IM0PIZy5YMtCL25BOv9VpOD4mhMkMpFeWAtrnWOl6r6hnvD7\n/YyMjBCPx4nNuImcdlBY5YJIFvM9dsp2W7j0tELRbvDkS9TdrTB+MbWoW2yw/z12bFkS0XlBIioI\nTQomuzS6nk8y06uTXBg9GJlLLUAf+tcsciuXJ9+dJF0j0jUWxv/yXthh+Hw+CgsLCQaDi8ZkbxYb\nedjSPRrKy8vZt28fAwMDm35YV4t0YwGd7hcT7H7EjixrSD2vEH19lM6iUUbK38/Dn8jmB3/cw8Rl\nKLpfov7OFAFN+VQ6n4tjy5KoPmQ1UxHoGtLwWaTZ/lSqoOAgY/d8lurBU+i737bo3Np9/x3LqX8m\n8ZnzREY6mD35TTz936cp24slrOCZm2Pu6VeR7V7sT36C8w0fpTW/EL2wiXhBI6L5rVh9zyM1HsOx\nYDhttOhOh0KEZyeQJzooeeOvKJi7hJIMMV2wH3deUSqK0ZLI45eQIwv+uRY7AW8tauMaZuRCYBl9\nA7XtUfNX8Yd+B+c3f43oY3+zqc8ok9iMZEySJFwuFy6Xa1GlPjgTZ+hyhClfmJnhSVx1s0yHcsmq\ndhKZU5BEguYKB3vfvrZXrhCCoTMaHT9QEXqK2IpbLHiKV/5e71Q7bnqku1PnPHv2LN/+9rcZGRmh\nt7eXZ555hscff3zTx7vpSXfv3r3ouk5vb++Wj2WQ3lof5HKNDYqiEIlEtlwIW+71gQmN4fMqux+W\nsPS9QMg/x/jIADO2g2Q538b973cjSRKl1SdxZJdx+Zk4tbdbceXIFDYoFDYoxEM6l5+JYYsOUFk5\nitsTgngYkVuF+vb/RXRkFF3T0Cv2Iw2dQVSmaRElGRBcvnSRUDhC030/jyc7G00IVCFwAVNTUwxe\nOcNu35c50PfPSLF5wl3PYVEU7LLAOXaaeP39i+7Ra0mQG+1CsutQVYJ28DeZVnJTnWHzIXqGxtA0\njebBb2LxFiLn12KtPoAlrwJt9uya76el9yXUpVMiZIVk26Mol76FuvsdK772P0OkuxF48u10P6Xj\nH7VR0ioT95VR2SghDowSGE1QfmSeqVCI8ZOp9ES6pthmtdH7ikbvK6oxHJiqQwoPfuZavWAt3Iip\nETt1zgMHDnDgwPoKsOvBTU+6mcRa0yNWa2xgHTrdtbBcpDvTrzHXH2N3zXGil6N0hZ3kzAxSePQ9\n9Hblcec7ronw4/lNFCReI+ct76H31SRD55KU7VaQ5gaRIrMUF6oU3FHF639fwCvf2MM7/9SNVbVQ\nU3ct+iSnAmnsEkJNgGJD0zT6+/uxVr+L+r6vY3vkdxBCmGmQUChEd3c3NpuNXYfuxNlWj+3p30Zv\nuRtX6W5i8RiRhM5oy/uYvXQB5/RVsuQkDqcLW04J1pojWB3Xoi+nEDidTkpKUtt/SZKItrUgLn2X\nsexdiMunkUPfxZ1MMqZPYKk6gNubbU6asPS+jFZ3N1JwPDUmfZkWXLXlLTi++WuoLQ8vm5Jgh0g3\nE80R6Wi4R6H5IQXFvvB9CAtOP+WgsMJGc3NK8yqEIByKcPmZGGfOaqjJWTRdo2hflJr3SHi8KTJ2\nuezI8vrvf6fHr3OTmt1wK5Du0vbArTwoq2l112psYIuGNyxTIBq/ECLpu0BNkx/fRBTdP8be6ZfR\nP/gVLj+dpHxfyhQdIBbUGTnrYvyFZhzPBJAUC/0nEjyY8wtMlH+M873txM+OI/0gSuV99bRGdBrv\ndy46t0GkeuMDSN3PM+zdQ39/P+Xl5ZS/53dw/u8DRB7+bdA11KleJq++TjwWpa20lCx7FmJiFpFX\nQ/KuX8R67msk7/kE9rkBnNM+8klQJ+tobW8nJjtTPfiBAMGeXmKx2HWGMw5HymBcCIHN4UKp3kud\nrCHufidCCM6cTdQUTAAAIABJREFUOUNxSTZaz0vMRcOMJXVCec1k2yWyLz6PJzGDvP/drERp8Yd+\nB8cP/+B6o/AdRKaJfdeji9UDNheMn1No+AS88Y0EE1dTn69ssdB0LJsj7702gt3wRgiFQgwMDJjq\niXSTGrfbvSLJ7RTpJpNJ87txM5rdcCuQroH1pgZWw3KkGwgE6OrqQlGUVRsbyGQrbTzE8DNvIEfH\nsRXN0dsTJb/lKEWJLsTuR+j6/PeY4V5OfClGxw/i2B0x7EqIytJhqo6Nkj/7TU71vAunbOU/TnyW\n8vBXuetX4tj33GFONhi5FEJXRWr7qMaxz/UgT/Ujq310PTdGeHQY5YDKoYcfxGpLTbpQ97wLqes5\npqamGYvbKNl1jLLiUiRJWmRHKHKr0PuPY+l+Dj23Cq3xmCnTkgAn4HQ6KSoqMl+TSCQIBAKmIUok\nEsFisaRV6avxDrxAIreWqZnZVJGpvAFRVp8aTKiriKEzxOcnKfj+79C7+6OEvv8EkkSqw8nlwenx\n4sjyItscqUqSlkQefQN9Ge3wTkS6bPNMMUmSCE1YOP2EhYPvtrDvXStrbm02G3l5eeTl5Zm/S+8C\nm5ycpKenx1RPpEvZ7Hb7f0W6G8DNd8UrwPBfyBTpbrSxgUw8QFE/FUPfp//kFZKleYTzkhRWHqbh\nxOd58pNt9I1/1Pynlc3T/OoX+xnpzkL2ZjPUXcCL/5SNI6eVfXfu5cDtHZQ116JFYjTvawMxh26x\npmRf88O4tCLi56bJylYRFhs4cpjK28dwMMH8QJijv/lxYs8+zdDXL6AvJPpCobsJT0Upu+0ou2ur\nV90aJx/8rQ3dus1mo6Cg4LpxPcFgkGAwyNDQEOF5N+6n/475ksOUlZURCoXMsS2aZIHcKnJO/T+C\nP/EPFFTsp2ghfxwOhQgG5pnyzyJ1XcEVGsauSDhspWiaA+eCd0I6diqnu9247TenKSkpITt744S4\nmnrCaHkeGxsjFouZ1o4GEbtcrm2Z0Jv+jP9XpHuDkO6pmwnvhEgkwqVLlwiHwzum95WmfChPPw7D\nb+CffgyyJ/j+Vx9B0wwi+GPuav8Gdzw2i0saolA5z8ln6/mrn/9l8xhFxRN86Ce/iLBAaCKLuZeT\nFD1o4+yVOppvi6A8+Uuorjz0wkZE/T24GhKE8ppx1ivE43F6L14kFArR3t7OKX8AhzsL5wN3kecf\nYcZdj8/nI9tTQkXSQeDsLP2nZlMnFgJ3lZe8/dUorgx37igKubm5uFwuggE/TqtMfXUFybJi/LqV\niYkJgsEguq5TM/0qeaE+Rh/4n7i9OSgLD6XkHyF7uptsoSPZZPT9d6DnVBFJI47gpUuoqorD4TBJ\nQ9O0HR1Bs13IdN44XT2RvlM5efIk+fn5qXl2g4NmW75hUrMR68bVsDTSvdkcxrgVSNfAZj11DSQS\nCWZmZohGo7S0tLBr166d0/vG5om6y/mHl36b2ZkyAB568Hvs+0gjitsFFhvH/79i/uXzdyy84IOU\nlQ7yqz/MwpHrgEQEy3f/jivjRxGj3ez1/BNxTxN9ZxoZu1hGqPEk3ob70L7yKZSDjyDJ4BloIjYV\nIVxwhVg0SqvTia5p5IR+iAi04/jah5EmrjLnbWT40KfZvXu3GVXm760xL13oOsPPXOLE75+gbL8b\nhGDyapjb/uDe9d270CEyhxSaQgpPIRntVAg0XWd6wdu2qqSEvHAn8uh5VKcdz64FWVsyiu07nyFc\n+wDTJT9NZGKIwLnvoidT0auSX4VSsQe3x7voATVMVQzikCSJWCx2jYiDQS5evIjdbl/UiJDJsTQ7\n8f3KNOmuBEmSlk1PRCIR0wTIsG50OBzX5e834gGdHulu29SPbcRNT7pbjXTTJ/1mZ2dTWFi4Zaei\njWxN/X4/XeOCvNzDfOwjX2A0mUXh4ccIjlYydE5HVRREXiWBnBKO3vYycuv92CPdZLmjjHzuC5Bb\nhTJ1gawjb6awJYC/tJLz409QdsBLg2eMzplC5nZ/iqFJnSt9l2hsysdWVkqPdZbZkQCH7n2Yhl0V\nRKNRLh1/jqLYKKqscKH0bczX/jxNzc3szc1d9tqjE/MMPt1JTn0Ot/3uUYaeuoya0JnwXf8gWC59\nC+zX+z8ICXDmItxF6AV1YLGZnX19fX2UVDRQd6QEa8czJO/8BZRz/4rIykcePAXJCNbX/wH1wE/j\nkC1UBK8g8nLRd30AIVvNiRjBYJDRsXGzYOf1es0CUXrBzmq1msQRCoVobGzEYrGY5ubpueal7bn/\nWQX6m5nZt1GstCMwcvJLDc3TFzcjPaEoyqKCXVZW1rLXnR7p/ld64QZjo5Gu0dgwNDRkTvqdmpoi\nGAxu6TrWW9CLRCJ0d3fjGTnO4cB5LPV3oN3/OYZPn6agtp3cJiu5uoY0fA6594u03K5hOfVlkkc/\nQ9Rax3znBNGhKfSCWmJ3/Sb+7qvMBmuZjduprvFw+dkRkp678U+FiF04g83poOSeFiZ+9D0ihxop\naMoiJ78MVzRJ79fOIHSNXHs9I/Pl6N4hIt5arAg6Ojqw2exkZ3vxeDx4vV6sSAx84xKKU6HiWB2j\nL/QRHr1M5aNtWN1OBo6/dN39SqEp9JxK9DUMZ4LBIF1dXTgdDvbv349dDWHp/B7artSYcvXoh7F9\n7/fQ82oYfXmIWMuvo07UoUvXxqlLfQAqoCBEHpCHVwIvkIwmCY5FmYxGicYmUj7KARs2q4M970rZ\nNs7MzBCLxcxJCIZpjbyksSMUCjEyMkI4HEYIsWgr7fF4/lMQgq7r274gbGS0kSRJOJ1OnE7nomam\nZDJpvqdDQ0MrpidIC7RuRgNzfhxJN93Iu6SkhNtuu818ODLpqbvSA5dIJOjp6cFx5dvsSfSi7H4Y\nfc/fokXmkAZep2D6AlLnNLLNBpKMyK1Cu+eXQVbQDvwUyo/+nKzcKbyj/4Z295uQgt9DLxLodz5A\nICnR1ztAdWEF/ouzRGZHsLRm0dA+zZVnZimKf4WRZA0tg534fO+h9cgFygtAbz/A+NQM/f39KGMq\n3pJ6smZrkawKc6dURIGO961RAn4//d88S3w+gb3UgTQIkWSYynftJcvtXvXB02ruQJ4bWFEtEI/H\n6enpIRqN0lxZhDfgQwQdyLP9aLvfcc2kxmIFXUW9/aP0dsQozLVQe4eCbLn+3GpCMNOrUdyS/llY\nAZf5f7oquPRMlIEzcQKBMdMG1G6309vbuygqZuFBB0wiKCsrM1Urhk/C1NQUvb29y/okpDtW7UTO\neCfSC5mIOK1WK7m5ueSm7aqM9zR9skQ4HObChQtcuHABl8tlarq3I1WjaRpf+MIXmJycRNM0fuZn\nfiYjnro3Pemmpxei0eiK/87Ysvb09JCfn7+skXcmPXWX2sFpmkZ/Xx/2k0/QNnMSuf4OxJ6fAEDu\nei7lTVuyC/+8g6LaRpTlrOpkBWnkHKJ8L4mPfAPr134O7Y6fR297BCQJ5/l/JCeQJM/SS76zH4nz\nJA4eoG+qkHGpmNvfkoX9zfeTe/WvqT88iN5wH7Pz8/jOvYHH4+HgwYMMD1xEqdFIyCp9x6GgwULv\nqzqNLX60yzPk2PKQy2S8zTlY6lLdYz29vUQiERRFwev1mpFgegVbFLeCfxih6kjjlxElu2DhwRoc\nHGR8fJza2lqK8nJQOp5B5FQiRefRmq43H9Er9iMPnaGwcS+5VTJ9x1Xq77o+4lFsEoEJneJVnpOu\n55PU3CW4/ELKTOb222/H4XCYXrjBYJCJiQl8Ph+6ri8beRlEnE4CGI0daT4Jw8PD5pQJYwJCJBIx\nGzu2AztFutsRTafPWystLUUIwalTp2hoaGB2dparV6/y9a9/nbm5ORobG/nYxz6W0fO/9NJLOBwO\n/uAP/oChoSE+//nP8yd/8idbPu5NT7oGVot0Z2Zm8Pl8ZGVlceDAATOPtxSZIt30rjJd1xkZGWFw\ncJDd/tco6vsP9MJGmOqG4XNI8SBoKsLhgawCGlUFZ38xis2G2ZMpBNJsX2pSg5rA8sJfQGQOHNnI\nHT9Ar7sb+dzXsESC2INhRPY+Eo0P0T80gv3Ml3HlFlF3cDe2/aUUaxq++c/QduYXOR/OQQjYU2jB\nUVaJsFqZHHDS8aqDsuZRKtuiODQdMeel89tTlLRaKTtWj6vsWrEkXeKVTCYJBoP0imEzKkl/cAoj\nUZ79SiPNuwfB0Y+fLMbHJyhr8LL/6CHsTguWi98EmzO1CBXUL/seq+0/ie2p34ScveRVWbBYJTqf\nS9D0gPU68pJYmcwGz8aJuUa42jWF29PEnj2Viz7H5Ub1GIWhmZnUziCZTC6KZtMr9EIIbDYb+fn5\n5lZakiRTkzw2NmZG9+vNaW4U6U5m24Wd0ugaqRKXy8V9991HXl6e6aW7lSL6Srj77ru58847AfB6\nvYRCoYwc96Yn3dUKacbUCEVRlh3RsxRbbeNNP0Z6ZF1QULAw1v1O4m/99PUvEgLiQaTQFDNXzlDg\ntqMYTRihKWTfj9Dr7kQUpUI25ft/CJFZ9LI9SJE5rE/+Eurdv0yydD/RHz7BsJ7H0OvHaZRGyDv0\nJrqPK9T+ZDG6rqNpGqMjIyi5Bzny4i+hvuX30bJbGDhv4/J3I1jCMnnZ49z3+D4uf/Es3Rcs5ORM\nMD5eQdmeacZf6sNVMkH+oRqs7sVdeUYhymq1snvXLqSF/KehBuiPuFFc5+mOuqm0v4zdU8zhd9yJ\nNZnD6AWB8B1HirvQKg8x+UoWTQ9o5FbJZtediSXEml0qo9gUOn6QpOVNS4hXAqELc6otC0TUe3mC\nrguT7D6WS2nJIX70wtqz6dLH75SWlprHWlSwGx1dVLBLt180/r2hf7Xb7ezatQtZls2cpqlJDofN\njjBj0drUNOIdwI3wXWBJWmM7crvp5/rud79rEvCWj5uRo9xgSJK0KNI1jMxVVV3X1AgDmYp05+fn\n6erqWjOyTrsBcHgRDi/RYpVoQQGu3BzkC18HQH3bnyGNXUZKRkBA8i2fRdTcBlYn0tXvYX3qt1Be\n+HOsWMkPBsju/DLV3iKwe5DODWDpaYefPMjEGy8SGrpCrbsWd+Xb0L0avT1VXPynPCoO6Dz0P1z8\n7YNu9h2d4PlPnmXPu3PY/0EbSu+LfOef3dT91CEAwoNTjD7biRbTzGjcke+k4Eg1thw3shW0WBLF\nZTe1trm5ufSMFtLc9iRXJw6Sd+ht2IdOMN9/gWnhpmDyJHnOCYJ3fJD4mEzzm2RkYOB1FT1tHZQt\nkFctk9dwDPmNc8ARALLyZWrvULj8dJK2N19zUyuok5nu0ymsT5FCMBik42oX8xfyOPaBFmw2G8mY\nwLLJZza9MJSueonH4+ZiMzk5STQaNav5xoDU6upq0xNWkiSTXI2C3Up+ui6XaxER32jZ1I0i3Ux2\npK1mXv69732Pvr4+fuM3fiMj57olSJeFlS6RSJiNDY2NjYs0g+vBVmeUhUIhJiYmUBSFPXv2rNoy\nvBIsFguW0TewPvV3qaJRcBLl+N+jl+9LDbNiIeXQ9SzEQ0jzw0T2vQ/l4jfwHfjvyPNDeNtvR53q\nBjXJ/LQLV+R1hr7151ga76T2rR/nwteTPP3pELHw+9nVdIY3/Z9GbG4ZoWnEk25s+Kk6kCDZN0F/\nj4qwlSKSSS599iu4WlO+upK0EHAuRJVzPQG6njlDMiox0pd3LTWSphS5+kaQe/c7afDUUVJkRy57\njKLuH9E8ewmcQeZv+xi22SkGLswjIj5kNYpTkXBbBW4RwakGIRan+0Q9//KdB3nkfa+apAvg8Mg0\nH7Ny+ekErW+xodgksstlel5SyanSzWkelrEm7vtvXqy2hSp4UmCxZTanunSkOwst5R0dHQgh8Hg8\njI6OMjo6itvtXrZgZygiXC4XpaWlZsHOyBMbKY6ljR3p2tedKNbdCNI12u0zlTpZybz8+eef58yZ\nM3z605/OGMHfEqSbTCbx+XwEAgHq6uooLCzcVGFis8WMWCyGz+cjHA5TUFBgfvE3A4vFgufslxB2\nNyK/DrH3XeDIQSg2yC5DZJenhjrGgvDs/+LSgd8iGZpjb+0kbUPf5HjuW5h541nyJk4Tqb6H1/ub\nKXu4hX2X/orhyPv4izuCWO0a9/+yzJ735BDtLGfy775AoixFXo/9Dw95B99MdoUNS/9rCFceoriV\nyg8Jnvsfbh6pehF177vBvbZ3sTGFuKenh8KCYpqaG/HsKsHad5nx74Sp0f4VKTyN7B9BbX2Y3CtP\n4h+s4XBTkqwCK8KaTUwThJMSo7qdmbiN0e4cshsUCg7IzFXeT2k8vqhoaXVItD1s48r3EjQfs2F1\nwvTMNFOn+6mpqSErWo/7gIzVce2z1pJg2cYnwXBqm56epqmpaVGFfjMFO4fDgd1uX7GxY3R0lHg8\njtVqJR6PMz4+nvHGjqX3d6NsHbezwWRiYoIf/vCH/N7v/V5GdxO3BOn6fD4zUkhvTdxuqKpKb28v\n09PT1NfXs2vXLkZGRrbsqTt27I+pqKhYcrI4kn8EafAUeixE4sS/MOJto3HkaZyeXERJE9LZsxzV\nv8t80UFO1v8cWTNXiQsrtr5T/PUTnyUU9PDAbyi0v9OLtfP70Clw29xk75pGPZiHKKhH1wQzPRp9\nXz2JyK1FuAqxj6gUt1jQlBwsQ6eRIrNreiuEQiG6urqw2Wy0t7czdVUhv12GrAKyr/wWo6P3or77\nZxHuIkRWAdhcCF0QfD5J+TGbaaBjW/jRejViPo03/6zCpWfCNL0pyvmvapz+yiyFh+dw5VhwuZw4\nXU5cThd2j5Xv/K4fa/U4saFs2t+6n/FXJeYGklQfsTLbr5OICIbPqSRjgkM/ndkWZgPT09P4fD5K\nS0s5fPjwdZFZpgp2huQqLy8PSZKQZZl4PM7Zs2eJx+NmY4dR2MxkY8eNIN2dMLt57rnnCAaDixQL\njz/++JbPK62x/bgpms+TySS6rvPaa69xxx13rOMVK+O1117j9ttvX3UFNWROIyMjVFVVUV5ebj5M\n4+PjRCIR6urqNnX+4eFhNE2jurr6ur8TQjA8NIT80l/jKSgjxy4Q+XUw04Nw5qM68wj0nqWz4H7a\n3BGiHUGe+9ZBhn053PHzfto9f828vRS/nEPudA/WWBxVKQbNgRaIEL3tk6BryIOn0Et3gz0VYcUm\nZpk8P8PoUCE/9UQB1kv/jpSIoB750HXXaOiQQ6EQTU1NJpl0PJug5cFr0YLvxSR1dy3W1/afSFLc\nasGZnTZePCnofjFJboVs6m2f/myYt/5+qig63atx6ak44TmVZDJJIpEkq8aPo3EMWQGtv4qcPA+V\ne1xMdyi0PGRj6KxKIiKwOSUq9l/zn80kotEoXV1dSJJEU1PT2nn9NZA+psf4icVi17Up2+12M6UQ\nDofp6uqivb192caOYDCYkcaOwcFBbDabKZXbLoyMjABQXl5uWlDedttt23rOLWDFL9UtEelm0lPX\nmFO23MqdPjGipKTEnBix9PVbKcYtHeNO2jbd5/PRNP0SZQPfggFSW38lFaFpahIlmaBYJCjpewZh\ndfD0iV9AnuvjPe8fhpiLCe1+LIOv42w5gqq7CNa0oMxdYKpkLwkpjks5SXXoDbQHHsWda8cpR1H6\nXkXUlqC/Z795PVr7T6Cc/QrKqS+jHv4ALCxEw8PDjIyMUFtbS0tLy6LP4fJTCTp/mGTXIynijfp1\nzv1bnL3vsmN1SOiqIB4Wiwh3sktjdkCj4R6rSYxCF4u+zgV1Fu77hMu8hoGBQTpfiRN+dQ+KbCOZ\nTHLlnyERTtD03/oZ/heJ8naF/KpUIcpiy+wjkLqGASYmJjY0jXktrDSmZ6WCnRCCeDxOXV3dog4u\nwIyUt9LYkQ5VVU1fju2EkbvmJrZ15FaJdFVVRdM0Tp48yf79+7ckHzlz5gy7d+++7gs2MzNDd3c3\n2dnZ1NfXr5jjmZ2dZWJigtbW1k2df3JykkAgQENDAywUXzo7O7Hb7bQ4/FhzS9Fdecg9L6MXNjId\nEcxfeJZsr4f8lqPI+TVYrjyF1vpI6uMTIuWhaxBgZA7bD/4Adffb0RvuBzWB5fJ30GvvRO99jenS\nOwgF/Fh6XyKW1AmWHMDjzTYt/tKF/MrpfwZJYqzqTfT09FBUVER1dfWKW81zT8YJT+vc9QtOhBCc\nezJBXpWMGoe+15KUtyvYXBLuQonZfp3CBguFjYuPdf7rcQobLJTvXfzAGZ/PctegJQWhaUF2qUwi\nkTBJKhAILPLtNdqcN6uRnZ2dpauri+LiYqqrV7e+3C7Mzc3R0dFBdnY2LpfLjGqNce6GjC0rK8ss\ntKUHKpIkmX82ImsjKk5v7DDI2Ol04vP5KCgoWJSr3g709PSQk5NDfn4+MzMzzM/PZ3Q0eobx4xHp\nGrKxrZDu0o4yw8TcarWyd+/eNVf0rWp9DQVFLBaju7ubWCyWkr1FRyHuhNkB5OkeIsLK+OkfIbnz\nqXjowzic165La7gPefgMet1d15/AlYtecQB57GKKdBUbeulurD/4QxLv+kuKB09SooXRHvgZsDpM\nIX8gEGBiYoJIJILVasXr9WIruAvbmX/CMvZl2h/8pTW30PvfY6f/RJLv/HaYR//IhbdIpuqQgq6l\nItjG+2yMX1UZOKWSX2PBP6bjH9NBgGSBvCqZkfMq7Y9dWxAjkQhdXV3Iskx7e/uy12CxSmSXpr4j\nRrNCegRqaGQDgQADAwOEQiFTk+v1etfUyMZiMbq6uhBCsG/fvmWnimw3EokE3d3dJBKJZSebpBfs\nxsbGCIVCyxbs0idSr9TYYSxaExMTRKNREolEaiJxLJbRxo6lWFpIu1kj3ZvzqleA1WrNiHeC0Z7p\n8/mIx+OLcpNrYavpBRaitpmZGRoaGlKSo8A4su8FiM6TyK5mdD7GlLuBhtvfQ3Z4EPnC15Bn+0FX\nIRZAis4jT/tQWx9OWSemtjQACElCCoxBVkrKJI9dgngI9ejPYn/yF4k/+ifm37HUXFzoSP4REoNv\nED77VfTIPIpFYVZuYOjSJTNS9Hq9K1bKa26zklMh82+/GObNv+1k9KJGzC+o2K/Q8YMEBQ0Wjn4g\nRZyJqGCqSyM6L9ASgq7nkzTen1pQNU2jr6+PmZmZTckD07Fc37+maSa5DA8Pm91IxlbbiIhHR0cZ\nGxu79lntMIyU18DAAHV1dRQVFS37vq9WsAsEAisW7Dwej3k8o7EjJyeH3Nxcs2B38eJF8vPzSSaT\n29rYsbSQdjOa3XCrka6iKFtuB5Qkid7e1Nwu40HaSI54tTHqq8FoF+7r68Nms3H48OHU3LLIPFmf\nuw+AqLeapOykWoEGkYQLAr2gAb1sH1rDfQiLdaHJIhvhzAa7B+TrP2JL9/NojQ8g9x9His6BEOil\nu4k/9n+wXH0mZTCjJZCnupFCU4BAmupCmh9hXvIwqmXjve1jFFU3IUkSXqA8mTQj4qmpKXPbbpCw\nUSmXJImcCguP/UUW3/hUmLLdFpBSM968JTLzQzrzQ6mFwuqEwkYL5fuuRU1CCCYmJujt7aW8vHxZ\nRUAmYJBLTk7Oos/IiIj7+/uZnU2NDcrNzV3U8rxTZBAOh+no6CArK4tDhw5t+LzpHXYGlhbsRkZG\niC/I8tKJ2LYwwikajRKJRMjJycFqtW5rY8dS0r0RO4pM4JYg3aXphc1A0zSzAFJaWkp7e/umCnIb\n7WozimTd3d0UFBSwd+9euru7TbNmYffQ9f7vMzQ8QkVFBeXl5WiyzJaalYXA8sa/p+wW6+5GuIuQ\npn3I0z1gsWH7xq+iNdyLpOuIrHxAYqrsLrqUKAUFBdTV1FwXtVit1mW37UbuNJ2IjUjx4T/x8ORH\nk7S+xYa3RKaoyYLDuzKBhkIhOjs7cTqdHDx4cMc7sWRZxuFwMDg4iBCC2267DYfDYZKL0fatqqoZ\n5RkLTiav1dD9zszM0NzcvO5d2HqwWsHOaHWenJwkEomg6zrJZJKSkpJFhuJGY4dxnJUaOwYGBsxB\nk8s1dizFrZJeuCUKacaHPzAwgMViuV7jugqEEIyMjDAwMEBZWRlCCOx2O+Xl5Zu6FiEEx48fX5d0\nLb1I1tTUhM2WGnnu8/nw+/3E43GSySQej4fq6mozmtgqXH+aKvLpebVI8SDCXYhe0Iiwprb1UiKS\nKrTV3kk4EjUHczY2Nm5Z+pROxIZkKZ2IjYg4PXpNJpP09vYSCAQ2lOrJJIQQDA8PMzw8TH19/aoN\nOEIIc9tuRIyJRMLcthv3abfbN7ywGwXD0tJSKisrb0ixLhKJ0NHRgcPhoLCw0NQUGwW79Eh2tYId\nyzR2hEIhYrEYVqvVJGKjseP06dMcOnQISZLw+XwUFxdTVla24/e/Tqz4wd4SpCuEIJFImJ04tbW1\n63rN1NQUPp+P/Px86urqsFqtq+pk14u19MJG4SUej9Pc3Izb7Ta/lCxEdIZRT3l5+aIoQ9M0srKy\nFm3bt2PFTye6xsbGRdvsTENVVfP+AoHAoq26pmnMz89TW1tLWVnZzo1QSoPf76ezs5Pc3Fzq6uo2\nlZtcaowTCATMbbvxOXq93hWjvEQiQVdXF6qq0tzcfEO21uk2nC0tLct+J9ILdoFAYNWCnfF9N/5r\nLCCyLJsj4Y1FKxqNEg6HKS0tpaenB5vNxtGjR7eNdP1+P5/73OdIJpOoqsoHPvABGhsbN3KIHw/S\nnZycxO/3r/nmGIY0TqfzuuhtfHyccDhMff3ytoLrwUqkm97Blq7hNKrFRmNBJBJZcQKxEIJwOGzm\nTw0iTi/wbIWIjdzy8PAw1dXVlJaW3hCim52dXZhaYcNmsy3qpjLu0+12b2ukl0gk8Pl85ty8tVzq\nNgpDS5se+UejUVOWZdzj3NycGWHvZMdlOoLBIFevXiU/P5/a2toNve/pOmDjxyjYGffodrsXfWeX\nRsWyLHPy5Emampp4/vnn6enpIR6PI0kSBw8e5L3vfW9G7/epp54iJyeHu+66iytXrvD1r3+dxx9/\nfCOH+PFoOcM6AAAgAElEQVSSjK0EI4LUdZ3W1tZFs5sMZMJpbCmMxoGhoSGqqqo4evRoqki2QLaG\noH5ycnJN7whDb2mI20n7UgcCAcbHx817NCRPBhGvFaEZvsOGyfuNyJnF43FTNbJ3795FRR5DURAI\nBBgcHLxO2pUpIjZSTkNDQ9TW1lJcXLwtC48kSeaAzPTRNYZMb2Zmho6ODlgwSJ+bm0NVVVMdshOp\nBU3T6O3tZX5+nra2tk15iqQvlgbSC3aBQIDh4eFlC3ZGh93U1JR5nLe//e1cunTJlMYFAoEM3zU8\n+uij5p+np6e3pI5ZiluCdA2sJBmLxWJma+pa8qJMka6xgzBSGIWFhRw5csTcVhmEa8h9ysvLOXLk\nyKYepPQvtZGLNojY7/czNjZGV1cXuq4vioYNIg6Hw3R3dyPLMnv37r1hW9ehoSHGxsZWXHiWUxSk\nE/HQ0JAp7Uq/z43IlYw8e3Z29g1beAx7UL/fz4EDB/B6vYty4UsN4tPvM5NEbDR7lJWVmbnUTGEj\nBbtEImF+fl1dXaYsUwiBoigZJcR0zM/P82d/9mdEo1F+93d/N2PHvSXSCyxEB9FolMuXL3Pw4EFY\n2M739fUxNTVFXV3duiKWUChET08P+/ZdP8drvThx4gTNzc34fD4cDgeNjY2mxMbYNs3OzuLz+cjJ\nyaG2tnZHZEbpkifjJx6PI4SgtLSUkpKSG2KUvVo32WZg5BWNe0zX2KZHxOnnSSaT5sLc0tKyaZe4\nrcJo9y4rK6OysnLV72u6Qbxxn+mFrOXucz1IJpN0d3cTj8dpaWm5YdIsQ9VTWVmJ0+nkhRde4MqV\nK0QiEbKysqiuruajH/3olhea1bx0Ac6ePcvTTz+dsfTCLUW6qqpy6tQpjhw5wtDQEMPDw1RWVlJR\nUbHuDyYWiy0i7o0iGo1y/Phx3G43LS0teDwedF03I1+jg8pisdDQ0LAjPetLkb59rqysxO12L3pw\nSYsUtzN3mm4K09jYuK0PdzoRG0TFwrRZIQR+v5+amhrKy8tvSA47Ho/T2dmJEILm5uZNq0SW3qdR\nyErvrlst52/I3mpqarZt4ONaSCaTdHZ2omkaLS0tWCwW+vv7CQQCtLa2kp+fTzweZ2RkZNPGUmvh\nypUrVFVVmYvvRz7yEZ544omNHOLWzumS1jMej8c5ceIERUVFyxrSrIXNpheMItnMzAwul4tdu3bh\ndDrNRon0SGq71QCrYXZ2lu7ubvLy8hZtn5du2Y0H19iyp/fub5WI0/1lt9pNtl4s15EVCAS4cuUK\niqKQk5PD6Ogow8PDG86FbwXpUrSGhoZFud3NYKXOMyPnb3j2Go0K6Tri3t5eLBbLDdFAGzBI39iZ\nzs7O0tfXR0FBwaLJ3Xa7fdsIF+D111+nr6+PRx55hMHBwYwZF3ErRbrj4+N0dnYSDoe56667VnRE\nWgsb0dmyTJGsrKyMK1euAJCXl4fb7WZycpLJyUlqamq2rSizFowI27Aa3GhUmZ47NSLi9Jzieoxi\njLlxRjfZRnYgmYSxQPr9fpqbmxeNc0pPwRgR8UYixY0gGAya5jT19fU7mtZJV8GMjY3h9/sXmdmk\na4l3AolEwoz0W1pakGWZvr4+gsEgbW1tO7IwpyMQCPC5z32OWCxGMpnkQx/6EE1NTRs5xK2fXhga\nGiIrK4s33ngjI566ax0jXedbWFhIzUKXlhCCZDLJ/Pw8o6OjzMzMYLFYcLvdZGdfc+vaapPBemEQ\nzPz8PA0NDRn98q5ExMY9plfZDVNzu91u5rh3GkYLcV9fH5WVletOJaRHigYZG9rTzeilNU2jp6cH\nv99vpqBuBIw2YrfbbZJ+NBpdpCVOJBI4HI5FWuLNNHWsBqOtOz267e3tpbCwkMbGxpu18+zWJ13D\n3vH48eMcPXp0SxHUWqRriOVdLhcNDQ3XFcnm5ubw+Xx4PB7q6uqw2WymMD69gOVwOBYRcSaJKD1v\na0TgOxFhG8WddCJOJpMIIaioqKC4uNjsUtpJhMNhOjs7cTgc5me2FaQTsXG/6U0ABkktLZAaC3VF\nRQUVFRU3ZNeTLlFsaWlZtcPPaOpI1xKnm6cb95lu+bleJBIJOjo6kCSJ5uZmJEmiv7+fUChEa2vr\njke3GcaPD+mePn2avXv3bumhWml6hFH4SSaTZidZepEsGo3S3d2NEILGxsZVxfTpHUqBQAC/308y\nmTTzbNnZ2Zs2TzGUEbm5udTW1t6QSEEIwejoKIODg1RUVOByua7zsF0aEW/X/K6+vj5mZ2cz7lOw\nFOmuXemNK4Y0am5uDqvVSmtr645t25fCGI5ZUFBATU3NpoOTdGlXMBhcZPlpkPFKn2n6jsPIY8/M\nzNDX10dRURGNjY3/KUfNbxC3Pulqmoaqqpw/f35NwlsLJ06c4PDhw+YHb7TEzs7Oms5j6WSbniPc\nyhY+vWff+Fna9uv1elf8QhqLAkBjY+MNUUawsBPo6urC6/Wa7dVLka47NYhYUZR12UOuB0b6Jz1/\nfKOiyp6eHnM4ZDKZvK6I5fV6t10yaKQ0DAVAprvrWIhcVzKIT0/BGF4eTU1NCCHo7+8nHA7T1ta2\n7UboO4gfH9K9fPky5eXlW1IHnD59mj179mC1Wk3pWXV19aIOMBYe7KGhIUZHR7dNYrNSPjGdnJxO\nJwMDA8zOzu6YGmA5GEbahgfxRrWuyTR7SOOhNaKn5SZXrIRIJEJnZydWq5XGxsYbHlXm5eVRW1tr\nLpZLF1ejLdYg4kw7kxk66Bux+KQbxBtTURwOB5cuXSInJ8eUVra1td0K0W06bn3SNZzGOjs7yc/P\n35Kh9Llz58jLy2NkZGSRYD/dlGZycpK+vj6Ki4upqqra0S+MrutmNDE+Pk4gEDBd/o0c8Xa59690\nPcZ8tNWMtDcDI3pKJ2KbzbaIiA2TmNVGne8kVFWlp6eHYDC47kaLpc5kgUBgEREbi+xGiDiZTJrp\nsJaWlh0r3i5FPB7n6tWr2Gw2GhsbUVWVl19+2bTIHB8fp6CggE9+8pM35Pq2CT8+pNvb24vT6aS0\ntHRTx/H7/Zw9e5bs7Gza2toWFclYiF66u7txuVzU19ffsChqbm6O7u5us6NNluXrCljG1s4g4u3I\nmxq6XyNHuBOLT/oIoUAgQDQaNTXahiHLduWI14KhM81E8dIg4vQilmERmb7oLCXi9JxpphfBjV7/\n2NgYg4ODpsHT9PQ0/f39FBcX09DQYH5fdF2/IfLBbcStT7qG09jg4CAAVVVVG3p9JBKhu7vbHANi\npCiM98eYWaZpGo2NjTesTdQo1um6vmbuemneNBwOb2q7vtJ1GPnjzeh+MwXjOnRdp7i42JQ8GRX2\n9HvNtNQpHbFYjI6ODjNXuV2SOMMoZqmsy/DqdTqdjI2N4XA4aGpqumEjbWKxGFevXjXb4HVdp6+v\nj2g0Sltb2w1rDtpB/PiQ7tjYGNFodN3dKulFMmM1HhgYYHR0lLy8PLKysvD7/eaE3kx2pmwEqqqa\n0wK2ch3LRYlLyWm1baixhZ+amsroiPGNYj2jztOlTgYRL9WcbnXLnW7Uc6PeD4OI+/r6mJ6eNp25\njHs17ncn0guGamVoaMhM8Rjz15ZGt7c4fnxId3p6+v9v78yjoyzP/v+dNZOZZDIJWSYJWciesMcE\nBOyLVBHfWkQNRluOFBHFitofFGwVRLSgoFaEGjhardWyGT0xVVTEgsoOIYFGSDJk3/dZksnsy+8P\nuZ/3SUggJDPzJJP7c07PYdKY555J5prrua7v9b2YNSbXg7xZBmqSmUwm1NTUoLW1FWKxGDwej7mt\nI7frnsgi2IsHyboeV9+GDUZDLBKJGDUAl1sLMIxV58S/tr/n2jcjHgxErz1u3DiPlVb6Q6/Xo6ys\nDHK5nBlyGMg0XSKR9GrCujL7NxqNKC0tZfTr5AN6DGW3bLw/6OJqwV6r1aKxsRETJ07s93vIKGpl\nZSVCQ0MZrSK7bkuCS0hICGJiYn7eVca6rSO6Wraci+hqXfnGI2brAQEBA0qv3EFfDbFGo4Fer4dI\nJEJ4eDiCgoI8uoCRwF517qqSxkDB6Xp1U+Kj0dPT4xZz88HicDiYxmFKSkqvceb+GOhDh32nQzLi\nmwnEZBCnoaEBycnJUCgU6OjoQG1tLZRKpcdHnAfi+PHj+OKLL8Dn8/HQQw8hPT3dnZcbG0GXrPgo\nLy9nbNnYkCAmlUqRmJgIkUjUK9h2d3ejvLwcEokE8fHxN7wd6yvnImbKJJMICAgYkorAaDSioqIC\nNpsNSUlJnL2p2SPEpD44VA3xcGDfwnti1XnfDx123ZTP50On0yEmJuaG1ovuRKvVQqVSMeqZod51\nsAMx+dBh18NvtEbIaDSipKQEfn5+SEhIYOxUTSYTJk6cyMk+u/7o7u7Ghg0bsHXrVphMJuTm5mLl\nypXuvOTYCbpmsxnFxcXIyMhgvk7MXux2O6MfZQ83sLcVJCUlDWsWvj8/gsFOX7HrpZ4ILgPBLmlc\nrws/GA2xv7//sMoQGo0GV65c8ag6oj8MBgNjZCSTyRhzbba21hMlJ5vNhoqKCvT09CA1NdVtAzD9\n1cPZUj1/f390dHSgqamJGSUm2W14eDji4+NHlBrh1KlTKCkpwYoVKzx1ybERdMkSubNnz2LWrFnM\nbaBGo2GaHOxgy9Z1xsfHIzg42C2ZS3+if7FY3KtmqtFoUFNTw6n7FlibE643TXY9iEsXaT6ybSFv\nRkNMFjGSkWuupuvYyxiTkpJ6DZ70lXR1dXXBZrNdM+TgqkBMDM6joqI4WdJJMmK1Wo3m5mbg6odi\nS0sLQkJCEBISglmzZo3I2m1+fj4aGxuh1+vR09ODBx98EJMnT3bnJcdO0HU4HDh58iQiIyPR2NiI\n2NhYRrPLniQjHVZ3NaduBPkDJraPPB4PAQEBUCgUHsua2LCXMBJfCVcxUPbPLsOQ7P9mVp27G3IL\nT1zkBvM3MtAod9+M+Gb8MIjtocPhQEpKCmfacKfT2WsbsFwuR2VlJc6fP88MsbS1tWHJkiX9lve4\nJD8/H2VlZVi3bh3a29vx8ssvY9euXe782/J+E3Nc/aMg23ztdjtuvfXWXgsgeTweOjo6UFlZeY2J\nNxdnbW1thcViQWZmJmQyGdOo6+joQFVVFVMzJRmiOwy13TlNRuhvtxlZu97V1cVsQMbVD6OAgABM\nnjyZEzcysNbVmEwmTJo06aZq6jweDzKZDDKZjPmwZ3vXkiZu33p4f9aQ5O+5pqaG003AuOrSVlpa\nioCAAGRkZMBms6GsrAwWiwWLFy/u1cS7QSLHCQEBAUhOToZAIIBSqWQWWnJRc/aqoFtRUQGTyQSp\nVIrY2FiAld2SBptIJOJs+SJuULclblRKpZI5O3mzNjU1MStmhtuoI7CnycjSTE9BFgoGBQUxWXZP\nTw/i4+N7Zd2eHHBgBzlXemn0t8GZHYjZ2xyIWbpYLEZjYyN8fX2RkZHB2ZCD0+lk9NBkg3ZbWxvq\n6uoQGRmJuLi4a/7+uLozuR5Tp05FTk4OFi1aBL1eD5PJxJmPsdeVF4i9I6mZ+vr6orW1FUajEYmJ\niZx1U9lv6OHUbW/UqCPP+Xp/+O6QXg2Fwaw6J2UYUiNm62rJHYArpr8MBgPKysqYCSoughyph9fW\n1qKzsxNisfiaFfPuXh/ERq/Xo7S0lDHssVgsqK6uhtVqRVpa2g0laiON7777jllAmZWV1avZ7gbG\nRk33woULEIlEkMlksFqtuHDhAvz8/CASiXo1rgYTmFwJsTpkm5q7kv4adewMMSAgAD4+PrDb7Yx5\nNZfTZGCtqiGC/sGWeQaScw1VRcA29CYaU64grwnxQRYIBMzdjk6nY2wTnU7ndTcbDxfymrS3tyM1\nNZVZOUW8kYnXB+W6eH/QdTqd0Gg00Gg0OHXqFE6dOoXExETcdtttjMcA+5aOBCZ2IHZ1MDSZTKio\nqIDFYhmS1eFwr80e5DAYDLDZbAgICEB0dDQCAgI4yebYCzqTk5Ndcos3VB9iIkcjTnJcBRJitK7R\naAa1voe9x43c7fQNxEOV6un1epSUlDASPYvFgqqqKthsthGT3V6+fBlvvfUWoqKigKs+K8uXL+f6\nWH3x/qBLKC4uxsWLF/HAAw9AJBJBp9Mxt6bd3d0QCoVMfU0sFvdaL2OxWJjG1XAmzNgZpTulaIOh\np6eHMY2OiorqNVXHriG6+9aVXV6JiYlBeHi4W18TssWB/bsnGmKZTAaNRgOHw+FWretg0Gg0UKlU\nCA8PR3R09JBfE7bdZ1+pHjsjHigQs6fbSHbb2trKKHxGUnZ7+fJlHDp0aKRbQY6doHs9SKZL3og6\nnQ5GoxG+vr5Mx1kgEDCmMORWjtgjksbVQG8MtqVeREQEp/4EZDJIo9EgKSmp39tm9q0reb642qhz\npS+vXq+HSqWCTCZDfHw8Z00h0sRsbGyEVCqF3W4HXNiYvBlsNhvKy8thNBqRmprqlrq63W6/JiNm\nB2LyfIkygYy9WywWVFZWwuFwIC0tjbOG00DQoDvKIY0pkhETF38ShIlciNy+9vT0QCgU9ipL+Pj4\noLu7G1euXGECCxfbbtEno7yZjbcEdqNOp9Ohp6eHadSR5zzYevj1Vp17GrL5lpixkMB/Iw0x+eBx\nZVZOZGOeyPj70vf5dnZ2wm63QywWo7OzE+Hh4XA6nYiJiRnWDjV3cvnyZbz//vtQKpXQ6/V48MEH\nMWXKFK6P1RcadG8Gq9UKnU4HrVbLZICkiyyTyRjrvO7ubnR0dMBgMIDH40GpVCIkJMTjgw0EMk3m\n7+/v0oyS3agjdwekUUcCMVuwP9RV5+6A+LgS57nBqFfYGuIu1v624foQm81mqFQqZvstVx/MuPq3\nUlpairCwMERGRqK2thbff/89Ojo6GAvMu+++G3PmzOHsjAOhVqtRVlaGWbNmobW1FS+//DL+9re/\njbRV7TToDgfSMddqtb1KE5cuXYJKpcIjjzyC8ePH93qzknopKUtcr542XNi61uF6RwyWvo06oiCQ\nSCTQarWQyWRuNfMeDMQCUqlUDssUBqy1QeT3fzMaYvZmZLL9liscDgeqqqqg0WiQlpYGqVSKlpYW\nNDQ0IDo6mmkoGo1GmM3mETnS25fnn38eq1ev5nR4pB9o0HUlWq0Wr776KjIzM3HLLbcwpQez2dyr\nLEH+eNnZsitlaw6Hg7HUG0jn6ilIjbKzsxNyuRxms7lXo4588HhqnQ97N5i7dMhsm0SdTtevhthm\ns6G0tBQymQwJCQmcZmM6nQ5lZWXMh5DJZEJVVRWcTifS0tI424Zysxw/fhwajQb33nsvtFotXnjh\nBezcuZNmut6M0+mEXq+/JqO02Wy91BJdXV2MlMfPz4+RrZHmxnBka2RHWt9Ns57meqvO+2vU8Xi8\naxpXrvqgYGeUXPg2sDXEOp0ObW1tzFjzuHHjOPHUQJ/162lpafD19e2V3cbGxo7IKbKBMBqN2LFj\nByODXLx4sbu9cYcCDbpcQLxK2YGYmIGTQCwSiW5Ktsbe1ZaUlMSp3Gkoq87ZjUvSmBQIBL0+eG7W\nRBus7Qmkns1l1tN1dfU62SjRd5jDUz7EuHpXVlZWxqhpTCYTKisrAWBUZbejEBp0RwrsTFer1aK7\nu5uRrZFGnVAo7LXNgMjWrFYr9Ho9kpKSOK0LunrVOWnU9a2XDuYOgAwWqNXqQW1PcCd2u50xfSda\n1/5gD+kQxYyrfYjtdjsqKiqg1+sZSVpzczMaGxsRExODmJiYEZPdWiwWrFmzBosXL8btt9/O9XFc\nBQ26Ixm73c68Acmb0GazMUG4rKwMTU1NmDZtGgQCAdNN7ytb88SbiHi6unNPGnubAQnEpFHH9iDW\n6XQoLy9HREQEpx7EYDXt+pZYBkvfKTNSiumrqR3McyQDF+QsRqMRVVVV4PF4SEtL42wTyUDs378f\nxcXFWLBgAQ26NOhyh9lsRnl5OT755BPweDxkZmZCoVAwZQkfH59eU0gmkwm+vr7XLJN0FWTVOY/H\nQ1JSkkc2y7Jhj/qq1Wq0t7fD6XQyTmWuyA6HArGBNJvNSE1NdenrcrMaYrvdjvLychgMBuYsIzW7\nJTQ2NmLfvn2IiYlBaGgoDbo06HLL6dOnERgYiJSUFGYxJlu2ZjAYIJFImIxYJBL1WrHOlq0NNSgN\nZtW5p2C7kpE19CQ71Ol0zMRV34k6dwWa1tZWVFVVeVQ5MpCGWCwWQ6fTISwsDPHx8TCbzSM6uyW8\n9tpreOyxx/DDDz/QoHsVGnRHMCTTZTfqrFYrpFIpE4j5fD6TIRLZGrldvZFsbairzt0BceAim5EH\napSRUg3b6IcMNpBAPJRGHRuTyQSVSgWBQMC5Ftlms0GlUkGv1yMwMBBFRUU4d+4cpFIpkpKSMH36\n9BE5ygsAP/74Izo6OpCVlYXc3NwxE3RHlLCNcnMQ3S97yopM0+l0OqjVasZPwc/PD+PHj4evry9T\nP2xra+tXtuZwOHDlyhU4HA5MnTqVM79d9GlODcaBSyAQIDAwsFdzj539NzU1MRNXbOvLwQRO9qpx\nrrN+AOjs7ER5eTmio6ORlpbGDDRMmTIFSqUSLS0tqKqqQmBg4IgMukVFRWhra0NRURE6OzshEokQ\nFBQ0Ekd6XQrNdL0coh3tK1vz8fGBTCZj3NZIsG5paYHNZoNcLkdoaOiw3NaGC2naDbU5NRBsKR/b\nk7evjIudTRNTGH9/fyQkJHCmiwarjmyxWJidaU1NTWhqasKECRM4XQ0/VMZSpkuD7hiE3SknsrXq\n6mqcPHkSkydPxl133QWRSNSvbG0wbmvDhWy2AOCxph1p1LEDscPhgJ+fH2w2G9OcGq48brh0dHSg\nvLycWSdkNBpRWVkJgUDAjPWORmjQ/T9GZNDV6XTIyclhVq4vXboUiYmJXB9r1JKfn4+SkhI88MAD\n8PHx6aUdJbVh8mYm+tKB3NaGE4jJJuDGxsZr9sdxgUajQVlZGXx9fSEUCqHX65mauLscyAbCarXi\nypUrsNlsSElJYXaoNTc3j9rs1svxrqB78OBBKBQK3HbbbSgpKUFeXh42bNjA9bFGLQaDod+GGrkF\nJ25rer2+lwk8WQHkCtkaaZQpFArExcVxevvOHixISUnp1fkn04PsiTqRSNTrOQ+3UdeX9vZ2VFRU\nMCoJg8GAyspKCIXCEZPdms1m5OTkQKfTwWq1IisrC7fccgvXx+IS7wq6bI4dO4ZLly7hqaee4voo\nXg/bBJ49PcaephOJRL2MYG4kW2N77g6mUeZuSHNq/Pjxg7akJI068pqwG3XDWZ5psVigUqngdDqR\nkpICkUjEZLdxcXEurXMPl1OnTqG9vR2LFi1Ce3s7Nm/ejB07dnB9LC7xPvWCVqvFtm3bYDQasXHj\nRq6PMyZgrxKPjIwEbmACHxoaytx+GwwGNDQ09JKt8Xg8dHR0IDo6GomJiZwGEOJMZrfbMW3atJuq\nI4vFYgQHBzPlELbxjUajQW1tLSPlI4HY39//uv4QxOg8Li4OYWFhjAm7SCRCZmbmiMhu2cyePZv5\nd2dnJ4KCgjg9z0hmxGe6R44cYdYmEx588EFMmzYNuCo7+frrr2l5YQRhsViu2U3H5/Mhk8ng7+8P\nvV6P06dPIzk5GT4+PjCbzb1M0d2xJHQg2IbrJMC56zqkHs5u1LEd10jTrqysjDE6FwqFaGxsREtL\ny4jLbvtjw4YN6OzsxJ///GfExMRwfRwu8a7yQklJCaKjoxlDkcceewwffPCBS69ht9uxe/dutLW1\nwW6345FHHkFKSopLrzFWINN0arUahw8fRmFhITIyMph6Kdttra+Ei10rdXWd12g0oqysDD4+PkhM\nTPS45WLfZZIajYYxDm9paUFMTAxsNhskEonb9qi5g5qaGrzzzjt44403RvQHhJvxrvLC2bNnUV1d\njXvuuQd1dXVuEakfO3YMEokEr7zyCurr67Fr1y689tprLr/OWIDH40EqlaK5uRlSqRTbt2+HUChk\nAg6RrRET+KCgIMbw3Gg0oqWlBeXl5S6TrTmdTtTX16OpqQlJSUmc3QqT4RaJRAK1Wg2FQoH4+Hh0\ndXXh4sWLOH/+PMxmMwIDA1FbW4v777+fk3MOhqqqKsjlcmZ1O5kMHMx6pLHGqAy6WVlZyMnJwblz\n52C1WrFixQqXX+MXv/gFsx9KLpdDr9e7/Bpjjfj4eMTHxzOPSfCMiooCWCbwWq0WGo0GXV1dwNVp\nuvDwcKaOqdfrUV1dzXgT34xsTa/Xo7S0FAqFApmZmZyqJNhLRMkaH71ej5aWFsyZM4fJbru6utDW\n1sbZOQdDSUkJOjo6sGzZMmi1WphMJs6boiOVUVle8DT79u0Dn8/Hww8/zPVRxhTsyTG2bE0sFveS\nrbFN4AeSrbEXVKampnIeEMxmM0pLSyESiZCUlASBQICGhga0trYiPj6e02WeQ8FisWD37t3o7OyE\nxWLB4sWLkZGRMeD3f/311zh8+DDzuLm5GevWrbvufzPK8K6arqu5XrPu0KFDKCwsxJ/+9KeRtoNp\nTMJeAcSWaPn6+sLf3x9SqRRisbjXtgaz2QybzQaFQoHY2FjI5XLOzHucTieam5tRW1uLxMREBAcH\nQ6/Xo7Kykqndeto2k2tOnDiBgwcPYvPmzd70HqNBdygcPXoUp0+fxrp16zh1kqJcH1I/JNkwMYEX\niUT44Ycf4Ovri0WLFjGNur5ua3K5HFKp1O2ZpclkQmlpKXx8fJCUlAQ+n4/6+nq0tbUhISEBERER\noyq7dQWtra3YuHEjNm3ahPDwcK6P40po0L1ZWltb8fbbb2PTpk2D2v01HEpKSvDWW2/h97///Vif\n4nEZhYWF2LNnDzIyMpCUlMSMLRPZmkQi6aUeIG5r7pCtkYWZ9fX1jDtZd3c3Kisr4evrO+Ky2z17\n9qC0tBQOhwP33XcfZs6c6Zbr2Gw2bNy4EQsWLMDcuXPdcg0O8S71gic4cuQIuru7eykWNmzY4PLb\nn+Nx630AABI6SURBVJaWFhw8eJDK0VyMXC7HSy+9BIVCAfSzl6yzs7OXCbxSqYRIJILVaoVWq0Vd\nXZ1LZGtGoxGlpaWQSqXIyMgAn89HbW0t2trakJiYiPDw8BGV3V66dAn19fXYsmULuru78dxzz7kt\n6B44cABKpdIbA+51oZkux5jNZohEIuzevRu33norzXQ9CNs3gsjWyDQd0Q/z+XzGGpOoKdibKfz8\n/PoNmmzvXSJLI9mtVCpFSkrKiMpuCQ6HAxaLhbkTWLFiBd5//32X18CLi4vxwQcfYOvWraNGf3yT\n0Ex3pOLu0gVlYAQCARQKBRQKBaKjowGWCbxWq0VnZye6urqY8efIyEhIpVIma66pqWFka+yyhMPh\nQGlpKfz8/JCZmQkej4fa2lq0t7cjMTERSqVyRGW3bPh8PvNhcPToUUyfPt0tTcf8/Hzo9Xo8//zz\nzNfuvPNO/PrXv3b5tUYaNOh6kBuNNFO4RyQS9eujQAJxc3MzYwLv5+eHkJAQ+Pj4MGvkVSoVrFYr\n/P39UVhYiObmZkgkEgQFBWHmzJmj5kO2oKAAR48eddt4/Vj2S6FB14PccccduOOOOzx6zX/+858o\nLy8Hj8fDsmXLkJCQ4NHrj3Z4PB58fX3h6+sLpVIJsEzgiWyttbUVra2t+OGHHxAbG4t7770XQqEQ\ntbW1OH/+PAwGAxwOBxISEvDEE09w/ZRuyMWLF5GXl4f169ePOGMdb4AGXS+mpKQELS0t2LJlCxoa\nGrB7925s2bKF62ONethG5lFRUSgqKsLp06exZMkSBAcHQ6fTQaPRICUlBQ8//DAzwDHSp8pw1Vt5\nz549ePHFFxlvE4proUGXY4qKivDFF1+gsbERVVVV+Oabb1x2S/fTTz8hMzMTADB+/Hj09PTAYDDQ\n7MXFJCUl4S9/+UsviZndbgefz2dqt0KhEBERERyecnCcOnUK3d3d2L59O/O1p59+mvMtHt4EDboc\nk56ejvT0dLf8bK1Wi7i4OOaxXC6HVqulQdfF9JcRcunpMBzuvPNO3HnnnVwfw6vhZhaS4hH6ygGd\nTueI7ZpTKGMFGnS9mKCgIGi1WuaxRqNhhgUo3k9dXR2eeeYZHDp0iOujUFjQoOvFTJ06FWfOnAEA\nVFdXIzAw0K1CdPomHzmYTCZ8+OGHmDRpEtdHofSB1nS9mOTkZMTFxWHDhg3g8Xh47LHH3HYt+iYf\nWYhEIjz//PPIz8/n+iiUPtCg6+UsWbLEI9ehb/KRhUAgGLXNPG+HlhdGOV9++SVef/115vHmzZvx\n7bffevwcAoGA2l9SKIOAZrqjnHvuuQcnTpzAf//7X1gsFhiNRsyfP5/rY1EolAGgQXeUw+fzsXLl\nSuTk5MDhcGD16tWcbUWgUCg3hgZdLyAuLg5SqRR8Pp9xy/J2PGW0PVqpqqrCxx9/jPb2dggEApw5\ncwZr166lo70jABp0vYCioiLw+XxYrVYUFRW5bcLtenjyTe5Jo+3RSlxcHDZt2sT1MSj9QIPuKIdI\ntdatWweLxYLt27cjLS3N4wbZnnyTp6WlMW5pMpkMZrMZDoeDllUoo4IbBV06MzrCWbp06ZsAhNHR\n0f8PANrb299funRpd25u7mquz+Yu2EbbDz/88BMAfsHn8x/h+lzuIDs7ezuAW69ucflDbm5uAddn\nogyPG63roVBGLNnZ2YsAvADgrtzcXB3X53E12dnZcwGsy83N/XV2dnYqgH/k5ubO4vpclOFB78co\no5Ls7OwFANYD+F9vDLhXuQNAPgDk5uaWAgjMzs6Wc30oyvCgNV3KqCM7OzsAwBsA7szNzVW7+VpS\nAP8EEAZAAuAvubm5B915TRZKAIWsx+1Xv9bloetT3AANupTRyEMAggHkZmdnk68tzc3NrXPDtRYC\nOJ+bm/t6dnZ2DIDvAHgq6PbtqfDohu7RD63pegmFhYV8Pz+/58RicSqPx6NlIzeg0WhCW1papqSm\npv7HE9erra2dIhKJjOHh4SqLxVK6cePGJ5xO59Tc3NxuT1yf4h5o0PUSVCrVn6OiorKlUqmD67N4\nIw0NDSk2m02kVCorJBKJ0RPXNBgMMo1GExEZGVmuVqtleXl5khUrVkzwxLUp7oNmRF6CWCxOpQHX\nfYwfP75MqVRWtLW1TfBUoiKVSnvEYrGhoaEhxWAwjJ8xY8ZPHrkwxa3Qmq6XQEsK7sFoNEqFQqFV\nJBJZr2a4PLvdLhQKhTZPXD8kJKSR/Ntms3mrSmNMQd+oFMp1MBqNfhqNRomfg57Q4XDwBQKBRwIu\nxTuhQZfiElQqlVgmk02fMWNGMvt/ra2t/Tppl5eXi7///nspACxfvjyqrKxsyGa8Z8+e9S0uLvYZ\n7PcHBgZOHez3KhSKdrvdLmxoaEhubm5OHDduXB1d7kkZDrS8QHEZEyZMMJ07d041mO/95ptv/PV6\nPX/evHmGf/zjH/XDue4nn3wSmJmZ2TNlyhTzcH5Of/D5fGd4eHi1q38uZexCg643YjPz0FHl2jUO\nwXEWCH2G1EHKy8uTv/TSS5ESicQREhJiff/99+u2bdsWIRQKnTExMZYdO3Yoc3Jyavfv3x/U0dEh\nrK6u9qmvr/fZsGFD40cffRTc0NAg/uqrr8oTExMtWVlZE5qbm8VGo5G/fv36pvj4eMvHH38ccvDg\nQYVSqbSazWb++vXrI0UikTMiIsKyb9++WoFA4Fy0aFFcU1OTeNq0aT39nTEnJydo9+7dYXw+3/nM\nM8+0Pv7445qXXnop7N///negw+HA/PnzdX/961+b16xZE3G9M6alpVmeeeaZyNOnT/s5HA7eypUr\n21auXKnOysqKFYvFTrVaLdy/f391VlZWnMFg4BuNRv6OHTvq5s2bZ1i/fr3yyy+/VPD5fNx9993a\nrVu3tgz790YZcdDyAsXtvPPOO6FvvPFGfUFBgeqhhx5S22w2PPTQQ50rV65sXbJkSa/mkEajERw/\nfrx84cKFmj179ow7fvx4+b333qv57LPPFG1tbcL58+d3FRQUqHJzcys3b94cMWPGDOPcuXN1L7/8\ncuO8efMMq1evjv76668rzpw5cyU0NNT24YcfBubl5QVYrVbexYsXy5YuXarWarXCPtfkb9u2LeLM\nmTNlR48eLT9w4EAQ+f/Onz9fdvHixbIDBw4Eq9Vq/o3OeOjQIb+6ujrx+fPnVSdPnlS98cYb4Xq9\nnoefyxq2b7/9trKhoUG0fPnyjrNnz17ZvHlz49atW8MBYNeuXWGFhYVlRUVFZYGBgXaP/YIoHoVm\nut6I0McJZarLb7VvRHV1tWTGjBnJ5HFCQoJp3759tVlZWeqnn346ZvHixZ3Lli1TR0dHD9iIyszM\n7AGA8PBwC4/HcwJAWFiYtbOzUxgcHGwvKCiQpaenh/B4PGff4FlfXy+sra31WbhwYQJ+1rnyg4OD\nrc3NzaJbb71VDwC//OUveyQSSS9p3cWLFyUJCQkmPz8/p5+fn/3IkSOV+Fmy5Zg5c2ayQCCAVqsV\ntre3C290xuPHj/tduHBBRl4Hh8OBuro6EQDMnDmzBwAiIyNtGzduDHz77bfDzGYzn0j9fvWrX2nm\nzJmTnJ2d3fn44493uvBXQxlB0KBLcRkD1XRXrVqlvu+++7r279+vWLhwYWJubm7lQD9DKBQ6Wf9m\nvu50OnnvvfdekEajERQUFJS1tbUJMzIyUtn/rUQicYaGhlr7nuHFF18MY3vtOhyOXp0woVAIh6O3\nxPnKlSviXbt2hRUXF5cEBAQ4EhMTJw7mjGKx2L5kyZKO11577ZrSgFgsdgLAq6++GhoREWHJz8+v\nPnbsmHTt2rVRALB37966CxcuSPbu3Rs4Z86clOLi4hKRSDTQS0UZpdDyAsXtrFu3LlwsFjvXrl3b\ncf/996uLi4slfD7fabPZbkoG0NHRIYyNjbUIBALs3btXYbVaebjqr2uz2XghISF2/DwSLQGALVu2\nhJ49e9Y3JSXFVFRUJAWA7777TmaxWHpdd+rUqaaqqiqJTqfjGwwG3uzZsxNbW1uF48aNswUEBDhO\nnDghbWpqEpvN5hued/bs2T2HDh1S2O12GAwG3u9+97uo/p5HfHy8GQA+/fTTQKvVylOr1fy1a9eG\nT58+3fTmm282BwYG2tRqNd2h7oXQTJfiMvqWFwBg27Zt9dHR0Zbbb789KSAgwB4QEGB78cUXW+Vy\nuWPlypWxISEhg9a8/va3v9UsXLgwYdasWbKlS5d2hIWFWdetWxd+2223dT/33HNRcrnc/u6779Y8\n+uijsSKRyKlUKq1r1qxpnzZtmunDDz8MzszMTJ44caIhNDTUyv65crnc8cILLzTNnTs3yel0YtWq\nVa2zZs0ySKVSe3p6esrMmTO7lyxZ0v7kk0/GkDLFQMyfP7/ntttu654+fXqK0+nkPf744219v2f5\n8uWdjz766IS8vLzAp556qu3zzz8P+te//hXY3t4unDx5cqpMJrPPmDFDHxYWRuu6Xgj1XvASampq\n/hUbG5s6iG+ljFJqampKY2NjvXJDxliClhcoFArFg9CgS6FQKB6EBl0KhULxIDToUigUigehQZdC\noVA8CA26FAqF4kGoTpfiMi5duuTz7LPPRnV0dAjx87YFywcffFAXHh5umzVrVpLdbudVVVVJgoKC\nrAqFwv4///M/XW+++WYz1+emUDwJDboUl2Cz2ZCVlRW/c+fOugULFugBYP369connngi6ssvv6w+\nffr0FQDIysqKXbx4seY3v/kN3YJAGZPQoOuF2MxOXmetzaXWjuNihBahD2/ASZr8/Hx5cnKykQRc\nAHjllVdabmb45uTJk76rVq2K4fP5yMjI0L/33nsN+fn5/ps2bYoUiUTOgIAA28GDB6v+85//+O3Y\nsSNUKBQ6L126JP3jH//YfPjw4YDLly9LN2/e3PDII49oP/roI8WOHTuUAoHAOW3atJ6///3vDTt3\n7hz37bffBrS0tIg+++yzqi1btoRduHBBZjab+cuXL29fs2ZNR18bys8//7zax2dolpYUSn/Qmi7F\nJZSUlEgmTZrUa0uuQCDoZQhzI5599tnod999t7aoqKisvb1deOXKFbFarRYeOHCgqqCgQOXv72/P\ny8uTX72eNC8vr3rnzp11r7zyyvgDBw7U7Ny5s/ajjz4ap9Pp+Nu2bQs/efKkqqCgQNXY2Cg+fPiw\nDAAaGxvFBQUFqrCwMFtsbKylsLBQdebMmbKtW7dGoB8byoE2X1AoQ4Vmul6I0IfnDEsSedTakZjO\nkMd33HFHfHd3t7ClpUV0+fLlEn9//xtuKq6pqZHMnDnTCACff/55DX52+/J59NFHY202G6++vt5n\n3rx53XK53JKammrw9fV1jh8/3jJhwgSTXC53REREWLu7uwWFhYW+zc3N4rlz5yYBQHd3t6CqqsoH\nAKZNm9bD5/MhlUqdarVaOH369BSRSORUq9VC/Fz+GLQNJYUyFGimS3EJkydPNhYWFkrJ4yNHjlSe\nO3dOZbfbeX1tEweiv91jTz75ZGxOTk5dQUGB6q677tKSr7PtFQWC/0tGnU4nz8fHxzFx4kTDuXPn\nVOfOnVOVlpaWPPnkk2qw7BW/+uorv2PHjvmfOXNGde7cORUpIaxatUr9448/qoKDg20LFy5MvHDh\ngmQYLwuFcg006FJcwsKFC7ubm5vF+/btCyBfO3HihLSnp0cgEAgGVRNNSEgwHj16VAYA2dnZMUVF\nRRK9Xi9ISEiwdHR0CE6dOuXf15axP6ZMmWKurKyUNDY2CgFg9erVEdXV1b2Madvb24UREREWHx8f\n5969ewPsdjvPZDLx+rOhHNILQqEMAA26FJfA5/Px3Xffle/Zs2fcpEmTUtPT01P+9Kc/RX766afl\nfn5+gwq6O3furF+3bt34W265JVmhUNjT09NNy5Yta5sxY0bK0qVLY/7whz+0bN++PbyxsfG6zt7+\n/v6OrVu31i9YsCAxPT09pbOzUxgTE9PLznHhwoXd1dXVkszMzOSKigqfefPmaZcuXRpNbChnz56d\n9NNPP/k+8MADXcN9bSgUNtTa0Uug1o7eD7V29A5opkuhUCgehAZdCoVC8SA06HoJTqdzcBIByqiF\n/o69Axp0vQSLxVJqMBjo79NLMRgMfIvFUsr1OSjDhw5HeAl6vf71+vp6iMXiVB6PR4OvF+F0Oh0W\ni6VUr9e/zvVZKMOHqhcoFArFg9CMiEKhUDwIDboUCoXiQWjQpVAoFA9Cgy6FQqF4EBp0KRQKxYP8\nf96g5iwaTY72AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139627220744656" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625802343376" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCoXiRf4/Ox1oUpUFn4cAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625645333136" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nA0xjbDCA2u6EAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625450337424" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625644538576" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsfXd4HOW5/ZnZXtW7ZPViybZwxcaA\nueBCTQCDk8CPYBIcwiUEcAgQ2g0todwQ7iWES+wLuRAwNr0YCITmgsEFW26yLWm16itptb3vzHy/\nP+QZZle70kq7Wltmz/PosXd3Zr5v2pl33nJeihCCFFJIIYUUkgP6RE8ghRRSSOH7hBTpppBCCikk\nESnSTSGFFFJIIlKkm0IKKaSQRKRIN4UUUkghiZCO8XsqtSGFFFJIYfygov2QsnRTSCGFFJKIFOmm\nkEIKKSQRJw3pKpVKvPXWWyds/DVr1uDyyy8/YeOncGJhNBpBURR2794NAKitrcVTTz11oqeVwimI\nk4Z0fT4fLrvsMuD4DfDKK69M6njhY6xbtw5vvvnmpI4Zju7ubpx33nmgKApmsznqcrt374ZUKsXv\nf/974btgMIhbbrkFZWVlyMjIwNKlS9Hc3Cz87nA48NOf/hRFRUXIzs7GpZdeir6+vknfp1MFR48e\nxa233hrTsk899RQ8Hs+kzylReOGFF9DQ0ACtVouamho8+eSToy7/7bffYvHixVCpVCguLsYjjzwS\n8rvP58Mtt9wCmqbx+uuvh/zGsizuu+8+lJaWQqPRoKamBv/5n/8Z1/zHuvbFeOutt0BRFP7+97/H\nNWYicdKQrhhvvPHGpJNuMsYYDVu2bMGCBQtQVFQ06nIMw2DNmjXQarUh399///349NNP8cknn6Cr\nqwuNjY246KKL4Pf7AQA33HADuru7sWvXLrS0tECpVOKKK66Y1H36PsJsNmPt2rVThnTfeecd3Hzz\nzfiv//ov2Gw2/PWvf8Xdd9+Nt99+O+LyAwMDWLZsGX784x/DYrHgnXfewcaNG7Fz504AgMlkwrx5\n8+DxeBBJUuDBBx/Exo0b8dFHH8HpdOK5557Dfffdh40bN054H8a69nk4HA7ceuut0Gg0Ex5rUkAI\nGe0vaQBAXnvtNfLQQw8RmqYJTdNEoVCQ7u5uwnEcefTRR0lNTQ1RqVSkpqaGvPjii8K61157Lbn6\n6qvJJZdcQnQ6HSGEEKvVSq6++mqSl5dHtFotWbhwIfn6668JISTiGNdeey256KKLhG1+8MEHZO7c\nuUSj0ZD8/Hyydu1aEggECCGEvPDCC6S6upq88cYbpLq6mqjVanLOOeeQnp4eQggh119/PVEoFBH/\n+Hm/9tprZO/eveTzzz8nAMjg4GDE4/LYY4+RCy64gCxZsoT8x3/8ByGEEJZlSUZGBnn55ZeF5bxe\nL1Gr1eStt94ig4ODRCKRkO3btwu/d3Z2EgBk7969whwvu+yyqOejo6NDOJ75+fnk1ltvJcFgcMxj\nSwghS5YsIffeey/5f//v/xGtVktKS0vJJ598Qp577jlSVFRE0tPTyW9/+1theb/fT26//XZSXl5O\nVCoVaWxsJB9++GHI9tauXUsWLVpEGhoahPn94Ac/INnZ2USv15PzzjuPHD16dIyr7DsYDAayZMkS\notFoSH19PXn55ZcJALJr1y5CCCGlpaXkiSeeIIQQcuzYMbJixQqSnp5OdDodWbJkCWlqaiJGo5HI\nZDICgCgUCvLHP/5ROLezZs0iWq2WFBQUkLVr1xKGYQghhHz++edEJpORrVu3klmzZhGVSkXmzp1L\nDh48KMztiy++IPPmzSNqtZpUVlaS559/Xvitt7eXXHHFFSQvL49oNBqyYsUK0tLSQggh5Msvv4x6\n3S1btowQQsg//vEP8uc//znkWCxZsoTccsstEY/Tgw8+SBYvXhz1OB44cIC8+uqrhIjuYTE++OAD\nsnPnzpDvZs+eTe666y7h8//+7/+SmTNnErVaHXLcI2Gsa1+MG2+8kdx4442ktLSUvPDCC1G3OUmI\nyqsnHemS4yQqJsC//OUvpLi4mOzfv58wDEM2b95M5HK5cINce+21JDMzk7z88suEZVlCCCFr1qwh\nixYtIjabjfj9fvLrX/+aFBcXC9sMH0P8+dChQ4SmafLiiy8Sv99P9u3bR4qLi8kDDzxAyHHS1Wq1\n5LrrriM2m4309PSQ0tJSctttt417v0cj3ba2NpKdnS0QBE+6x44dIwBIc3NzyPLz588nd999N/n4\n448JAOL1ekN+z8nJIX/7299imtfs2bPJz3/+c+JwOIjRaCTl5eXkD3/4AyExHNslS5aQ/Px88q9/\n/Yt4vV5y8cUXk8LCQnLrrbcSr9crENyRI0cIIYTcfvvt5LTTTiMGg4EEAgGyfv16olAohIcYv73P\nPvuMcBxHCCFk2bJlZOXKlcTj8RC3201WrlxJzjzzzJiP+1lnnUUuvvhiYrfbSVdXF1myZElU0l22\nbBlZvXo18Xq9xOv1kjvvvJMsWLAg4vnr6OggEomEbNq0iRBCSHNzM0lPTyfr168PWf7KK68kJpOJ\nWK1WMn/+fOEB2N3dTbRaLVm3bh3x+/3k008/JXK5XHiAzp8/n1xzzTXEZrMRh8NBrr/+ejJz5syY\n9zscLMuSioqKqES3dOlS8otf/IJcddVVJC0tjdTU1ES9hiKRrhg+n4+88sorRK/Xk2+++YYQQsj7\n779PdDod+fLLLwnDMGTHjh0kIyODvP766xG3Mda1z2P79u2kqKiI2Gy2FOlGneEopDtz5kzy2GOP\nhSx/+eWXk5tuuklYvqqqKuR3v99PnE6n8Hn79u0EAOnr64s4hvjzrbfeOuLp/sADD5Dp06cTcpx0\nAZDu7m7h9+uuu46cf/75497v0Uh32bJlws0gJl1+X0wmU8jyK1asIL/4xS/Iyy+/TJRK5Yjt1dbW\nCsQ5Gr799lsCgHR1dQnfffPNN2Tbtm2ExHBslyxZQi6++GLh92eeeYYAIENDQ4QQQtxuNwFA3nvv\nPcKyLElLSyMbN24MmcOcOXNC9n3p0qUhv3s8HuLxeITPL7/8MlEoFGPuGyGEmEwmAoBs3bpV+O6t\nt96KSrrz588nv/zlLwXC5/8lUc6fxWIJGW/ZsmXkhhtuCFmeP5bk+LVVV1dHCCHkySefJBUVFSHr\nv/fee+TYsWNkz549I867zWYjNE0L8x4v7rzzTlJYWEisVmvE3+vq6ohOpyNvvvkm8Xg8ZMOGDYSm\nafLpp5+OWHY00r3++usJRVEkLy+PvP3228L3l1xyCbnxxhtDll27dm3IvSnGWNc+IYQEAgHS0NAg\nzOVkI92T0qcbjmPHjuHee++FUqkU/t577z10dnYKy5SXl4es097ejh/96EfIysqCQqHAv/3bvwHH\nnf5jwWAwoL6+PuS7qqoqGAwG4bNSqQzxx6rVani93rj2U4yXXnoJZrMZt912W8zrEEJAUVFzssf8\nnUdbWxukUimKi4uF7xYsWIDFixcDMR7bkpIS4f9qtRoqlQqZmZnCZ375gYEB2O12XHPNNSHn98CB\nA+jo6BC2EX5+m5qacMEFFyA9PR1KpRKrV68e4dOLhu7ubgBAZWWl8F1DQ0PU5R988EFs2rQJZWVl\nWLNmDTZv3hzRf8lj/fr1qKmpgVqthlKpxKeffjriuquqqgo5Pvy109bWNmJfL774YlRXV+PYsWMA\ngNLSUuE45eXlgaZpGI3GmPadB8dxWLt2LV544QV8+OGHSE9Pj7gcIQTnnnsuLrvsMqhUKvz4xz/G\nueeeO+54yLp16+D1evHMM89g9erVQtD62LFjWLduXci5/8tf/hJyb8cC8bX96KOPoqKi4qSNYUwJ\n0lWpVHjuuefg8/mEv0AggHfffVdYRi6XC//nOA4XXnghFAoFDhw4AL/fjy1btsQ8XiRiDr/JJBJJ\n1PXXrFkTchGJ/1566aUxxzebzbjjjjuwbt26iOPk5eUJy4Wvl5eXh7y8PPh8Prjd7oi/jwWKor57\nFQpDrMeWpulRP/PgCfijjz4acX6ffvppYTnx+bXb7Tj//PNRX1+PtrY2+Hy+mI4rD56cWZYN2a9o\nOP/889HV1YUnn3wSLMviqquuwk9+8pOIy/7973/H/fffjz/96U+w2+3w+XxYvnz5iOWiXT8URUWd\ni0qlAk3TcLvdIccqGAziiiuuwJYtW6Jed+I5BINBXHnllfjnP/+JHTt2YNasWVH3PT8/X3hY8igr\nK0Nvb2/UdaJBoVBg5cqV+OlPf4r//u//Fvbp7rvvDtkfv9+P/fv3A8dT9/h9WLNmzZjX/tGjR/H0\n00/jmWeeGff8koUpQbrV1dXYt29fyHednZ0hN40YAwMDMBgMuPnmm1FYWAgA2LNnT8zjVVVV4cCB\nAyHfHTp0CNXV1TGtv27dupCLSPx3zTXXjLn+5s2bYTabsWLFCmRnZyM7Oxvbt2/H448/jjlz5qC8\nvBzZ2dlCTikAuN1uHDp0CGeccQZmz54NqVQa8ntrayssFgsWLVoU0/6zLIvW1lbhu23btuHVV1+N\n+9iGQ6/XIycnZ8T5NRqNUa3J5uZm2O12/Pa3v0VWVta458C/oYitqfDzLYbZbIZarcbKlSvx/PPP\n4+2338bGjRthsVhGLPv1119jwYIFuOSSSyCTyRAMBkfddjiqqqpw7NixkH3fsGEDtm/fjurqanAc\nJxASjhsDvJV79tlnR73uPv74Y2Gda665BiaTCdu3b0dFRcWo82loaMDevXtDvmtvb0dpaWlM+3PG\nGWfgb3/7W8h3fr8fMpkMiHJv9/b2IhAIAMdT9/h9WLdu3ZjX/quvvgq73Y7Zs2cL905XVxduvvlm\n/PCHP4xpzpONk5J0VSoVurq6YLPZEAgEcNNNN+H555/HJ598AoZhsGPHDsydOxfvvfdexPWzs7Oh\n1Wqxfft2BAIB/POf/xSW7enpiTiGGKtXr8bOnTvx8ssvg2EY7NmzB+vXr8fPfvazJOw9cOWVV6K9\nvR379u0T/ubNm4df/vKX+OCDD0DTNG688Ub88Y9/REtLC5xOJ+666y5UVlZi6dKlyMzMxE9+8hPc\ne++96O3txdDQEO644w4sX74cdXV1Y47f2NiIefPm4Z577oHNZkNPTw9uuOEGtLa2xnRsx4ubbroJ\nTzzxBPbs2QOWZfH+++9HvNl5TJs2DTRNY9u2bfD5fNiwYQO+/vrrmOdQWlqKhoYGPP7443A6nejo\n6AixqsXwer2orq7G008/Db/fj2AwiN27dyMnJwfp6elQqVTAcXJwuVwoLy9HS0sL+vv7YTKZcOON\nNyInJyfmY3PVVVfBarXiySefhN/vx1dffYXrr78eHMehvr4e55xzDm677Tb09vbC5/PhoYcewqJF\ni2JymwHAxo0bsXXrVmzevDmiS2Hnzp2oq6uDzWYDANx44404dOgQnnrqKfh8Prz22mv4/PPPY74X\nzjzzTDzyyCPYu3cvWJbF1q1bsWHDBlx66aUAgH//93/H5s2bsWHDBgSDQRw+fBhnn302/vrXv0bc\n3ljX/m233Ya2traQe6ewsBAPPvgg1q9fH9OcJx0nYyBt69atJCcnh2i1WrJ7927CcRz5wx/+QEpK\nSohSqSQ1NTXk2WefFdYND4oRQsiGDRtIUVER0Wq15PLLLydms5mce+65RKPRkJ07d44YI3wbr776\nKjnttNOIVqslNTU15E9/+pMQQHnhhReIRqMJGe+mm24iS5YsiXl/ly1bRhQKRUjKkUKhIA899FDE\n5cWBNEIICQaD5De/+Q3Jzs4mKpWKLF++nLS1tQm/O51Oct1115G0tDSi0+nIlVdeScxms/D7WClj\nJpOJXHjhhUSj0QhpT3zK3FjHdsmSJUKQM9rxEp9vv99P1q5dS/Ly8oharSaNjY0h0evw7ZHjAaec\nnBySlpZG1qxZQwYHB8nMmTNJWlqakPUwGo4cOULOOOMMolarSX19PXnnnXeiBtI+//xzsmDBAqLR\naEhaWho5++yzhRQ5v99PzjrrLCKTychvf/tbYrPZhONWXl5OXn31VfL+++8TvV5PVq5cGTHw9sQT\nT5DS0lLh89dff00aGxuFa12cMtbd3U0uv/xyotPpSFpaGjnvvPNIU1PTmPvL47zzzhNSJSOllEWa\n3/vvv08aGhqIXC4nlZWV5I033hB+e+ihh4RtACAymSxke36/n9x///2koKCAKJVKUl1dTR5//PGQ\nYOT69etJdXU1USgUpKysjDzwwAMhv4djrGs/HCdbII0ao0daSmXsFEVnZyduv/12bNq0Ka7tEEIQ\nCATAMAykUikkEgkkEklMAbsUUjiFEfUGGEvaMYVTFG+++SbOOeecCa/PcRz6+/shkUig1WrBMAxY\nlkVXVxcUCgVyc3NB0zQoihKImCfjFCGn8H1GytJNYVxgWRYsy4LjOEEkxuPxgGEYaLVauFwuaLVa\nFBUVCVkQCEvpmUwy7u/vHzPI895772HZsmVxj5VCCqMg6sWcIt0UxgQhBBzHCWSL4xHj/fv3g2EY\nVFVVQSqVwuPxwGQyIRgMCqSq0Wig0WigVquh0WigUCgEchV8XGFkTNO04KpIWcYpTFGkSDeF8YMn\nW4ZhBIvV4XDAYDCAYRhoNBrodDoUFhaCYRhQFIXu7m7QNC185/F44Ha7hT+/3w+apkeQsVKpHEHG\nOJ63miLjFKYgUj7dFGIHIURwI/AEaLPZYDAYQNM0KioqkJ6ejs7OzhFVbmKXglQqhV6vh16vD9k+\ny7ICGdvtdiH9iaZpgYR5QlapVMIcWJZFIBCAw+GAw+EQUscoihLImP+cQgonK1Kkm4KAcLIFgMHB\nQbS3t0OpVKK2thY6nU5YnqbpEQUqo1VU8ZBIJNDpdCHbwnEy9nq9cLvdcDgc6OvrE/JPxWTMMIzw\nPcdxIIQgGAwK44utY4lEAqlUmiLjFE4apEg3BRBChOwD/rPJZEJHRwf0ej1mzpwplOuKIbZqR/su\nVvCZEOHawRzHCWTscrlgtVoFK1mlUoVYxmq1WiB+fr98Pl+KjFM4aZAi3e8xCCEYGBiARqOBVCoF\nIQQ9PT3o7OxEVlYWZs+eDaVSGXX9aAQ7UdKNBrEPGADS09NhNptRWVkpaEy43W4MDg4KYtpiMtZo\nNFCpVJBIJCFkzGswhJNxKtc4hclEinS/h+BJh+M4dHR0oKysDBaLBT09PcjPz8f8+fNDBGaiIZql\nmyzwPmC1Wo2cnBzhe0IIvF6v4DceGhqCx+MBx3FQKpUhZKxWq0eQMb9PPT09KCwshFwuT5FxCglD\ninS/R+AzEXifazAYhMvlQlNTE6ZNm4aFCxdCKo39kqBpegTp0jQ9pk93skFRlEDG2dnZwveEEPh8\nPoGMrVYrPB4PWJaFQqEYQcYWi0Uo8hCT8WiWcYqQUxgLKdL9HkBc0IDjKk9GoxFDQ0OQSqWor69H\nRkbGuLcbLWiWaPdCJExkDIqioFKpoFKpBHUyiEqZXS4XPB4Pent7Bf/xoUOHoNPpQshYJpOF5C4n\nq/AjhVMDKdI9RRGpoMHr9aK9vR0OhwNlZWWoqanBkSNHJjzGiXIvJHoMiqKgUCigUChCyHjv3r2o\nrq5GIBAQCj/cbjcYhoFMJguxjDUajUDGfBZIqvAjhUhIke4phkgFDS6XCwaDAT6fD+Xl5aivrw8h\ng4m6A3jSjZaneypAoVBAq9WOEPIOBAJwu93weDwYGBiA2+1GMBiEVCodk4wDgUDI8bdYLMjKyhJ8\nxykyPrWRIt1TBJFybO12OwwGAziOQ0VFBTIyMkbczIkg3bG+OxUhl8shl8tHuGWCwaCQTWE2m9HR\n0YFAIBBSEs3/yeVyEELQ1tYGvV4PhmGACLnGMpkMNE2n0ttOEaRId4ojEtkODQ2hvb0dUqkUlZWV\nSEtLi7p+PCQZKZB2KpFurD3lxJDJZEhPTx8hEM4wjEDGFosFXV1d8Pv9kEgk8Hq96O7uhlarFfQp\nkCr8OGWRIt0pCj69aWhoCH19fZg+fToGBgbQ3t4OjUaD6dOnjygyiISUpTs6EkVmUqkUaWlpIx6A\nLMti165dkMvlQpeOSCXRvD4FRGScKvyYmkiR7hRDePUYRVFwOp3YsWMH0tPT0djYKLSQiQXxkm74\nuskg3WQRSTIeHnyGQ0FBQcj34foUfX198Hq9QjpceOEHYiBjnpBlMlmKjE8gUqQ7RSAuaOCDZd3d\n3UJzxQULFgivpeNBLFoJo617oizdZI1xosgpmj4Fx3ECGTudTvT39wvt2yNV4YlLojs6OqBUKpGb\nmysQcKoKL/lIke5JjvCCBpZl0dnZid7eXhQUFKCxsRFtbW0TIlxE8cvGCoqiwLIs2traYLPZoNFo\nIJFIEAgEwHFc1LbrKUwcNE2PqU8hLokGIFThud1uofV7uD5FqvAjeUiR7kmK8IKGYDAIo9GIwcFB\nFBcXY9GiRZBIJPD7/XFVgEVSCosFgUAAnZ2dMJvNyMzMRGVlJbxeLywWC1wul9ASnb/h+SCRSqWa\nMmR8Ii3d8SJcn4IHx3GCPoXVaoXZbEZ/f3/Ukmj+IZwq/Jg8pEj3JEKkggafzwej0Qir1YrS0lJU\nVVWFkNZESVO8Ph8djwXiarb8/HxkZmaipKQEgUBACPYwDIP6+npBA4G3vgYGBka8CovJ+GS8eU/G\nOY0HYn0Kq9WK3NxcpKenCyXR4owKsT5FuK4xL4g0WuFHioxjQ4p0TwJEKmjweDwwGAxwu90oKytD\nXV1dxIs4Xq2DWN0LPp8P7e3tsFqtKCsrQ3V1Nfx+P2w2W8hyYp+uWANBLEgTLtUo9kuKb3atVhvS\nUSKF+MCybIh7gS+JDten8Pv9Ahn39PSE6FOEB/GikXFrayuqqqoEYflUFd53SJHuCQRvCdpsNqHi\nyel0wmAwIBAIoKKiAllZWaNepPGS7liBNL502G63o7y8PIT8JxpIG+1VWBwkMplM8Hq9I9KneF9k\nCuNDLH52iqKgVCqhVCoj6lPwZNzX1we32w2WZSGTyaDVakPOkc1mE64tvgoPYbnGPBl/3wo/UqR7\nAiAuaPB4POju7gZFUTAYDKAoSqgeiwXxXqjRSJu3tF0uF8rLyzF9+vQRYyVaTzdakCg8fcputwtW\nstjq0mq1kMvlU+rmFfeDm2zEE9wU61OIS6L54g2ejPv7+4X/7927N6QPHl+Fx88lGhlTp3j7pRTp\nJhHhObY4XqprNpsBYEQ7nGQg3L3gdrvR1tYGr9eLiooKNDQ0RL3okyV4E54+5XA40Nvbi+rqauEG\nt1qt6O7uFqq8IpXcnow3LyEkaYFFsXshUaAoKmJJ9K5duzBjxoyQbAqj0RiiTxGNjMUZFadi4UeK\ndJOASGRrMplgNBqFi66xsfGEzI1/BXS5XGhra4Pf74/JrYEwK1kcVEmW5SaRSCI2vhSX3A4NDaGz\nsxOBQCCiGE0sYu2TiWRmSCQ7jS9aSXQwGAwRmOfPj/hhyRNyeEl0pMIPl8sFvV4PmUwmBKHHUyCU\nbKRIdxIRXtBACEFvby86OzuRmZmJ2bNnQyqVCulVJwJerxcDAwNwuVyorKwcoaY1GhLtXkgUopXc\n8je7y+UaYXnxWRRiZbBkgOO4U450x4oxyGSyiOeHYZgQgXn+zUUcA+DJWFwSfeTIEcyYMQMymQyD\ng4Pw+XxoaGiY1H2MBynSnQREKmjo7u5GT08PcnNzMW/ePMHC4v27yYbdbkdbWxsCgQC0Wi3mzp07\n7m1MNe2FaDc730FD7JNkGAZerxctLS0jovWJRDLdC8myqifqxpBKpRHfXMJ9+r29vSH6FB6PB3a7\nHRzHCW80kwG/349nnnkGdrsdwWAQK1eunNB9kyLdBCK8oIFhGHR2dsJkMqGwsBCnn376iAsiUTdB\nrDeU1WoVAnaVlZWgaRrt7e0TGvNU0dOVyWTIyMgYEbz85ptvkJ2dDZfLFRKtl8vlIyzjifpKk0m6\nSFLeMcuyCSW+aCXRLMvC6/XCarXC6XTiww8/REdHB1QqFcrKylBcXIzzzz8/YifriWDPnj2orKzE\nD3/4QwwODuLhhx9Oke6JQKSChkAgAKPRCLPZjJKSEixcuDDhAQwxIpFfOCwWC9ra2iCVSlFdXS1Y\nE263Oy7thWhzmUwki9hpmh5BxuGpU+F5rOKCD77p5WhIpnshWZiMgF0kSCQSaLVayGQyVFRU4Kab\nbhJU9uRyObq7uxNK/meccYbw/6GhoXG54sRIke4EwZNtZ2cntFotdDpdSDuc0tJSVFdXJ8WK4QNa\n4WMRQjA0NASDwQCFQoG6uroR1kKiG0lORUt3PBgtdUpcVBBe4SVOa+PLbTHFSo1jRbJIFxHiByzL\nQqVSobCwECUlJZMy5r333ouhoSHcddddE1o/RbrjRLhoON+mxWg0wuv1jmiHkwzwLcTFczSbzTAY\nDFCpVGhoaBhRiMAj0dkGpzrpRsNoRQXictuhoSF4vV4QQqBUKiGTyQTLebJ1KZJ1XpJJuhzHhYzF\nF2tMJh5++GEYjUY8/fTTeOKJJ8Z9r6dIN0bwZCtuqWK329Hf3w8AmD59OjIzMydMtvFYPLz+AiFE\nEDLXarWYOXPmmP6seKQdo23v+0i60TBaua3X64XZbIbD4YDRaBRUwSJJNMZLxsk8J8kkXYZhQlwI\nifYni2EwGKDX65GdnY2ysjKwLAuHwzFqZ5ZISJHuGIiUY2uxWGAwGCCVSpGTkwO1Wh1i3YwX/Cv+\nRC9UiqLQ39+Pvr4+pKWljUvIfDLcCymMDV6XIi0tDV6vF7W1tUAEiUaxSFAk8fJYj/dUL8KIhkik\nO1mW7uHDh2E2m7F69WrYbDb4fL4JFTOlSDcKIpHtwMAAjEYjVCqV0A6np6dnXCpdkSCRSCZ0oXIc\nB5PJBIvFApqmMXv2bCF/MVYkinRT+rkTQ/gbTry6FHwOazgZJ/P8nEjSDf+cSCxfvhzPPvss7r//\nfgQCAfz85z+f0DFNkW4Y+EwEnmwJIUL1WHp6+ohXdqlUCp/PF9eY4T7ZWObIF1lkZWUhJycHpaWl\n4yZcJMAdwLIs9u7dC5fLJQSZ/H4/TCbTiKBRCiMRKxnGqkshzmENL/ZIJulOFvGFI5nuBblcjltu\nuSXu7aRI9zjCCxo4jkNPTw9n7jMFAAAgAElEQVS6urqQnZ2NuXPnRuzOIJFIBD/vRBGrJi4/p87O\nTuTk5AhFFs3NzRMusJioO8DpdKK1tRU+nw8zZsyAVqsFx3Hw+/3Yu3cv/H4/LBYL3G43kGD93FPJ\nbxxv9sJoOaxiXQqHwwGn04k9e/ZMui4FwzATMgAmOhZPsnxGUbKs7Inie0+64QUNLMuiq6sLPT09\nKCgowIIFC0b1EfGugXgw1jb4irbu7m7k5eWNmFOi/bKjwel0oq2tDQzDCN0iMjIyEAwGhQi+VCpF\naWmpsI7YTxn+aixOpTqZhWkmC5OVpxuuS+F2u2E0GlFbWyuUQk+WLsWJci8wDDMl+rx9L0mXfyIO\nDg7C6/WioKAAwWAQHR0dGBgYQFFRkdAOZyxIpdK4Ld1opCt+AOTn50esaEOSSJcn22AwiKqqqpil\nJxHmp8zNzRW+51+NXS4XLBZLCAHwJMz/m6zX1WQjWQEu3o0RrdQ2kboUySZd3qpOplsjHpz8M0wg\nwjs0BINB2Gw22O12WK1WTJs2DYsWLRrXTTAZli5fPtzX1xe1fDh8/ckiXZfLhdbWVgSDwXEL4oyF\naK/GvD6ry+WCyWSCy+UKqfiSSqUIBoOnRPAuWRVpYxHhaLoU4g4fvC4FL1weSZfiRFm6KdI9iRBe\n0EBRFDweD7q6umC321FfXx+1Hc5YkEqlCSFdjuMEa7u/vx/FxcUxlw/H2yctEsZDton2r0aSBOTL\nb3mr2O1249tvvwUhZFL6rSXLZ5xsS3e8iCbPGK2LhFwuh9frxdDQEDiOE/qrTRYiuRdOdpzSpBue\n9kVRVEg7nPz8fEilUuTn5094jEQE0gCgp6cHLS0tKCkpGbe1nUj3glhXt6qqakzLNllBLXH5rUKh\nQDAYDGl+6XK5BMtYnEoldlOcjP7iZJUBJ/qtIJJwOf9g3L9/vxD0DdelEJdCJ4Igw0k3ZemeIEQi\nW15dC4DQDoevCIoH8RAe31m3t7cX2dnZ4yZb8RzitXTFZFtZWRlzsceJyiSI1PxSDLG/WKzNygeM\nxK/GkXyUU5UMo4Fl2Ukfh38w0jSNadOmCaQarkvR1dUVky5FLEi5F04wIhU0mM1mtLe3Qy6Xh6hr\nIUFBsIncmOGddauqquK6+SQSyYQLNNxuN7xeLw4dOiRYtuPZpxNBurHMbyx/cbh2brgllqwuxMkk\n92TqIYiv5Vh1KXi3kdhlJBYvj3R/hFu6yRKfjwenBOmGFzQAQH9/P4xGI7RabVTBl0SQ7ngg7qwr\nbqve19cnlHpOBBOxdMW90ORyOebNmzehm3Kq5cyO5S/mLTGeCA4cOBDiokiEv1iMZHZzONl0e8fS\npeDPgdlsjqpLwTCMsF+8T/lkx5Qm3fAcW3E7nIyMDJx22mmjJmkny7/Hd9Z1Op2oqKgY0Vk33gyI\n8bg4xGTLuxF27tw54bFj0fI92SH2F/OWGMMwaGpqQmVlpRC953UQeJdGIvzFybR0p8KrN8JcRjk5\nOcL30XQpdu/ejT179kAqlaK2thZarRa5ubkJf8j84x//QHNzMziOw6WXXorTTz99QtuZGmchDCzL\nore3V6g55zhOKB4Ib4eTLES6edxuNwwGA9xu96iddeNN+YqFdD0eD9ra2uDxeASy5efCK41NxNKN\nV6znZEa0m19cehvehTg8v3is191k+nQjVVROJUTSpdi5cyfmzp2LjIwMNDU1obe3VxCmeeSRRxJ2\nXR48eBBdXV145JFH4HQ6cccdd3x/SJdhGDAMA5vNBoZh0N/fP2o7nGSAt1T5sfmglM/nG0FwkRBv\nIGw00haTbUVFBbKzs0fMJZ5g4GjNKaey9Tva/KP5i/kuxLxV7HK5wDDMqO19TrWAXTJdTfyxo2ka\nVVVVYFkW06ZNCynASRTq6+tRVVUFANBoNPD7/RM+plOOdGmaRiAQgM1mQ29vLyoqKuJqh8NbefFc\nkHyurtfrFaq2KioqYg5KJcK9EL4+79Lgu/xGIlvx+hO9WcTuBXFGwalMutEQqQuxuL2Py+VCT0+P\n0CJJpVLB7/cLgabJFDFPpkV9ohTGJtOFQtO04Kr87LPPMHv27AkfzylHuna7Hfv27YNer0dubi6m\nTZsW1/b4YFo87giO47B//36h2eN4SmSRYJ9uONlGc2mIEY+Q+YnoCJzM3OBEbCNaex++27Df70d7\ne7sQTBVbxFqtFgqFIu65JIsMT7Ss42RnL+zatQufffYZ7r333glvY8qRrl6vx6JFizAwMACn0xn3\n9uIhXZvNhra2NrjdblRXV6OoqGhCc0gE6QaDQRw8eBAul2tU/3G09acS6SYDyWiuqVaroVQqkZ+f\nL1jHvG6uy+WC3W5HT0+P4C8W+4r5hoyx4vtg6U52nu6+ffvw5ptv4p577omrw/CUI12apkFRVMLS\nvSZSxhveWbenpyeukxBPIM3r9aK1tRU2mw2zZs0aF9nyiId0aZqGx+NBR0eHII7CcVzSVM8mEyfC\n1xpNN1fsLx4cHER7e/sIDQT+30iklyLd+ODxePCPf/wD991334hzM15MOdLlIZPJ4u7YgHHk6hJC\nBLKVy+UhnXVNJlNcD4CJWLperxcGg0HoPOz1eiccQJioZer1emGz2eBwOFBeXg6O4+ByueD1erF3\n794Q64z/mwrJ60iy9kIs5B7JX4zjGgh8frHYX6xUKkPIOBkVaUhyKW64lu5kku5XX30Fp9OJP//5\nz8J3v/rVr0Lyi2PFlCNd/gJNpKU7GnmHd9atr68f8aSL1z0wHp+qz+dDW1sbHA4HKisrUV9fL7SC\nnyjGa+n6/X4YDAbYbDaoVCpUVlZCp9MJ23A4HKirq4NUKo1onfHRfP7vZOwuMVWyCuRyOTIzM0f4\ni30+n0DGg4ODsFqtOHDgwAj94kRX3p1IhbHJ1NJdunQpli5dmpBtTTnSxXGSmmxLdzyddeN9AMRy\nofh8PhgMBtjtdlRUVIS0eY9X8CbW9QOBANrb2zE0NISKigrU1dWhubl5xHL8vMKFtBFW/cULafPV\nRuEFB4kIIE0UySLdyRhHXOnF5xd/++23mDFjhnDsxa19+DeScDH5iSDZpMuPlcxx48WUJF0k2NIV\nb4cQgv7+frS3t0Ov18fUWTcRmrrREE624dVsSIDvcSzSDQaDMBqNGBgYQFlZGWpqakIKKyIF0qJt\nL1L1F0YJIEUSND+VkMwyYKlUKrxliMH7i3mrmBcwj9VfLMaJEjCfKgpjmMqkmyjrgG8sSQhBX18f\njEYjMjIyxtVZVyqVIhAIJGQ+PMRkW15eHpFsE4VoPl2GYdDR0QGTyRRV4D1Sju9E5hktgBQMBoXX\nZF63NRgMgmEYGAwGYZ1EayJMZUs3EkYTS4/VX8zLNPLKYDwRi91DyW5KyRP8VNHSxVQl3USmJEkk\nElgsFvT19SEzMzNqA8qxtpEo4RyxAlk0yzbRCLd0+TZB3d3dY4qpR7NqE3V+ZDIZMjIyQnKfPR4P\njh07Bp1OJ1R/eTweoUw0XBPhZEYyhWjGex2N5i/mffViMRq1Wo1AIACdTgev1zvpSm3ivFyWZadM\nkHZKkq4YE7UUeJHl9vZ2SKXSuPQaEuFe4DgOzc3NAtlOtJPFRMCTLq9h0dXVhYKCAixcuHBMq+VE\nFUdIJBLk5OSM0ETgyWBoaAgdHR0IBoOQy+UhWRQajWZMojvVLN1EjRFNGYx3DxkMBvh8PrS0tAj+\n4kjiQIlAuE835V6YRIRnMIznCSfurJubm4uZM2eiu7s7rgshnpY9fCaA1+uFXq9PKtmKMTQ0hPb2\nduTl5Y1Lw0JMsDyBnKjiiEiBO4hek10ulyDbSAgRyCBSJP9keO2fSuDdQ0qlErm5uYJ0ZrQHoUwm\nGyEmP17SFN/7KZ9uksBnMMRCuuJXZnFrda/Xm5BuvuPdBl/6abFYUF5eDpfLhZycnLhuwPESBSEE\nJpMJHR0d0Gq1mD9//rgfPpF0Fk5kRRohBPZeAvcQh6JZw5d3pNdkXiYwUiRfq9UKfvpk3MynAuny\nCPetjvYg5MlY3GNtPJ0kxEG7qSJgjqlKuuPJ1eU76/b29qKoqGjEK/NktlCPBDHZlpWVoba2FhRF\nwWQyxZ3rGyvp8ulwBoMB6enpKCsrA0VRE7L2owXSkkW6rkEO5jYObIAAFAXGT3DsMwatXzC48AEl\nJHJAm0Mjr44GRX93bMQygXl5ecL3DMMIvkqv14umpqYRwSM+cJcIX2wyLOpkPgBjzV6I1mPN7/cL\nwTtxOqFKpQpxUSiVyhB/OMuycVWFJhNTknR5jJarGwwG0dnZCZPJhKKiIixatCjixZCIIFgsxC3O\ncRWTLY945R15v+xoRMAXerS1tUGn0wkZGr29vfD7/RMaN1IgbbJJ97M/snB5s2DK9EFfQKFghgTq\nTBqEAB3fsDhtpQynr5Zjx/oAfvi4Cs5+Dm1bh8+PTEWhqFECqSJ6JD89PR0URYFlWdTW1o4IHg0O\nDoaI04gLPU7GwF0yFd/i8a2K2/qE+4v5txKn04m+vj74fD54PB40NzejtbUVEokEjY2Nk7avnZ2d\neOKJJ3DRRRfh/PPPj2tbU5p0I5FdIBBAR0cHBgYGUFJSMqbsYzyyhjxGs3TDyVac4xrrNmKdw2i5\ntkNDQ2htbYVarcasWbNCrIJ4SDLZgTSfg0CdTaHkHDNmzSoEGyQIegFHH4eWzxlUniVFyxdBFM6Q\nIL2Ywsur3Vi0RgFaSoEQwGsj2PK0H0wAWH53bCmB0YJH4uaX4f7KWPNbp0LV23gwGXm6kcTLAeCb\nb75BUVERjEYjWlpacPjwYXi9XmRnZ+OOO+5I2Pg+nw8vvPACZsyYkZDtTUnS5S9UsaXLk5vZbEZp\naemEO+vGMx8xxGRbWlqK6urqUeczGZq6OK6E1tLSAplMhoaGhohiHVNJZcx0mEVeHQX+USuRAl6L\nGfa9Zpx9ngkUBfgzVZi583rMqDoX27lfgjYFUL68AEQ37EaoWy5D27bR30xisZiiiZlH00PgO53w\nVnGseeDxIpkFC8kW1tHr9bjgggtQVlYmNAyIp99gJMhkMvzud7/D22+/nZDtTUnS5SGVSuH1enHk\nyBFYLJaYyG2yEQgEYDQaBfKPdT6J7pPmcDjQ0tICiqJCxHliWXc8SDbp9h1k0Zj/CsihJij6smC1\n6DHkqMD0s6QgtBaUzwlJ71EETvsRJH0HsGjBFrz12g+Qn7UDerkJoCUgtASSrnqAmwfQkW+BWF9T\nd/3DD1sXgUwNpBfT0GZToCQ0AD0APeQA5MMbhN/hh9XnQ5/PB5/PhkAgiP692dh2ixNXbrLH3OJn\nvDgZm1LGi3A3hjhPd6wK0vFCIpEk9KE1JUmXoij4fD6YTCZBXCXcRzpexOsLIoTg2LFjGBwcFNqq\nj+dCT1SfNJfLhZaWFrAsi+rq6hFVRtHWFZPki9fa0XeIwYW/10ClH30fzGYJBo4CrSovPA4GQRdg\nt6WB4mictYYBJQEIB4AAhAz/y3GAZ4jAYeJQf4EMurzYj5PLTKAv7MC3DWvg0zXA2U9QtlAKBgDl\nsUDSvh2B+deBzfsS/iW/gertW3DRbxbjtYfPwZV/9IACA4pjgIOtoNxmEF1+zGNHgq2LYNnvlAi4\nCWw9HFyDZHh/AYAa3l+pEkgvlkCXqwEtGX7TMH7N4MC7QXAeK8rPHr72xC1+FApFiIsiHlGgZJNu\nMhAMBpMuYJ4oTEnSDQQC2LdvH3JycqBUKlFQUBDX9iaS7yuei9FohNvtjsutEW8gjeM4HD16FBzH\nobq6elzdK8KDYWf8XAVtDo3/u8YOAPjho1pIZOKUsO/WtXdL0P4pjaDHhxk/8mPGSiUGB1wY2pcO\n1yABywwvT1HDJERRAEUDujwKGdOkcA4Q6PIwLlAAHJ1yZBQOEy4AUK4BSLr3gKm/GNjOgkhkgFwN\n75XPQbXpeiy782l89HQGzr9fBQKAZPhBZNGj3bE+hCU2A2QfvAqFhIYOGLak1VkgmmwQdSYILUXA\nT8PerEDndhk6Duqx/4tsTKt3oqDSjTklL6F1ax3KO9wInPFLYWw+ih9NFEgcuBtrnsmSdUwmIlm6\nqTzdSYRcLsfChQvhdDrR3t4e9/YmQrpiEZjS0lLodDoUFBRM+OKeqHuB78tmtVpRVlYmpH+NB5Hc\nC/nTpZj5AwXmrFLi/66xo+x0GVY9rQvZdts2P1xDAeine1E4U4J9f0tH00tA0TIGMl0/cnJ7oc+I\nThBuCwenaXxuCIoCunuKQHIolMw5Trj2Hkj6m8HUXRBhBRrey55GwVs3o3zR/2Df6wHUXyiDTBoA\nJNEzDWIl3fxaDt24AHkrFg1/wQZBeSyg3IOgPBaA4yCTsfA4JWjdk4HcUjd+9ew+KAb3wfj2EeTW\nDeJI6c/A5XSI9jF6FJ8P3FmtVnR1dSEQCAiiQOJCD/HrcLK6NSczNS2Slm5Ke2ESESmQFg/Gk6sb\nTra8ZdvX1xfXiZdIJOPaF7EgTmVlJaRSKXQ63YRcJNEyOAgB8uukuHNXFlq3BPD4fAtOu1yBFXdr\nYbVasf01G4rOsaEsU4PZZ5XjnGuD6NzJYscrGXB1SKE9VwKFwh1CEHxkX6vVgg5owRElgNiPWc9+\nFlXz1VA1BMAyBFJHB2hrB5ia77ROpZIwQpVr4Fv+ezRuuwcf9TyEli8YlGR5AGn86V0lF9XhyFOf\nIO/C419IZCC6PBBdHjiWoHMXi87dDPQFNM78nQxqfwvkO94Dl9eAwLyf4tsKCaijTrDZVWOONZYo\nUKTGl1qtViClyU4dS6ZFLSZd3n0yWWMbDAa8+OKLGBwchEQiwddff43bb799wh0kpiTp4jjxTpa8\nYySIyTaS4la8DS4lEgl8Pt+YywUCARgMBlgslhBBHLvdHrNPmPETOPo5OEwc7L0sWrYyqP7pd+sS\nAsj+fAbo9gdAt0gBQlCTD/zuFYKv3lHjsXk1mHf2l8jxZqLw6FGUTDsM6QdaSNggalgG/pwieNQ6\nDG7IwYB/JhZfbkZdVh/oQDfI0ACCQQbBYBB2qxI+qwS7PBdDrVZDp9ONme966RMqMP90oKNPhp7P\nusA5HeDyFwMmRpg75bSi1VYKrkd0Tkkh6MBqlMs3482Hl+PW/w0M+zmiIFaC0uVJ4XKE3nxskKBj\nJ4veAwzUmRRmXSZHhrobii3PgMuYBt/FjwG0FEquA/7DRmTqBkHSZsZy6iIikigQ3/jS7XYL/QR3\n7doVIgqU6G4eyVYY48ea7KrBiooK/P73v0/Y9qYs6SKBOrajkW4wGERHRwf6+/ujyhsmYi5jBdJ4\n0ucDdeLAIRskcPXIYDlAkHMZgd85HKRyDnAg3PEAlsgXSzjA2s1Ck0kjq0wCWiUFS74bm6KBlpKn\nUNG2CbJN74KtWwFvzYXo7etD5kwa/36ZDDtfPwv7t9BgS6cjo1CFrO0PD8+z/mIE0kpQeZYdAwdY\nVM/oxZGvM/HVQCnOulEG/eIsgKIgA6Ac5ICmXZg7d67w2myxWEKEasI7TKQV0pDmD8CqPYry0gKw\n0xaMPJYdXWALZgHy8Mu7AbL9R3DHog/AyfKQKAVkguEDG/QRdHzDwGsnoGkKfQc4ZJd4sfvzo5DI\npcg99z+gZGWgdgC6XBby4nwMvWJB7cxjAJ3YV2O+8aVarQbHcdBoNCgrKwvRQkh0N49ka+nyD+ap\n5FrAVCZdXlglEYhEugzDwGg0or+/HyUlJWMGyOIRvcEogTSxpm1J8TTUlcyHtZ3gi9c9cJs56PJo\n0BIKJqMCFAVkZQeh0FHQ59PIrpCBlg4fI44l6N7HwGvnIFNSmH2FEjLl8G/2f/nAiNwLMiWFpi8y\ncfHDd8G/Oxfu3hZkvnsL8k6/CYplvwZFUTjvLiAQcGHwq3a8+M4FuPpnPuQtmwnVh/dAPagDJZ2G\n6h/Xo3egHLmLCU5fJMG2//HD9ZIPZ9+sgDaHFqL8NEVFfG0OBAJwOp0jgkkLOvchWF6DQe1Z0AYC\nI6xiTpcHyCMHyYKzVkK+7WlIB1vAVp0T9XyM51U8wOnR+sEAiCoDbBBIK6QxrdYK00etuCjvMQTP\nPh+BsvPQ0wP4PAAXILD1ENBygt4jRXCVN8N5vGIOFKDLoZBeTEOuScz1LfbpTqSbh9gyHq2bR7JJ\nly/wmUpiN5jKpJtIiEk3hORiIFse8ZYTh1vKzqEgDu/og6nLguzsbOTkzEWggwZTQKF0vhSazO+y\nCwBAppZh9uoAqs4OJaCBFgbWLhYUTaG4UQp1xshXSQqh2QsyFeDz0LDseBl9VCFylv8U6rw8aD59\nFNI/1II5/Wdgl94FSgIsOGs3yHkUPv3TRVAe1uDMGzfDuX0napsfg2RwN4prlsHVeBGOfMJg3lVy\nyLUUtjzth99JMPcnckgUaiDgAhQj84jlcjmysrJGdJjwsj+C3OICc/Aj9Pm8YJnhHE2FUgGVUgWV\nWgX5UDuoKO4DNn8mFNv+e9TzMR7Srf9RAbgjXyFYeyEknBPY9Rk6vvLDp70Qvpx5QM0yyI3bUWnv\nBhgfiDYXVnoW+owqEKYUctaMnIpBKApyQUDD2snhvbu96NzFYualMiy9I74iirFSxibSzSNcKpM3\nOk5Uf7STnXRXrVq1G8CjmzZtev3knukoELeLiTcPkS+yaGtrGzfZ8pioeyHoIzAbWAx2UOgfkEE6\n4MPQ0BDs3n5UzM7AvAtmRryQ86dLce1Laej6Noiac+U4tK0fWx9TYOdfhwAAWRUSnHWDCjnVUtSe\nGybK7rGCGmoD5bGB6jsAxV419OUDwNy5YFkW/ebhYIzW0Y6GK34F+vj4vjPvgnfGHfBveQP+W66G\nrWctBkvyIPnWhYU/U4ChZXj/Hi8W3zMNQ65VyExPB23vRvoXt2NW9gyYrNfA2g2ULpCC8RG8dpMH\nP35UB8pjBYlAupFA0zToOVfC1dyMysZGIMxSsxy31jw2DyiKiuq/9Ixi5Y4X087JgdL6LzAFCtC2\nTgR/vAJH9hSiNHcQnZY58DeXAigFjnOnJGBFutSAaQ0WSKTFKC84gL3/ugjfvj8Ep0UObUYA1XNt\noGeqce7S/ZB0Zkd0o8SKiQp8jxa4i6QQRtO0kG/Md5SYrMBdMn26CcIrAK4CMHVJl0e8ASyGYWA2\nm2E2m1FZWTmmVsNo8xgv6T42b0j4/8zLJJDX22GW70H+7HwsKJ01+oXEMXAe7YDKbYesw4E67ELu\n1TJU3XYrOIbgiYUWfPSwE+A4aNMD+MFNncgr8w1n67uPj6tKBzvnJ2BIGjjXC+jq6kJnZyfS1EUo\nrZWgt3sGuO0sABagAKmCgjqdgnLJSqT/4EpoftOM+eonIQtqEFjwHiy9QSy5RQmzwQ2fuQiDtYtB\n27pBuWeBQhrSD/8ZmYVKUMtvACWVo3aZDJTbD8rRh3iSjaJZatH8l3zhgdh/GU4O4430M/UXg0jk\nYLOrQQ8Z0PUpi/PPew2UNgtczrbh3F1tDog6CyzJhqUjE7u+8EJV5MSHH18K/WkcrvjNMeiyg9i3\nWYP5aU/ivaYfIe3T++BffFNcpJvolDGZTIb09HRBMxfHj1dPTw/sdrsQvJvMbh7hpDsFCiM2Anh4\n1apVaVOedPm0sfGeSF7ysa+vDxkZGcjPz0dpaemE5zER98Jvv87EkU/9IDorDm8ZQsvfiuAbHLZK\nJTI7imfLULZAhrrzpMhQd4MaagfvCD26JwN58/Kgv2QWDj3/LVTSAigz+kAf+xQ0gNnnFWPFrUGQ\nrHI4rFnYfI8CAy3D61bM57Ds/jwo9cOpYjabCcqAB/D5BAFzOv0z0McMYM6OflyrL6tEx55r4HZK\nUPjA1dCXZyHzuj9BMcRC3TmA9IVSAGUAWwRp2xfg5i4F0eZB8dF9IFIF/OfcDqJMA90/sqPwWIgl\nJzSa/1JceDA4ODiCHLRaLRiGGR/p1q4I+cxpvZBQHPxzrwYkclAeCxztFgwe7kd/uwoehxS5ZVac\n8YM2zKS2IbCoDPK9HwFDLPTSOdhi/DXmPHo6gge+QmDRL8d5dEKRjIo0vpuHXq9HSUmJ8D3/4OOl\nGsNFgcQPvvE8GCK1Xz+ZsWnTpp5Vq1btBHD5lCXd8WjqiiHW1+X7f7ndbnR0dMSwdnRIJJJxySMS\nQjBg7odNZwA3kIdZi0tRem4zFsyfDzhN8B5rg/GgCoZ9evztrxkgnB4U3YiMYhqWTg7zfqJE4c6n\noHjt/9DISfFR72OYvbwDXNFsQJ0BTu8GSWdAt+9AOmFx1QP5IIWzAIpC27YA/u8aOzx2FoRikV5G\nsPBiFaqrq7+bn0wJMKOnsNUtVYBztaFHU4u8pRvB9B6G4p93Io/I4cxtFB0cGZiaZaBsXYBMNZwy\n5XdC8cWToPwOsCXzE5ZJMBaiFR6EW8UWiwUMw8Bms4WQQ8wNMCkKrD+I7oMy+BwcBo7qAVqPnCoa\nDWdLoM+nEDh4BNyBL4D0dEh69sK3/D9AaCmYLQGY3zbh9BwbiDojtARwAki2CI0YsXbz8Hg8gihQ\ntG4e0cbi9Y6nADYAuHLKki6PWAskGIZBV1eXIGYu1tdNRL6vVCqF2+0eczle07a1tRVpaWmYW1cG\nZb4Btt5udH3sBKf5HJLMPKhmL8D0eXJMB3DR8eyDISOLL//iwZm/VMPey+H1d1fDZloNSq6E1waU\naLagoOXfQAW9kOy9E3RbLrj6C0aIumQ2uDH7nhawNh1UvmIcfIeD2VgQ+kotUwHK47oNHAt4bcMV\nVu4hUAH38WJcAH4HdO4m0C2fgWYYBOsvgb+3Fd60cqQP7zAorw2UvRuU2xx6TirPHj4m+sK4jn0i\nEE4OfX19CAaDyMnJEcihv78fXq83xNfJ/4W7gvoOstjhPB0l1wwLMDRcIkNaLgvZoXch2bsHAIVg\nwTwYZ/8KddPrhfWcJg6mJjdqzmIh3/oU/Of+btz70r3xCxQsyoOkqAqQyJJmCYozCsbCRLp5iN9E\nxNfqFGpK+RqAJ6Ys6RyCln4AACAASURBVMZq6fJk29PTE7WzbbK6R4g1bRsbG5H+3LnDRAYgF8Ay\nSo3DXz2LwgtrkCYJvYhoCQV9Hg25dlg8RWo5jNN/lIndm9Mwe/5BsOXT0bXzItgLH0RGEQXbji/R\n88+dKPhyPeRwgZu2AM6aC9DUo4DdmIb8/FoU1miQUyXFaT8Ajr7bF2JREF0euKxy0Mc+AygKRJ0B\nos4ECmaAyDWC9RVwmOHragHJLAcxG0FxQbDqLChsRkhah9OOiCodJK0EXP6MuK22ZIEQApqmBR3d\n8AaYYiJua2sTrC2tVgudTocr12sg2bwf3X1nQNrxDZz7jNBP6wc3bwWCMy8HKAoeux10f3/IuOY2\nDtb2AM78mQ7U576oqW+j4dOXSlG2x4LS+m0gqjS4rIMgDR2gqwvBZdckpBIvEuIl99G6efBvIfzx\n9ng82L9/P5qamqBUKjFnzhwUFBRMysPl73//u6DYt3r1alRVjV09GAmbNm2yrFq1asuUJV0e0Sxd\nlmXR2dmJnp6eUTtHIIGWbjTStVqtaG1thVwux4wZMwQx5sBtX4PqOwjK3gOuZimaP3gejR33wvhE\nDjwUwbSsJvRa62BxlmBAfjaGJGdiyKSEzr4D+ctKcWB7LuZdRSHomoXazA+QvtADRncGsisk0Jdq\nkfaTm+DTpsPJenBwwxaov9qBaWjDtKz9gHoGuOAV4Kz1QHrJyEmnFYKb/9Mx95spPxOBgUGAcGBL\n5oGSKeE9HkTJLCuL65ierJBIJEhLSwtRcOO7S/BkbDKZUOpvR/bA/XDXLAZTuBxHe9JAtypBGxik\nFdGQZI5sSmluY5FdYIds/2cILLphQvObVtaD+b87Ax2b21BT3wsXWwhLsAxDTT7QjmaAZZGe50d2\noRdElw0upwaQxf96PlkWtVQqDTnehBDs2rULVVVVsNvtOHLkCD7++GNs2LABOTk5uP322xM29uHD\nh2EymfDII4+gu7sbzz77LB555JF4Ntl5SpCuWLQ4nGxjaSOeqO4R4cRtt9vR2toKmqajatqSghkg\nWeWgD2+GV5WLwcs+husIg95DDHYYWVQsliG7yI+znM/j83VvQRHQIOuzR7D/1ZXQSnzIzrNjMOtK\nsHNmQmN4EVnL5Tj0oR+MJAODTQa0DmTAF3RjziULkF98AShqWACc6mmCpOkNSL7+X1C2TszyWBE4\nbQHItPnj23FVOoYKzkBJdiUQCABJasE+2eIq481eEHeXEKzimX8dbtRoagPTsxNy1gOf3w+fRIN2\n40y4v9aA4ygQkxulc1RQaGh88/cAfv0/vaCPtoHLvnHC81dn0Ki7qgot/8qHbOBdFC9VQj6/GkDO\ncPPOHoJj7RzQYQdtb4FS6UV+uQcyBQdOnQEut27YxTQOJMuNweflqtVqnHXWWcjIyEBDQwP0en1c\n8qiRcODAAcyfP3xPFBcXw+12w+PxTKgf26pVq6oBXDhlSTfcvSDu9hsr2SYSYveC0+lEa2srOI5D\nVVXVqJq2fheHngMyuM3L0f75XnAHD0M/qxpzf6SEKo3GkX8FoC/TAXlr4dtuB929BwcXHwTr55Bd\n5kW66yOYP2xGxku3gM6sB731GdQUVaNXToExbsWMS36G3KKZI1OiihrBFMwA1bUHlNcGY9N2TCue\nPe79jqRQdiK7AScKvHshXkilUmiLa4Hi2u++dA2C6dwHq2IQbrcbjDcdW16vBscqkVmbBebgBwhM\nmw96giRGZGpQjj5AX4Ca5Tp8+dYcyN46ivzZA5DIOUhlHNKkQGY+Ebw9XpcE3S06MAEalN8Jqe0V\nFCh2Qx88AC67Gt4fvzDmuMn0HUeTdUx0wNBms6GiokL4rNfrYbPZxk26q1atehDANQB+NWVJl4dE\nIoHFYsHg4CAKCgqSTrY8+JbdTU1NCAQCqKqqiqhpyzEEpiMMXAMcrF0cmABBZqkEGSUS5F1GMG9O\nEei2D8FpzgYUWZhxth3GfxrhkjOg+jg4LRJ4jxxESa0TmVJqWL81pwquFa/goBkogAVDPf2ov2kh\npjV9DFZNhfpRCQHV3zycSUBJwJXMAVFnotuixbQoXRRGA1+cwkf8+XSrRFscpxS0OZDWLwMGB0Fc\nLlTlZ6LWdBBcYBDeOS1I++Qj7K7/OVx7946I6I9VigsARJ0FSW8TGP2wzrSu1AufvQyetEowrAys\n0wnOYQXncADgwLE0PA4p3EMsfP0ueN1KmEwrYB1aBQC4/EEnYkmmPBlIN9EINx4mqtS2adOm+wHc\nj6leBtzR0YGOjg5IJBIhvzQeTPSAejwetLW1wel0orq6OiRBHwBsPSz6jzBgg8OJAD1NQex7c2R6\nGS2vRvdpNIrLG5GO7ZAqAUlRDShVIWzGAXS2aREM0jj3/FJklADUwXdBMqaBUBZ0s+mwWtuRXV2D\nmVk60DoalFQGZB6/XWxdoE2HAVDg8qeD1K0YMf5E4HQ64XA4YDKZkJmZCbfbDYvFAo/HA7vdHqIc\nNlqDxpMNyeigK6RyqdLAli8GMFy05mq8GHXHx+bVwiKV4o7Q0KUgZIjQXzwHl1UHj0MG/9EB2IxF\n0JItINpcELkGRKkDJ+FgMwbhtMqg1jFQ5SqRMbcK2sAR6D7eD1vlLJx5ZyHSCmKrFjwRpEsImdSK\ntMzMTNhsNuGz1WoNKQqZCKY06UokEsydOxfNzc1xH3Q+EDae7Yg1bauqquBwOEYQrs/B4bkf2kas\nm1sjwf9n782DJDurM+/fzX3P2vd9r+pVvbckQCAkhCXjASTDCOPPw2YzM3Z4gY8xobCNPWPwzGds\nYwMeGybGYRsENotlIQmEFiTULXWru6XurjWz9n3Nfc+89/uj6r26lbVXZVV1t/REdEhRUXWXzHuf\n97znPOc5eVU63BV6XAVJFN8YY94gcqKU157OI7JwR9ZfLJKnxRLjnz8ZwuUKUlx3GHdTnKkJA4eH\nh7HbHNTV1QF1SJ7nkPyj6Hp/CkoGxV2F3HrvuuqBrRBNJBLB4/GQSqWwWq0cOnSIZDJJSUkJeXl5\nzM3NUVdXt8LnVVGUTds43upY8/PW/EzrFlZSUqL+PJVKMXZljrkXe5lIJEmmUosqPmsefZc7aCq+\nF4P7GO4WE3r3ZYpcRVh6/o547d1IBguyuwJDYRVNv1yIu0KHpJPQzfXT8/XvcnnybRz/L0cpP7A1\nAt0P0t1tL90jR47w3e9+l3vuuYfBwUHy8/N3PIPtpiVdSZKorq4mk8nk1Mh8M6SbSCQYHBxc4Wnr\n8XhW/K7FpeNzrxaSCMsMX0yBJFFxQM/Ez0cZfiVOoMfAVMyMo6KaWHKMysooJ+6ZxVxRTkxfQSYh\nI028xstPVuMbSXP/L/6ETFEL8349oxNW5q6WMXnRQqVznNG4ke5YAqNJAu6g6rAVS/Pawxe1EHnY\njUg3kUjQ399PMBhUZ7BdunRpxbFYw+dVmKiEQqFlHUqiNVeQ8aabEHYJexrpbgNGo5H6U+Vw6o1R\nVULnOno1RdofYOqZ5xnKZEinUsQWAvh97yb/rntpPpbGEbgCyjwZWxNKooCJv/82l6/eQdtHf4UH\n3rF9zetefGd72Y3W2tpKQ0MDjzzyCJIk8fGPf3zHx7xpSVcgF8oDtmBkLsa8Z3vabgSzOUFr7WXk\nWJSh51wopkrO/JdyXJGXwT/OSJeT4WmJ2gNFjPcU4r+QBIZYNCUoYKzLQnvbVRryf8pAXoT8lg4O\nHz3O2Ct6yv/EgGP2CokxB81vN2EwiWs6s+n73+hzFFaXMzMz1NfXqwuNLMtbKqStZqKibc0NhUJq\nE4IQxQsiFumJvXix94J0c30OoXN9z+dkZs7/Mmc7+pDb3sNrP/8p5hEnL/3fen4h8y3O/egYiXQF\nhXUKNU//ExfPvZPqMye5/29qkSw3fpPBXpvdfOQjH8np8W5q0s1llXw90tXaPdbW1nLmzJktRSim\n/9GKtGTpojhKaK49BbP9TPyFnpl4MQXOMZpcHuplPZ7n3k25w8Udx2aR3KWLDQkmO93n7kefmiMo\nGyk98V5sla0Mv5qioE6Ho0iHbh6MdllDuFuDINDsqEGWZcbGxhgdHVWbS7T3rv0OtM5vW/le1mrN\nTafTq6YnLBYLsVhMLdztVnpiLyLd3YjS8qp0ON5Xz/WfltE4/h3Kg30Mj32A8pJRSBzgnndLxF76\nV574xj2Mln6Cil9OQuUs3p99HzMpjK5iqD2Jw+nCbrffcEMtb2YvXW520s0lViNdofmdmJjYlN3j\nWjaTyc/3IE1eQ5r1Ik11IikyVBykoiCIFPUzFz7G9eBDRGxGmu53Y4pG6XpFwj0zSEXeBZIhHwbp\nXVhkH3kTV9A/+hEmF5qwKxLlBZ7FKbvxIK3lb0dnHQV7sTp2V256x6buP1v6pSgK09PTDAwMUFxc\nvGahcjViytViaDAYVrhZybJMKBSiu7t7V9MTeyF5y5UsbTUYzBKH2i8x+n+vEzVYkBMhxmabqL74\nLOe/cwRr1X/iF/9GwrxwjWjUysjCcbAcIf+gTCY+jjL0IuFYjCFjCXFryYZ5+P0aSnkzmN1k46Ym\nXfFSiakLO/nwtaQry7Kq+a2oqNi03aPQ6q54kSQJpeLwouFMy7vQDV8AFOSqY+AoJm/WS/7E6wx1\njzP8kxRWU4am+gGmp2Re7rmD2pbFXHDVPS0MZD6P8/4PE5qSqTtlJAmQSaK7/Ch9iToKb3v7tu5f\nm15YWFjA4/HgcDg4fvw4ZrN5w7/Pxm69hGILbTKZVIMe4acrpkxkpycEGW9FPXGj53TXRSaFoecp\nMjWnsLqf5Kc/f5DCCjM6JUX3tVbe/ycBosEYg09bcBXmUV4fpD35KDJGBi+cImGspqDxIcrr9VRO\n94B/hERqnnla1hyntJveudnIJt2bxHdBxU1NugJGo3Gx82eHpJtKpVRP2bKysi3L0IQCYt2HwJqH\n3Hbvol527DLS2GUUWwHy4fdD6lmqqqeZpYonrp+gpLSMg/+xiOBwmEzGR7nhJV58+W00t6VpeecS\nEcoZdNf/Hfm2D6NceHXb9y9JEqFQiM7OTnQ63bJ25e0cay8jH62f7lrpiYmJCcLhsKqe0JLxfqkn\nckXs0sIQuoWhxf9PhNBNdZKpOs7EP/07yVQFqaiZygNxIvMmau2v4wiEsNsKKDxVT2DORN/FAmwW\nI9U1IzRL30LyTzP74zKGfOVYpSnq3OexpYMUxINkiluJ/tr3YKmoqrXIjEQiXLx4cYVxfK4/35vQ\nwHwZbq6rzYK2K01sMbcDRVEIhULMzMxQVVXFqVOntrV6bslTV5JQqo8vZnrDcyhdPyY9Nch1cw3N\nZSbed+cYSrGd4f4CBs8ZOHaqE3/+vUCM5rtM4sLRXX8Muf0+1cRkOy9yPB4nGAzi9Xppb2/flg5R\nypI53QgdaWulJ2KxGKFQCJ/Px8jIiBq1abfPsrzSFyHXyBXpzgeriQSqMETGMManUBo+w9hrGcpK\nztPfn4/D5sfuNqJLRbnk/UWcXUM4dONIoS4Uiwu9q5yg382LnlPY3bdRfzSAo9lPQWyCxKyd3s5f\nRDFaqXhvB8aDbxRntcbxsVgMr9fLgQMHVHOa7PSPIGOn04nVat12lH+zjerJxs11tWtgs/aO2dDm\nLS0WCxUVFcs8ZbeK7YzskWWZsYUoo34X1vJTtMqTlBhjKM5KJCVFve1p6h5uxfCDvyX17m/SYP0a\n6fRJMFrRdT+B3HQXmBYj0s3KvgRSqRQDAwPMz89jtVppa2tb4Xu6HdwopLsatE5WAtnpidnZWfx+\nP7Ozs8zPzy+L2nKZP8xJeiEVozD5CvmhftKyhYS7jr4n+ihvijD3aoBwqIx0Gs59vwxdeBadlCEx\nOctCopSC1makiI/M0DypTBySEcYG8njtyUpi4TrgCJJ+8foURUf0e3bcFWE+9q+OFZch0ns6nQ6n\n07nMZ0Q7TikUCjE3N0csFlt3nNJ6yI50t7sj2y/cEqS7VZcwRVGYnZ2lv78ft9vNsWPHiEQizM7O\n7tl1KIrC5OQkg4ODlJaWcvr0aSYnJ4kqJcg1NRCcQjfxOuiNEPVDIoqUjJA5/EF0r38PnGXIVcfB\n9oYGVhTDNnqRtQXC2tpaWlpa6OzszBlR3myGN6ulJ/r7+3E6nZjNZkKhEJOTk4TD4WVtuSIy3skO\na6eRbjxmYepVM1KyhqSxmOlBO03HfdgLDQSKCjj5gJ0XvxQkI8uEU0VUVE0wmno39vwUI9dnMVps\nVB2vo1S5Qt7UP2Csy6DPzydddZLh3mKGrphJTs2i18m0vmuYqs9/dtXrWC/izPU4JW0B8q2c7h5D\nK8LfTKSrKArz8/P09/djt9s5evSo2l2SSCT2xFNXS/j5+fmcPHlSzXktmz7hKkN2lYGcRhp6BfnI\n+yEVQ/KPYnjpb0l+9J/BVbbi/Ot5HiiKwsTEBENDQ6pPhYjcVjOu2S5u5Eh3s1AUZYWlIKukJ0ZH\nR0kujYHXEvFmCkvbjXQl3zC6hUEA7Aq0NPYTDNkZGi/l1PsmScX1pIJR/IMp9KlX8M2d5m3Nf8dz\ns5/mWP1jkH+ZhUARYZ0bV2aAscdKGDPakKv/DNIp/C9ESERAr1eobg1gfNd7cVUYKbxrbXLbTk1l\nO+OUnE4n6XRaHfmzV+qFrq4uvvzlL/PpT3+a48eP7+hYNzXpCmwmwvT5fHg8HiwWy6pFot321EWj\nCsgmfIFVSVNnQGm4g0zDYluwUtZBsv4OsK50LhMqjmxop1VkE732b98i3Y2xWnoCTVEpFAotI4ps\n9YQ2GtxupOuLVjM/Wam5ptt56e99HPpQPsPzEjqDhLkQHO0eiu47gvKkQm35dUp8M6SrTmKITFCo\nu06hS2E6cRvmAhNzY1ZCY5PYzD5aSs5jywsSPPqfWZiv4fo/poAEP//bJJ9+cmVqgRxKtzYzTimd\nTnP16lW+973vYbFY6OjooL29nfr6+mXm57nC1NQUjz/+OG1tbTk53k1NutpId61ROYFAAI/Hg16v\np729fVVPW3I4PWK1YwSDQTweDzqdjgMHDqwYaS2wFmmuwCqEyxrEGQgE6Ovrw2w2r0r0AkJjnAvc\nCqS7VUJca/ssIjbtqHKRnojFYqTT6S2fK69SR17lGxFyJq0Qedc0xQeKiPkUMmkITSuMeQvp+sMM\n6ZiO//PTr5FfuMDIFR2WlndjbCli/ryHdCSNyRCj5cAQjrw0ChIjc/cxnc5HmSnAmg+fetyOvWDj\nlNVuRpwiKnY4HExMTHD8+HFuu+02zp8/j9VqZWxsjKGhIT784Q/n/Nz5+fl85jOf4etf/3pOjndT\nk66AkIxpEQqF8Hg8KIpCS0vLhgWi1Y6xVej1+mVpDmEKk06nVZ+Cjf5+q4U4LbSkG41G6evrI51O\n09rauuH956qdmjcp6a6GtSZMRKNRdbrE4OAgXq8Xo9Gopia2Ut0Pz8rMvLZAfHIe2/zLlBak0BsW\nP3vrZIbOCQutZVPEHB3k1ZoJ9LiYejGMLIexmFNEYnmEYzV09d2GokgoMuq/e3+tj8P3hMnknd3w\nOvbS7EabEnM6nRw9enRXi2nbzdmvhVuCdIVkDCAcDuP1ekmlUjQ3N29a/pSL7bXBYCAejxOPx9e1\nelwLmyVdRVE4980YzhIdB3/BjM6wSA6poJF4PMHo6KhqSLPZc+/k/hVFob+/n8nJSSwWCzabjWQy\nSTwe39D79UbGbly3qNjb7XZmZmZobGzEZrMty2POz88TjUaRJGnd9ASAo1iH454i0gvlJPLKmffb\nyaRBtzCEt8/IxLhCLNZKRfkoAz/Xc+bENSzWBN6pM4RSFRRWZGgvHaGt/gKvXzlCNOEmLdmQDHry\nmx3IxVUYPM+gGK1k6m4H3erEulcFrXQ6vew8udbpPvPMMzz77LPLfvbQQw9x9OjRnJ3jpiZdbXoh\nHo9z7do1otEoTU1NmyabXEJRFGZmZpienqaxsZGOjo4tvbibIV05o9D5ZILGO0xk0go9zyQpatAj\n6TNce9TMSOsoldXl3HZvG2bb5os02yFdUZiLRCLo9XpOnjypan6np6fp7e0lkUisiOJ22r20V4Y3\ne3EOEc2uV90PhUJMTU0RDofJZDJYrdZln6fJZEJfWk2J+TWKztyBfuAFYhWlXHyylI62H+M2jTE4\ndTsJm8QrfR8ERaGwMkYqosc/Y2FyqJ6eqzXUd8xRUztNoWOMQvcI8f44gz8xUebqocjiQUrHSR77\nCIm7V04o3o9IV1GUnOt07777bu6+++6cHW813NSky5Kwv7+/H7/fz5EjRygqKtrzyEoY4oyPj2Ox\nWDh58uS2rmEj9UEqrtD94wTt7zGjH3+V0aev0f7Re7jwokTfC1Hail6k4/YSbO3tDF9Jk44rFDUa\nKKzb+GXYakpgfn6evr4+8vPzsdvtVFdXq1GI2+3GbDZz6NAhdDrdMg3s3Nwc0Wh0Ry267AEp3ggu\nY2tV94V6QmtqHg84MATHKfd8icz4ApMLh6h2VXL1+t2UN01jay2irj7C5MhiPUFvcnL0biMmu0TM\nr5CMKYRnCpicaqL7usz8gEwqkoZ0nGhkcev+if9xAec77lr1WveSdEWkK56Bt7wX9hher5fi4mJC\nodCyMdnbxVZeNq1HQ2VlJUeOHGF4eHjbL+t6kW48KOP5WZKD95vRj7yE4ijGb2vA99wLyANFPPyh\nED95tJURXy2HJ16huTCBYstnJn6E3mfSmOwStSeMaioiG5uNdMPhML29vej1eo4cOYLFYqGzs5NX\nXnkFu92OLMsEg0FqaxdN14UXhchtCsPptRzEhCxIkPHN1m20FWxHMqY1NddW6kPzCfzffYlZiwuv\n5f1Y3xFk+mf52OqjREMSUsaH+/4aDn107fykFJzEdOmfoNHPcG0t171nyeTXg05PaZse6x3vAt3q\nz89eteNqI929Oufly5d57LHHGB8fZ2BggCeffJJHHnlk28e76Z/ow4cPI8syAwMDOz6WIL2NvsjV\nGhsMBgPRaHTHhbDV/j44nWHstTQHHzCj73sGv7mE7iE/mVAMc/77uP2BV5ASOipLvZjzarnmOUP9\nWSM2k5/S0RcorcwQN1bT+WQDJptE5REjjiLdps4tkEgk8Hq9hMNhWlpacLvdKIqCLMu0t7czOzuL\n1+vFYrGQn5/P5OQk4+Pj2Gw2XC6X2nmkPY/oXKqoqFDPI7bTs7OzDAwMrLqd3ovc4Y0Q6W4FzkIz\nzw7+CoEJmbJ2HfFBqG6WUI5NkOkape7QBGMEmbqw+Hk6HA5cZoli779jCE/j7W2mb/AQcuGnUPQm\nak4YeNevG9ZcpLOxH1Mj9uqcx44d49ixYzk73k1PurnERtMj1mtsYBM63Y2wWqQ7P5TBN5qh414T\nySvfpzPuJmXN0N7WwYV/G+PMA9egoAG5sIHExZeo8z+G6+Dt9F8/wOgVMxWHllzHInOUGi9SUh7l\n3KOHeemfTPyHLzkxWqHutEmNPrORyWQYGhpienpanZIhyJalyNfj8WAymbjtttuWSdIURVFJVPgc\nJJPJZSSa3fopxpiXlS02fkiStGw7PTY2tridXkor7dakiZvRZazp7QZa7zFgMC9edyKi8OrjFspd\nEcpbjlJa2o7h9X9BHrjO9WutdI80Erb+AimdiZIjMWp/QcLpiuJ06rHZzOjWiGpXw16PX+cmNbvh\nViDd7PbAnbwo62l1N2psYKuGN6sg+9qnutMkIgpVJ9JMPPV3TDraaDh4nLy8PDp/lKS6YRa9pKAU\nNhAPyQz11DDyWgFWdwG6mJfBnmLe8V+LmB/K8Pp3jHhnysBgoq7sMgeadLTU5SElwsipt63Q6Wq7\n1yorKzl9+vSy30kmk/T39xONRteUw2mr7+Xl5epx4/G4OtByYmKCeDy+wnDGYrGov28ymSgqKlLz\n9YqicOnSJdxu97JJE2JYo3bSxI1mwK1Fron9wAPLdwAmG0xdMXDyzBWufzPJ5FQEOf8uJOcHaLnP\nwHuPvzGFQ3gjhMNhhoeHVfWE1qTG4XCsSXJ7RbqpVEp9Nm5GsxtuBdIV2GxqYD2sRrrBYJC+vj4M\nBsO6jQ3kuKtr9HIKRZch6ehn4onHcZ75EMcqapEkie6fJFjomuX8dw/QcimIuSyM2SFRelhPY+nr\nFFQ0c/lfklgTfh77xCjldSHuPOPFppsDvQmlrIOJV+fJFN2BzuFace093znH9NgM+R3FnHjncYwm\nkxrdyrLM8PAwMzMzNDQ0UFxcvCXikCRJjWa1gxaTySTBYFA1RBHFtmztqhj3rtfryc/PJy8vT80T\np1IptStsZGRkGXGIVMZmTWv2ItJll5UYkiQRntbz9LXf5vgHnXR0rH3fJpOJgoICCgoK1J9pu8Bm\nZmbo7+9X0z3aIqjZbH4r0t0Cbr4rXgPCfyFXpLvVxgZy+AJ5f54gokwTVby0L3ixvPu3+OHvpxi+\nsKD+TnWbzG/9NJ+JJ/vRuWXGfj7NuW+3ctV2ioO3z3PsrkkqytPII9dpvq8J3PVkyu5X/RoslT8h\nFpawL60hOp2OeDzOpUuX8F+Z4/R/eyexvllGv38VealKHA6HiVhjVJxp49SpUzmNIrXRrEA6nSYU\nChEKhVTtsdD+VlRUEA6H1bEtmUwGSZJwuVw4nU6ViLWyq2zTGi0RrzYJYS9yuruNM/9tjrKyMtzu\nrRPieuoJsbhNTk4Sj8dVa0etLHA3dhnad/ytSHefoPXUzYV3QjQa5fr160QikT3X+8qyzNSrVnyO\nLrr/vopM6ggvcASIcvbjVs5+zILdFqE48gQXnqrkK++2A40AFNdY+PDv/Ji8vkeZdT7E/EIdRe+s\n4LW/tdN48v4V57JVFxPv7sRedoZEIsHw8DDhcJijR49yMRDE4rBjOWYn/1gdPp8Pr9eL21lGVcpC\n8PICQxeXFgBFwVHjouC2Wgy2HHfuGAzk5+djs9kIhUKYzWYOHDgASx2H09PThEIhlURXK9gJRYTN\nZlNTHCx17IlGrIIPngAAIABJREFUhKGhIdLpNBaLRSUN8bc3O3KdN15rJPyFCxcoLCwkHA4zMjKi\ntuVr1SibtW5cD9mR7s3mMMatQLoC2/XUFUgmk8zPzxOLxWhra+PAgQN7qvedm5vj0Y8liUzUAPDu\njwxy5NPHMFh0EPVx/ksXePQ3Di399n1Ulg7ye7/3P7GYokhTXUi+UTxdDzBpOE37+6pIlBxl+HUz\nE+N+QjMZnCV6EmEZk01C0klY62uI9P0IX3URMzMzlJSUqAUueamWJ1qJ9Xo9Bw8eVKPKwsN16nUr\nsszYk9d5+QsvU3GbAxSFme4IZ/54c7PZ1oOwoBRFPG0qI9v5S4x1146TWbVgJ6eRklGsqSg2KUK5\nPY4kz5NpeTfxeFyN4EKhENeuXcNsNue0sUOLvXi+dm0kUBYkSVo1PSG+F611o8ViWZG/34oHtDbS\n3a+pHzvBTU+6O410tZN+3W43xcXFO3Yq2srWVBjSmEwmPvZoM32v/JRDLoVwzxCT/+9fkZEXV/Jw\n8pc5fftl9FIUi/91HOZ5Rl+KoFQfQ1d0L/a7anElewgbq7nuOUzlfCetpT767RmCE0kmrunofCpB\n8ztMmB0SQ54kUo+V+rNGTp8+TSwW49KlS1y5dJlkOsmVK1dIpVK0tLSQn5+/6rXHpv2MPNFLXmMe\nZ/7gNKOPd5JOykx7d/YiiM6+wcFBysrKVk9lZJIYrnwXxV2JHnAv/UO3+D8KCslkgOjCILHxGLOx\nKKlkCr3RhMVVgNmZj8VdhMmWj/OHv0Ww5jRGo00ljnA4THNzM3q9PueNHXuJVWf25Rhr7QhETj7b\n0Fy7uIn0xGaLoNpI9630wj5jq5GuaGwYHR1VJ/3Ozs4SCoV2dB2bLehFo1E8Hg+pVOoNQxpF5vS5\nzwBgqTtL3m//Bkp+NTjLaHj9XzE+9Udkas8Sbvowfp+bSNCMYnaRMrjxT9tZmKokOjZAeVkP182t\npFMG/DEv8dcvYLKYKC+yMf3YEIZmhYpiPSlHCPuED++EDcXkoFg+wVxfD5I1ikQhRqORnp4eTCYz\nbvdirtTlcmFEYvgH1zFYDVTd3cDE84NEJjqpfqADo8PK8PkXtv35hUIh+vr6sFqt3HbbbWubjegM\njF2VSVZUknbWq9E5i5OQFiHL4B9Dya9BsoHOBslUCv9CjNh4jFg8hnX6VVKBz5D52gCtD5dit9uZ\nn58nHo+rkxBu5saO3Rrznn2OzQYZ2kKqtplJFEHD4TCjo6NrpifQBFo3o4E5b0bS1UqhysrKOHPm\njPpy5NJTd60XTkit/H4/zc3NywpHSDrOv/dROjo6sJjNkAghBSdh+GVwlpJ6aNFazgbYCmIgh1GU\nWdDpkZCINsWZmpylwFaPv+dHRDIO9K2ltBY8wZXAf8RpeZ6QsYbigmJGvI0cqPs3yu6sQTc/gH+8\nn5mZGWzTBeAoxdGrg/xKfNdtKEUy7nt9BIIhhn54mYQ/ibncgjQC0VSE6vcfxu5w7Gi7nEgk6O/v\nJxaL0dLSsqYFp/azGl44QVGxgcbSl6HpbSt+JZ1U8D0/TfHbGzU/NS59gqAbvkDGcYbOxwOMvCar\nFpx6vR6z2czAwMCyPDFLLzpLjR0Oh4OKigpV+bGZxg7tIrIXOeO9SC/kIuI0Go3k5+cv21WJz1Q7\nWSISiXD16lWuXr2KzWZTNd27karJZDJ8/etfZ2Zmhkwmw0c/+tGceOre9KSrTS/EYrE1f09sWfv7\n+yksLFzVyDuXnrrZEZpoMpiamqK+vp62trZVHxS1Y0uSwOJCsbigpJVVX09FgUQYKTSFEpxCkhJI\nUoa8Mpm8slKI+VG83yY8NclYMs27jpooaCjEqfRwsPk1pOAkM3EZ72Qap/sgDbc1MBa5RqHDSNJU\nxuCLMcr4Mf0v5NFS4SIzaiLPVICuQoerNQ99Qz6hUIj+gQGi0SgGgwGXy6VGgqtVsHU9z4BBh+Is\nR8mvRjZYGRkZUT+XkpKSTb9AJTVR3EdaGei20Zz8EZn294L0xvkMJongnInVmsOlwDgoMr2XSqi9\nW2bg54NkMgWcPXsWi8WieuGKgp3X60WW5VUjL0HEWhJgjcYOMWVCTECIRqM5b+zQYq9Idzeiae28\ntfLychRF4eLFizQ1NbGwsEB3dzff//738fl8NDc386lPfSqn53/hhRewWCz88R//MaOjo3zta1/j\ni1/84o6Pe9OTrsB6ke78/Dxerxe73c6xY8dUcXU2ckW62q4yWZYZHx9nZGSEyspKzp49u+5LsCVP\nXUkCixPF4oTiZjLRKAuZXmpbbiOdTjM0NMRMeTmVB+roGE9iar+b4vx6Br5lgHceWvQbHh6mo6MD\nu92+uDANW+l5yUJFdT91eecxVVaTGaii90cjlJ4oo+LuRmwVbxRLtJF6KpUiFAoxoIypUYn2xXG5\nXLz0V26afrEWSUoTnblGYG6GkiodJzpsmINdEOxCdpag5NeCeW1NNACKREGNHr2xhK6rb6c99W/I\nHfeBUdO4otdDJgl6zQKbSaEbvcRg8j3EbWN0jc1g1ikcOnRI82crvXC1BTuhelizYKdp7CgsLFS3\n0pIkqZrkyclJNbrfrcYOrZPZbmGvNLoiVWKz2bjrrrsoKChQvXR3UkRfC29729u4447FiS0ul4tw\nOJyT4970pLteIU1MjTAYDKuO6MnGTtt4tcfQRtZFRUWbHuu+EyNz8bdjY2MMDw9TVVXF6dOn8f4s\nRXPp82QK3k0mnWY6pif+8lNUH118cBVFYfhCis4fJTHMBSk0DXP3/xPj6vMn6Tmnx50fYmq8kPIz\nElMvDGIrm6bwRB1Gx/KuPKPRSEFBAUajkYMHDiAt5T+FGmCofxhz1Sxz/f2kjpRjabfQWncWYyqP\n0VHI+ABFRooFmHvhHC33OsgvjaM3ACx+z4qjCDm/BixvkKG7XIfBZKfzwns5oP8pSu0pFOeinEnJ\nr0Ga7EapOqL+vq7nJ3gyt9F7tZeDd+dTXnaSn/3jzzf8fLXjd7I77ERjh7bDTkw6EPaL4veF/lVI\n4LIbO0ROc7uNHXuN/fBdICutsRu5Xe25fvSjH6kEvOPj5uQo+wxJkpZFusLIPJ1Ob2pqhECuIl2/\n309fX9+GkfVaf7/drjafz4fP58PpdHLy5EkMBsNiJ1lGBklRJwAXHqmnNBQmv6CAoZdTXH88SXXt\nCPe3/2++8jef4cjpBE//nYNDD+Zx9DOL5Pnkf75C4z0ulKJGIiOzTPy0l0w8s5jiACyFVopO1WLK\nc6AzQiaewmAzq1rb/Px8Mr1DmG43MXfZSlNjIxlZZm5ullBoAAUFR8EiQSX7krS+vwSl9BADo/Ib\nRTJFQZcOUmR8nZJXfhtq/l69d3uhjvo7TVx94V4OGs8hFfhRilso6shjvq+XgqrF34v3vohnVmLK\nm+buX23DZDKRiisY9Ntb6LSFIa3qJZFIqIvNzMwMsVhMreaLAam1tbWqJ6wkSSq5rtbYofXT3aix\nY6+xX6Sby4609czLn3rqKQYHB/nc5z6Xk3PdEqTL0kqXTCbVxobm5uZlmsHNYNMzytZAOBxmenoa\ng8HAoUOH1m0ZXgvbiXRDoRC9vb0YDAbsdjvNzc1q265/XEZKXue1yTiuOplTp05x9QdpHv37g8T/\n0E/7HSHuP/qXGFuOkTr65yT+IoTRCq2nbCQDSYb+5QoAiimPa//rp9hu88NSZkOS3pAK+PqD9D15\niVRMYnywQCVjNEqRkdev0fYrJzAkdFTI01B9eNnvRCIRAoEgC9e68N1ZiDxxEZvTpnaZuVwuDMNe\nvBfd/OOPHucXPj257HOwOHW03m3k2k/OcuBQF4bYRdzVJxh80YQzlWLk+gWUaS+p+H/grl82YEr4\nIBRFmfVhkINb/q7WQ/ZId5Zaynt6elAUBafTycTEBBMTE4uOX6sU7LIbO0TBTuSJ12rs0Gpf96JY\ntx+kKwKTXKVO1jIvf/bZZ7l06RKf/exnc0bwtwTpplIpvF4vwWBwW34AAtstZsTjcbxeL5FIhKKi\nIvXB3w62QrrxeByPx0MsFqO1tRWHw8ELL7yAx+PB6XQiSRKvPjnHkbrXqbn9I/gG9PzF7Yuk+q6P\nTHBq7sMEq9/PUNUfkolY4SWZ9/+5ncKGO3GX65Z9HtXvV3juN9u558GDYNhc55mYQtzf309xUSlV\nFWWUlpXjPCMz8bN+Kqrf+F2R+/VfmOXgAy3YWxqXu5SNDxB68Rw9I6ex1ZqoqfWQmJnF9A//E6Xu\nLHLZAdAZ0AMHWyS6nsmnvaUb87UfkhiqYfipl2mIdDJp/08UF3Vj9QwiReZRzHbkVClK69u3/mVt\nEqKIOjc3t0L3vJ2CncViwWw2qx1hkiQt075OTEyoEzsSiQRTU1M5b+zIvr/9snXczQaT6elpnn76\naf7oj/4op7uJW4J0vV6vGiloWxN3G+l0moGBAebm5mhsbOTAgQOMj4/viqdu9nkHBweZnZ2lqalJ\njaZkeTGSFUSXSCRJpwqIR2W+8f4wsXk993xyhDOzH0Kah+hnrmBMhmmc60ZKRpaOAXNdFgYuFKO4\nykBvweyUKG3Tkyo8gPGFr5B612c3vI9wOKw2fRw9epTZbgMlrcMA2PJ0TMRskIotK3opGZnY6Az2\nu8+AxqXMtdDF3ILMjO03eNcnjXT+YILykxf5+cX7eCl5isa2SxToejHqJfQGAwa9Hptk4PFvtlFY\nZyQwWkS7ZZRrpk+x0Gmj7kCQOfddJHXFjJ1Lk4ornHg4ty3MAnNzc3i9XsrLyzl58uSKyCxXBTsh\nuSooKECSJHQ6HYlEgsuXL5NIJNTGDrG45bKxYz9Idy/Mbp555hlCodAyxcIjjzyy4/PeEqTb0dGB\nLMsMDQ3l5HgbdZTJsszIyAjj4+PU1NRw5swZ9WUyGAwkk8ltn3u9SFdRFMbGxhgZGaG6ulq1W1QU\nBUVRSKfTjI6OsrCwQGtrK6kZN8/9wxw/6H6Qt/3qIO8MPQxz8Oyd/xudzonl0jgWoxOT7iBS2kQ6\nvnQikwK2ADrfMFI6Qbhfj/cHVvyDFqSeZ2Ed0hU6ZK3ZOUBkKoi9dJK0Ii/KukpbYPAVaHlj/MvI\nE93U3FP/xsHiQej5Gd0jJ8lrKaKtbfFxnXpxivf+r/to/q8lzA1kuP54EaO+NKlEimQyhb0ugKV5\nEtfRCHJXLfX5I+Q3W4nSyts/ZWX0cppMVMFqlXjn71hV/9lcIhaL0dfXhyRJHD16dEt5/bUKdiKt\noC3YZbcpm81mNU8sot3KyspdbezYq3bcvTYwf/jhh3n44YdzftxbgnRz6akrClmrfaHaiRFlZWXq\nxIjsv99JMS57jDuabbrX61U1xmqRTJZRFIXx8XHGxsaoqamhqakJSZJ4+htRdHEfHzrzZeiDa+99\nHuQUpf4YOjmALA+SUcLElQiyFMViAbvdhtVmw1ZgxWQ2Iz7JA+8IgMlBmj9Z9bplWWZsbIzx8fFV\ndcidP5bwjBdw6I5/RC47QDxo4LVn5zj8oecwOCxknFUkF0JYKhcNbXSjl5jtTTIr30vTe0wqMSqy\ngpSOg2NxR1PUoOeu37Kp1zA8PELvzxNEXjqEQWcilUpx5VwbyYhEy68MMvbPEpVHDRTWLBai9Kbc\nvgLC+nJ6enpL05g3wlpjetYq2CmKQiKRoKGhYVkHF6AS+k4aO7RIp9OqL8duQuSuuYltHblVSFdA\nqA92Ih8Rx8gm3fn5eTweD263e9XGCoGdSL5W+/tgMEhvby9ms5mjR4+qkYwoJIiXpLi4WCVjgXs+\nZ8Pyd79L6m2/iWJ2gnkSxeJCMeeBuXoxN6shxkQiQTAYZG7JYDwWiqlCfpd90eLParWSvaSJaRol\nJSWcOnVq1QXrg3/p5Mq/3sXE61d4x+FnSX7os7z2f/IYnTaTmnYw9O+9VB2UGPinl3CHXmJWPk5x\nm42OlksosRoUYzno9Lz+wyTHjr8G3Lnq91NSUsI9Dx9Ydg2ZlEJ4TsFdnq8OyRQEo/XtFcW67Wpk\nFxYW6Ovro7S0NOfWl2shu2Dn8/no6enB7XZTUlKCz+djdHT0jVTNkoxNyCdFwU4Qura7a73GDu3E\njv3K6b5FuvsI7Sj2VCq1I9LN7igTJuZGo5HDhw9vuKLvVOsrcrqiSBaPx9W2WC3ZhkIhPB4PFotl\n3e1r/FNPbvrcZrOZ4uLiZT3xQsgvxqpHo1GMRiMulwuTycTs7OyG1yBw24NmhqqO84N/qeED05/A\nWfP/UVd+kVTNHUjTEs3vMDN1LYM385sU1hvwAb6BBISmMcz/mEJzH5PPnebErzsRewnhhKbT6da8\nBr1Rwl2++IyIZgVtBCo0ssFgULW4FFt8oZxYTyMbj8fp6+tDURSOHDmy6lSR3UYymcTj8ZBMJled\nbKIt2Gl9hbMLdlrJ4lqNHWLREhM7ksmkOkJpNyd23CqkK20gKbkpDEUzmQzpdJrr169TU1OzaV3u\narh+/TrV1dUYjUa8Xi+JRGJZbnIjCPPzo0ePbuv8c3Nz9PX1AawokqEZECmua0OPgl2AuMdQKITV\nalUXOhEpulyudSvl/rEMP/7vER44+eeEU6VEbIeoavYzMH6Y4roMxXnDSIpCMq5nZsRCNGwmYyvG\nN5dPfp2BlneayGQyDA4OMj8/vy154EbIZDIquQSDQbUbSWy1RUQ8MTHB5OTksu9qLyFSXsPDwzQ0\nNGypjVoU7ERjRygUWlGwy87vCr6QJEkt2F27do2ioiJ18dqtxo7Ozk7q6urUzx2gtbV1R8fcRaz5\nJdycS8UaMBgMO24HlCSJgYEB4vG4+iJtJUe83fSCaBceHBzEZDJx8uTJZTPJtLKjxsbGLV9XLqDN\n29bV1XHkyBH1GlKplBoRa7ftgoRFpVySJPKq9HzgL5384DOfpcpxEd18N/HkCZwl8/hmyvGFz4Kk\nx2iF4tv1lOe/ETUpisL09DQDAwNUVlauqgjIBfR6PXl5eeTl5S27fxERDw0NsbCwoI4N0rY875Xz\nVSQSoaenB7vdzokTJ7Z8Xm3BTiC7YDc+Pk4ikVhRsDMtjXCKxWJEo1Hy8vIwGo272tiRrV7Yjx1F\nLnBLkG52emE7yGQyagGkvLyco0ePbovUttrVJopkHo+HoqIiDh8+rFo+imLZxMQEo6OjVFVV7Vmu\nMBtChiZamrOjFqPRuOq2XUSK2flTl8vFe7/o5F8/eZz2+87iOKinuEWPxbX2vYXDYXp7e7FarRw/\nfnzPO7F0Oh0Wi4WRkREUReHMmTNYLBaVXETbdzqdVqM8seDk8lrFAjw/P09ra+umd2GbwXoFOxER\nz8zMEI1GkWWZVCpFWVnZMgVDdp54rcYOYTa/VmNHNt5KL9xAEF/+8PAwer2eqqqqTf+tqPwPDw9T\nUVGBoiiYzWYqKyu3dS2KonD+/Hluv/32DX9XWyRraWnBZFrcNnu9XgKBAIlEglQqhdPppLa2Vo0m\n9hKRSEQdzNnc3Lwl6dNq0BJxKBQiEoksI2IREWsXllQqxcDAAMFgcEupnlxCyPXGxsZobGxctwFH\nUZQV23bt6Hlxn2azecsLuygYlpeXU11dvS8LcDQapaenB4vFQnFxsaopDofDy9qZRX5XK2sU96v9\nr7axIxwOE4/HMRqNKhGLxo5XX32VEydOIEkSXq+X0tJSKioq9vz+N4k1v9hbgnQVRSGZTKqdOPX1\n9Zv6m9nZWVWG1dDQgNFoZGxsjEwmQ21t7bav59y5c+uSrii8JBIJtZNMPJQsRXTCqKeysnJZlJHJ\nZLDb7cu27bux4muJrrm5edk2O9dIp9Pq/QWDwWVb9Uwmg9/vp76+noqKij1PqbBknNTb20t+fj4N\nDQ3byk1mG+MEg0F1265tc14ryksmk/T19ZFOp2ltbd2XrbXQp09NTdHW1rbqM6Et2Ilc+FoFO/G8\ni/+KBUSn06kj4cWiFYvFiEQilJeX09/fj8lk4vTp07tGuoFAgK9+9aukUinS6TS/+qu/SnNz81YO\n8eYg3ZmZGQKBwIYfjjCksVqtK6K3qakpIpEIjY2N6x5jPaxFutoONq2GU+RtRWNBNBpdcwKxaI0V\n+VNBxNoCz06IWOSWx8bGqK2tpby8fF+IbmFhYWlqhQmTybSsm0rcpxhAuVtIJpN4vV51bt5GLnVb\nhdDSaiP/WEwj01u6R5/Pp0bYe9lxqUUoFKK7u5vCwkLq6+u39LlrdcDZBTtxjw6HY0XBThsN63Q6\nLly4QEtLC88+++xSx2UCSZI4fvw4Dz30UE7v9/HHHycvL48777yTrq4uvv/97/PII49s5RC3diFt\nszldEUHKskx7e/uqlf9cOI1lQxSgRkdHqampUTvJBNkKQf3MzMyG3hFCbynE7Wge6mAwyNTUlHqP\nQvIkiHijCE34DmsbMPYaWnXG4cOHlxV5hKIgGAwyMjKyQtqVKyIWKafR0VHq6+spLS3dlYVHkiQs\nFou6TRcQMr35+Xl6enpgySDd5/ORTqdVdchepBYymQwDAwP4/X46Ojq25SmiXSwFtAW7YDDI2NjY\nqgU7oUufnZ1Vj/O+972P69evq9K4YDC3ZkUADzzwgPr/c3NzOVXH3BKkK2A0GlclzHg8rrambiQv\nyhXpih2ESGEUFxerBSit3lbIfSorK7ddJNM+1CIX/YZrV4DJyUn6+vqQZXlZNCyIWEjAdDodhw8f\n3ret6+joKJOTk2suPKspCrREPDo6qkq7tPe5FbmSyLOLJpj9WHiEPWggEODYsWO4XK5lufBsg3jt\nfeaSiEWzR0VFhZpLzRW2UrBLJpPq9yemU6fTaRRFwWAw5FwuKOD3+/mzP/szYrEYf/AHf5Cz494S\n6QWWooNYLEZnZyfHjx+HLGOYhoaGTUUs4XCY/v5+jhw5su7vrYeXX36Z1tZWvF4vFouF5uZmVWIj\ntk0LCwt4vV7y8vKor6/fkwKZVvIk/iUSCRRFoby8nLKysn0xytZ2k9XW1ubEgEV7n1qNrTYi1p4n\nlUqpC3NbW9u2XeJ2CtHuXVFRQXV19brPq9YgXtyntpC12n1uBqlUCo/HQyKRoK2tbd+kWULVU11d\njdVq5fnnn6erq4toNIrdbqe2tpZPfvKTO15o1vPSBbh8+TJPPPFEztILtxTpptNpLl68yKlTpxgd\nHWVsbIzq6mqqqqo2/cXE4/FlxL1VxGIxzp8/j8PhoK2tDafTqfojoOmg0uv1NDU17UnPeja02+fq\n6mocDseKJgBto8Nu5U61pjDNzc27+nJriVgQFUvTZhVFIRAIUFdXR2Vl5b7ksBOJBL29vSiKQmtr\n67ZVItn3KQpZ2u669XL+QvZWV1e3awMfN0IqlaK3t5dMJkNbWxt6vZ6hoSGCwSDt7e0UFhaSSCQY\nHx+noaFhV66hq6uLmpoadfH9+Mc/zje/+c2tHOLWzumi6ZBJJBK8/PLLlJSUrGpIsxG2m14QRbL5\n+XlsNhsHDhxQ+9LJiqR2Ww2wHhYWFvB4PBQUFCzbPmdv2cWLK7bs2t79nRKxttFjN7rJVsNqForB\nYJCuri4MBgN5eXlMTEwwNja25Vz4TqCVojU1NS3L7W4Ha1lFipy/8OwVjQpaHfHAwAB6vX5fNNAC\ngvTFznRhYYHBwUGKioqWTe42m827RrgAr7zyCoODg9x///2MjIzkzLiIWynSnZqaore3l0gkwp13\n3rmmI9JG2IrOllWKZBUVFXR1dQFQUFCAw+FgZmaGmZkZ6urqdq0osxFEhC1JEi0tLVuOKrW5UxER\na3OKmzGKEXPjRDfZVnYguYRYIAOBAK2trcvaxrUpGBERbyVS3ApCoZBqTtPY2LinaR2tCmZycpJA\nILDMzEarJd4LJJNJNdJva2tDp9MxODhIKBSio6NjTxZmLYLBIF/96leJx+OkUil+7dd+jZaWlq0c\n4tZPL4yOjmK323n99dc3TZhrYSOdLVk63+LiYurq6tQiWSqVwu/3MzExwfz8PHq9HofDgdvtVglq\np00Gm4UgGL/fT1NTU04f3rWIWNyjtsouTM3NZrOa495riBbiwcFBqqurN51K0EaKgoyF9nQ7eulM\nJkN/fz+BQEBNQe0HRBuxw+FQST8Wiy3TEieTSSwWyzIt8XaaOtaDaOvWRrfCOa+5uflm7Ty79Uk3\nnU6TyWQ4f/48p0+f3lEEtRHpCrG8zWajqalpRZHM5/Ph9XpxOp00NDRgMplUYby2gGWxWJYRcS6J\nSJu3FRH4XkTYorijJeJUKoWiKFRVVVFaWqp2Ke0lIpEIvb29WCwW9TvbCbRELO5X2wQgSCq7QCoW\n6qqqKqqqqvZl16OVKLa1ta3b4SeaOrRaYq15urhPq9W65XtJJpP09PQgSRKtra1IksTQ0BDhcJj2\n9vY9j25zjDcP6b766qscPnx4Ry/VuXPnOHv27IqHSBR+UqmU2kmmLZLFYjE8Hg+KotDc3LyumF7b\noRQMBgkEAqRSKTXP5na7t22eIpQR+fn51NfX70ukIDwjRkZGqKqqwmazqS9uthnORq5kO4FwIxPT\nNHazhVjr2qVtXBHSKJ/Ph9FopL29fc+27dkQwzGLioqoq6vbdnCilXaFQqFllp+CjNf6TrU7DpHH\nnp+fZ3BwkJKSEpqbm2/IUfNbxK1PusLe8bXXXtuQ8DbCyy+/zMmTJ9UvXrTELiwsqM5jWrLV5gh3\nsoXX9uyLf9ltvy6Xa80HUiwKAM3NzfuijGBpJ9DX14fL5VLbq7Oh1Z0KIjYYDJu2h9wIIv2jzR/v\nV1TZ39+vDodMpVIrilgul2vXJYMipSEUALnurmMpctVK2LINjkQKRnh5tLS0oCgKQ0NDRCIROjo6\nlg3tvMnx5iHdzs5OKisrd6QOePXVVzl06BBGo1GVntXW1i7rAGPpxR4dHWViYmLXJDZr5RO15GS1\nWhkeHmZhYWHP1ACrQRhpC6/frWpdtfaQ4qUV0ZP2Xjf6jKPRKL29vRiNRpqbm/c9qiwoKKC+vl5d\nLLMXV9Gq7k7DAAAgAElEQVQWK4g4185kQge9H4uP1iB+ZmaGYDCIxWLh+vXr5OXlqdLKjo6OWyG6\n1eLWJ13hNNbb20thYeGODKWvXLlCQUEB4+PjywT7WlOamZkZBgcHKS0tpaamZk8fGFmW1WhiamqK\nYDCouvyLHPFuufevdT3CZ3erRtobQURPWiI2mUzLiFiYxKw36nwvkU6n6e/vJxQKbbrRItuZLBgM\nLiNischuhYhTqZSaDmtra9uz4m02EokE3d3dmEwmmpubSafTvPjii6pF5tTUFEVFRfze7/3evlzf\nLuHNQ7oDAwNYrVZ1iupWEQgEuHz5Mm63m46OjmVFMpaiF4/Hg81mo7Gxcd+iKJ/Ph8fjUTvadDrd\nigKW2NoJIt6NvKnQ/Yoc4V4sPtoRQsFgkFgspmq0hSHLbuWIN4LQmeaieCmIWFvEEhaR2kUnm4i1\nOdNcL4Jbvf7JyUlGRkZUg6e5uTmGhoYoLS2lqalJfV5kWd4X+eAu4tYnXeE0NjIyAkBNTc2W/j4a\njeLxeNTBliJFIT4fMbMsk8nQ3Ny8b22iolgny/KGuevsvGkkEtnWdn2t6xD54+3ofnMFcR2yLFNa\nWqpKnkSFXXuvuZY6aRGPx+np6VFzlbsliRNGMdmyLuHVa7VamZycxGKx0NLSsuf+ywLxeJzu7m61\nDV6WZQYHB4nFYnR0dOxbc9Ae4s1DupOTk8RisU13q2iLZGI1Hh4eZmJigoKCAux2O4FAgGAwSFNT\nU047U7aCdDqtTgvYyXWsFiVmk9N621CxhZ+dnc3piPGtYjOjzrVSJ0HE2ZrTnW65tUY9+/V5CCIe\nHBxkbm5OdeYS9yrudy/SC9pJJyLFMz8/v2p0e4vjzUO6c3Nz6hiT9SBelrWKZPF4nKGhIaanpzGZ\nTEiSpG7rxHZ9L6II7eDBqqoqKisrc74N24yG2Gg0qmqA/ZxaQNao89ra2k1fh/CvXe1esyPizUDo\ntQsLC/cstbIawuEwPT09uFwutclhLdN0i8WyrAiby+g/FovR3d2t6tfFAv0mim61uPVJl6WEvd/v\nZ3x8nAMHDqz6O6IVtb+/n5KSElWrqM3bCnIpLi6mtrZWnVUmtnVCV6uVcwldbS5fPGG27na715Re\n7QayNcQ+n49wOIzRaKS8vJyCgoI9HcAooB11nquUxlrktF7eVPhoRCKRXTE33yxkWVYLh21tbRtO\nwV5r0dHudEREvBUiFo04Y2NjtLa2kpeXx9zcHMPDw5SVle15i/NaePHFF3nsscfQ6XR86EMf4tix\nY7t5ujcH6YoRH2uNQBckZrPZaG5uxmg0LiPbUCiEx+PBYrHQ2Ni44XYsW84lzJRFJOF2u7elIojF\nYni9XtLpNC0tLfv2UmtbiEV+cLsa4p1Au4Xfi1Hn2YuONm+q0+kIBALU1tZuaL24m/D7/fT29qrq\nme3uOrRELBYdbT58ozFCsViMrq4uHA4HTU1Nqp1qPB7nwIED+zLPbjWEQiEeeeQRvvSlLxGPx/nu\nd7/Lr//6r+/mKd88pJtIJLh69SonTpxQfy7MXjKZjKof1TY3aKcVtLS07KgXfjU/gs12X2nzpXtB\nLmtBm9JYrwq/GQ2x0+ncURrC5/PR19e3p+qI1RCNRlUjI7vdrppra7W1e5FySqfTeL1eIpEI7e3t\nu9YAs1o+XCvVczqdzM3NMTExobYSi+i2vLycxsbGG0qNcO7cObq6uvjEJz6xV6d8c5CuGCL3yiuv\ncPbsWXUb6PP51CKHlmy1us7GxkaKiop2JXJZTfRvMpmW5Ux9Ph9DQ0P76r6FZnLCet1k60G4dIni\no9YWcisaYjGIUbRc71d3nXYYY0tLy7LGk2xJVzAYJJ1Or2hyyBURC4Pz6urqfRnSKSLihYUFJicn\nYWlRnJqaori4mOLiYs6ePXtD5m5/+MMfMj4+TjgcJhKJ8NBDD3Ho0KHdPOWbh3RlWeall16isrKS\n8fFx6urqVM2utpNMVFh3qzi1EcQDLGwfJUnC7XaTl5e3Z1GTFtohjMJXIldYK/rXpmFE9L+VUee7\nDbGFFy5ym3lG1mrlzo6It+KHIWwPZVmmra1t37ThiqIsmwbscrno7+/n1VdfVZtYZmZm+MhHPrJq\nem8/8cMf/pCenh4++9nPMjs7yxe+8AW+9rWv7eazdeubmLP0UIhpvplMhjNnziwbAClJEnNzc/T3\n968w8d6Pa52eniaZTHLy5EnsdrtaqJubm2NgYEDNmYoIcTcMtXezm0xgtdlmYux6MBhUJyCztBi5\n3W4OHTq0L25kaMbVxONxDh48uKWcuiRJ2O127Ha7uthrvWtFETc7H76aNaR4noeGhvZ1EjBLLm3d\n3d243W5OnDhBOp2mp6eHZDLJgw8+uKyIt0Egty9wu920trai1+spKytTB1ruR875liJdr9dLPB7H\nZrNRV1cHmuhWFNiMRuO+DV9kg7ytcKMqKytTr128rBMTE+qImZ0W6gS03WRiaOZeQQwULCgoUKPs\nSCRCY2Pjsqh7LxsctCSXSy+N1SY4a4lYO81BmKWbTCbGx8exWq2cOHFi35ocFEVR9dBigvbMzAwj\nIyNUVlbS0NCw4vnbr53Jejhy5Ahf/epX+aVf+iXC4TDxeHzffIxvufSCsHcUOVOr1cr09DSxWIzm\n5uZ9q6ZqX+id5G03KtSJe17vwd8N6dV2sJlR5yINI3LEWl2t2AHkovsrGo3S09OjdlDtB8mJfPjw\n8DDz8/OYTKYVI+Z3e3yQFuFwmO7ubtWwJ5lMMjg4SCqVoqOjY0OJ2o2Gp59+Wh1A+cEPfnBZsX0X\n8ObI6V65cgWj0YjdbieVSnHlyhUcDgdGo3FZ4WozxJRLCKtDral5LrFaoU4bIbrdbsxmM5lMRjWv\n3s9uMjSjaoSgf7NpnrXkXNtVEWgNvYXGdL8gPhPhg6zX69XdTiAQUG0TFUVZd7LxTiE+k9nZWdrb\n29WRU8IbWXh9vIV1ceuTrqIo+Hw+fD4f586d49y5czQ3N3PnnXeqHgPaLZ0gJi0R55oM4/E4Xq+X\nZDK5LavDnZ5b28gRjUZJp9O43W5qampwu937Es1pB3S2trbmZIu3XR9iIUcTTnL7RSTCaN3n821q\nfI92jpvY7WQT8XaleuFwmK6uLlWil0wmGRgYIJ1O3zDRbWdnJ1/+8peprq6GJZ+Vj33sY/t9Wdm4\n9UlX4OrVq7z22mt84AMfwGg0EggE1K1pKBTCYDCo+TWTybRsvEwymVQLVzvpMNNGlLspRdsMIpGI\nahpdXV29rKtOm0Pc7a2rNr1SW1tLeXn5rn4mYoqD9rsXGmK73Y7P50OW5V3Vum4GPp+P3t5eysvL\nqamp2fZnorX7zJbqaSPitYhY290motvp6WlV4XMjRbednZ089dRTN7oV5JuHdNeDiHTFixgIBIjF\nYlitVrXirNfrVVMYsZUT9oiicLXWi6G11KuoqNhXfwLRGeTz+WhpaVl126zduor7ZalQl0tf3nA4\nTG9vL3a7ncbGxn0rCoki5vj4ODabjUwmAzksTG4F6XQaj8dDLBajvb19V/LqmUxmRUSsJWJxv0KZ\nINrek8kk/f39yLJMR0fHvhWc1sJbpHuTQxSmREQsXPwFCQu5kNi+RiIRDAbDsrSE2WwmFArR19en\nEst+TLslK6LcysRbAW2hLhAIEIlE1EKduOfN5sPXG3W+1xCTb4UZiyD+jTTEYuHJZVQuZGN7EfFn\nI/t+5+fnyWQymEwm5ufnKS8vR1EUamtrdzRDbTfR2dnJN77xDcrKygiHwzz00EMcPnx4vy8rG2+R\n7laQSqUIBAL4/X41AhRVZLvdrlrnhUIh5ubmiEajSJJEWVkZxcXFe97YICC6yZxOZ04jSm2hTuwO\nRKFOELFWsL/dUee7AeHjKpznNqNe0WqIg5r5bTv1IU4kEvT29qrTb/drYWbpWenu7qa0tJTKykqG\nh4d57rnnmJubUy0w77vvPu644459u8a1sLCwQE9PD2fPnmV6epovfOEL/PVf//WNNqr9LdLdCUTF\n3O/3L0tNXL9+nd7eXj760Y9SVVW17GUV+VKRllgvn7ZTaHWtO/WO2CyyC3VCQWCxWPD7/djt9l01\n894MhAVkWVnZjkxh0IwNEt//VjTE2snIYvrtfkGWZQYGBvD5fHR0dGCz2ZiammJsbIyamhq1oBiL\nxUgkEjdkS282fv/3f5/f+Z3f2dfmkVXwFunmEn6/nz/90z/l5MmTHD9+XE09JBKJZWkJ8fBqo+Vc\nytZkWVYt9dbSue4VRI5yfn4el8tFIpFYVqgTC89ejfPRzgbbLR2y1iYxEAisqiFOp9N0d3djt9tp\namra12gsEAjQ09OjLkLxeJyBgQEURaGjo2PfpqFsFS+++CI+n4/3ve99+P1+Pv/5z/OVr3zlrUj3\nVoaiKITD4RURZTqdXqaWCAaDqpTH4XCosjVR3NiJbE3MSMueNLvXWG/U+WqFOkmSVhSucrVQaCPK\n/fBt0GqIA4EAMzMzaltzYWHhvnhqkDV+vaOjA6vVuiy6rauruyG7yNZCLBbjr/7qr1QZ5IMPPrjb\n3rjbwVukux8QXqVaIhZm4IKIjUbjlmRr2lltLS0t+yp32s6oc23hUhQm9Xr9soVnqybaaKYniHz2\nfkY9waXR62KiRHYzx175ELO0K+vp6VHVNPF4nP7+foCbKrq9CfEW6d4o0Ea6fr+fUCikytZEoc5g\nMCybZiBka6lUinA4TEtLy77mBXM96lwU6rLzpZvZAYjGgoWFhU1NT9hNZDIZ1fRdaF1Xg7ZJRyhm\ncu1DnMlk8Hq9hMNhVZI2OTnJ+Pg4tbW11NbW3jDRbTKZ5Hd/93d58MEHueuuu/b7cnKFt0j3RkYm\nk1FfQPESptNplYR7enqYmJjg6NGj6PV6tZqeLVvbi5dIeLru5pw07TQDQcSiUKf1IA4EAng8Hioq\nKvbVgxhN0S47xbJZZHeZiVRMtqZ2M/coGi7EtcRiMQYGBpAkiY6Ojn2bRLIWvv3tb3P16lXe8573\nvEW6b5Hu/iGRSODxePjOd76DJEmcPHmSvLw8NS1hNpuXdSHF43GsVuuKYZK5ghh1LkkSLS0tezJZ\nVgttq+/CwgKzs7MoiqI6leUiOtwOhA1kIpGgvb09p5/LVjXEmUwGj8dDNBpVr+VGjW4FxsfH+da3\nvkVtbS0lJSVvke5bpLu/OH/+PPn5+bS1tamDMbWytWg0isViUSNio9G4bMS6Vra2XVLazKjzvYLW\nlUyMoRfRYSAQUDuusjvqdotopqenGRgY2FPlyFoaYpPJRCAQoLS0lMbGRhKJxA0d3Qp88Ytf5OMf\n/zjPP//8W6S7hLdI9waGiHS1hbpUKoXNZlOJWKfTqRGikK2J7epGsrXtjjrfDQgHLjEZea1CmUjV\naI1+RGODIOLtFOq0iMfj9Pb2otfr912LnE6n6f3/27vzqKivsw/g3/nNyjAMM8gyLAKyY1yQsMSl\ntVaNfZsSk2Antp5QNRptjMmrlWyutdhoTGv0BD1JY62pWyc5SKsxaqJNXBEErTEsIvsyA8MswDjD\n7O8fceYdKCiRWWC4n3NyDjNB7gXOPNy597nPU1UFjUYDoVCIsrIyFBcXg8vlIiEhAVOmTBmWV3kB\n4JtvvkFHRweys7MhkUhGTdAdVoltxA9jy/t1vGVlu03X2dkJpVJpr6fA4/EQEREBHx8f+/5he3t7\nv2lrFosFd+7cgcViweTJkz1Wbxd9DqcGU4GLTqdDKBT2OtxzXP23trbab1w5lr4cTOB0bDXu6VU/\nACgUClRXVyMyMhLjx4+3X2iYNGkSRCIRZDIZamtrIRQKh2XQLSsrQ3t7O8rKyqBQKMBkMhEQEDAc\nr/Q6FVnpejlb7mjftDU2mw1fX197tTVbsJbJZDCZTODz+QgODh5StbWhsh3aPerh1EAcU/kca/L2\nTeNyXE3bisL4+fkhLi7OY3nRcNhHNhgM9p5pra2taG1txbhx4zzaGv5RjaaVLgm6o5DjSbktba2u\nrg6XL1/GxIkT8eSTT4LJZPabtjaYamtDZetsAcBth3a2gzrHQGyxWMDj8WAymeyHU0NNjxuqjo4O\nVFdX29sJ6XQ61NTUgE6n26/1jkQk6P6/YRl0Ozs7kZ+fb2+5npOTg/j4eE9Pa8QqLCxEeXk5nnvu\nObDZ7F65o7a9YduL2ZZfOlC1taEEYlsn4JaWlv/qH+cJKpUKlZWV8PHxAYPBgEajse+Ju6oC2UCM\nRiPu3LkDk8mEpKQkew81qVQ6Yle3Xs67gu7JkychEAgwY8YMlJeXo6CgABs2bPD0tEYsrVbb74Ga\n7S24rdqaRqPpVQTe1gLIGWlrtoMygUCAmJgYj759d7xYkJSU1Ovk33Z70PFGHZPJ7PU9D/Wgri+5\nXI67d+/asyS0Wi1qamrAYDCGzepWr9cjPz8fnZ2dMBqNyM7OxuOPP+7paXmSdwVdRxcuXMDt27fx\n8ssve3oqXs+xCLzj7THH23RMJrNXIZiHpa051twdzEGZq9kOpyIiIgZdktJ2UGf7mTge1A2leabB\nYEBVVRWsViuSkpLAZDLtq9uYmBin7nMP1ZUrVyCXyzF//nzI5XLk5eVh9+7dnp6WJ3lf9oJarcaO\nHTug0+mwadMmT09nVHBsJR4eHg48pAh8cHCw/e23VqtFc3Nzr7Q1Go2Gjo4OREZGIj4+3qMBxFaZ\nzGw2IyUl5QftI7NYLAQGBtq3QxwL36hUKjQ0NNhT+WyB2M/P74H1IWyFzmNiYhASEmIvws5kMpGe\nnj4sVreOpk2bZv9YoVAgICDAo/MZzob9SvfcuXP2tsk2v/zlL5GSkgLcTzs5deoU2V4YRgwGw3/1\npqMoCr6+vvDz84NGo8HVq1eRmJgINpsNvV7fqyi6K5qEDsSx4LotwLlqHNt+uONBnWPFNduhXWVl\npb3QOYPBQEtLC2Qy2bBb3fZnw4YNUCgUePPNNxEVFeXp6XiSd20vlJeXIzIy0l5Q5MUXX8T+/fud\nOobZbMa+ffvQ3t4Os9mMF154AUlJSU4dY7Sw3aZTKpU4e/YsSktLkZaWZt8vday21jeFy3Gv1Nn7\nvDqdDpWVlWCz2YiPj3d7ycW+zSRVKpW9cLhMJkNUVBRMJhM4HI7L+qi5Qn19PT744APs3LlzWP+B\ncDHv2l64du0a6urq8NRTT6GxsdElSeoXLlwAh8PB1q1b0dTUhL179+Kdd95x+jijAY1GA5fLhVQq\nBZfLxa5du8BgMOwBx5a2ZisCHxAQYC94rtPpIJPJUF1d7bS0NavViqamJrS2tiIhIcFjb4Vtl1s4\nHA6USiUEAgFiY2PR1dWFmzdv4vr169Dr9RAKhWhoaMCzzz7rkXkORm1tLfh8vr11u+1m4GDaI402\nIzLoZmdnIz8/H8XFxTAajVi2bJnTx/jRj35k7w/F5/Oh0WicPsZoExsbi9jYWPtjW/AcO3Ys4FAE\nXq1WQ6VSoaurC7h/my40NNS+j6nRaFBXV2evTfxD0tY0Gg0qKiogEAiQnp7u0SwJxyaitjY+Go0G\nMpkM06dPt69uu7q60N7e7rF5DkZ5eTk6OjqwePFiqNVq9PT0ePxQdLgakdsL7nbkyBFQFIWFCxd6\neiqjiuPNMce0NRaL1SttzbEI/EBpa44NKpOTkz0eEPR6PSoqKsBkMpGQkAA6nY7m5ma0tbUhNjbW\no808H4XBYMC+ffugUChgMBiwYMECpKWlDfj5p06dwtmzZ+2PpVIpcnNzH/hvRhjv2tN1tgcd1p0+\nfRqlpaV44403hlsPplHJsQWQY4qWj48P/Pz8wOVywWKxenVr0Ov1MJlMEAgEiI6OBp/P91jxHqvV\nCqlUioaGBsTHxyMwMBAajQY1NTX2vVt3l830tEuXLuHkyZPIy8vzptcYCbqP4vz587h69Spyc3M9\nWkmKeDDb/qFtNWwrAs9kMvH111/Dx8cH8+fPtx/U9a22xufzweVyXb6y7OnpQUVFBdhsNhISEkBR\nFJqamtDe3o64uDiEhYWNqNWtM7S1tWHTpk3YsmULQkNDPT0dZyJB94dqa2vD+++/jy1btgyq99dQ\nlJeX489//jN++9vfjvZbPE5TWlqKQ4cOIS0tDQkJCfZry7a0NQ6H0yt7wFZtzRVpa7aGmU1NTfbq\nZN3d3aipqYGPj8+wW90eOnQIFRUVsFgseOaZZ5CZmemScUwmEzZt2oR58+Zh5syZLhnDg7wre8Ed\nzp07h+7u7l4ZCxs2bHD62x+ZTIaTJ0+SdDQn4/P52Lx5MwQCAdBPXzKFQtGrCLxIJAKTyYTRaIRa\nrUZjY6NT0tZ0Oh0qKirA5XKRlpYGiqLQ0NCA9vZ2xMfHIzQ0dFitbm/fvo2mpiZs27YN3d3deP31\n110WdI8dOwaRSOSNAfeByErXw/R6PZhMJvbt24cnnniCrHTdyLFuhC1tzXabzpY/TFGUvTSmLZvC\nsTMFj8frN2g61t61paXZVrdcLhdJSUnDanVrY7FYYDAY7O8Eli1bho8//tjpe+C3bt3C/v37sX37\n9hGTf/wDkZXucOXqrQtiYHQ6HQKBAAKBAJGRkYBDEXi1Wg2FQoGuri779efw8HBwuVz7qrm+vt6e\ntua4LWGxWFBRUQEej4f09HTQaDQ0NDRALpcjPj4eIpFoWK1uHVEUZf9jcP78eUyZMsUlh46FhYXQ\naDR466237M/NmTMHv/jFL5w+1nBDgq4bPexKM+F5TCaz3zoKtkAslUrtReB5PB6CgoLAZrPtbeSr\nqqpgNBrh5+eH0tJSSKVScDgcBAQEIDMzc8T8kS0pKcH58+dddr1+NNdLIUHXjWbPno3Zs2e7dcy/\n/e1vqK6uBo1Gw+LFixEXF+fW8Uc6Go0GHx8f+Pj4QCQSAQ5F4G1pa21tbWhra8PXX3+N6OhoPP30\n02AwGGhoaMD169eh1WphsVgQFxeHl156ydPf0kPdvHkTBQUFWL9+/bArrOMNSND1YuXl5ZDJZNi2\nbRuam5uxb98+bNu2zdPTGvEcC5mPHTsWZWVluHr1KhYtWoTAwEB0dnZCpVIhKSkJCxcutF/gGO63\nynC/tvKhQ4ewceNGe20TwrlI0PWwsrIy/Otf/0JLSwtqa2vxxRdfOO0t3bfffov09HQAQEREBO7d\nuwetVktWL06WkJCAP/zhD71SzMxmMyiKsu/dMhgMhIWFeXCWg3PlyhV0d3dj165d9udeeeUVj3fx\n8CYk6HpYamoqUlNTXfK11Wo1YmJi7I/5fD7UajUJuk7W34rQkzUdhmLOnDmYM2eOp6fh1TxzF5Jw\ni77pgFarddiemhPEaEGCrhcLCAiAWq22P1apVPbLAoT3a2xsxOrVq3H69GlPT4VwQIKuF5s8eTKK\niooAAHV1dRAKhS5NRCcv8uGjp6cHBw4cwIQJEzw9FaIPsqfrxRITExETE4MNGzaARqPhxRdfdNlY\n5EU+vDCZTLz11lsoLCz09FSIPkjQ9XKLFi1yyzjkRT680On0EXuY5+3I9sIId+LECbz77rv2x3l5\neThz5ozb50Gn00n5S4IYBLLSHeGeeuopXLp0Cf/5z39gMBig0+kwd+5cT0+LIIgBkKA7wlEUhRUr\nViA/Px8WiwVr1qzxWFcEgiAejgRdLxATEwMulwuKouzVsryduwptj1S1tbX45JNPIJfLQafTUVRU\nhHXr1pGrvcMACbpeoKysDBRFwWg0oqyszGU33B7EnS9ydxbaHqliYmKwZcsWT0+D6AcJuiOcLVUr\nNzcXBoMBu3btwvjx491eINudL/Lx48fbq6X5+vpCr9fDYrGQbRViRHhY0CV3Roe5nJyc9wAwIiMj\n/xcA5HL5xzk5Od0SiWSNp+fmKo6FthcuXPgSgB9RFPWCp+flCmKxeBeAJ+53cXlNIpGUeHpOxNA8\nrF0PQQxbYrF4PoC3ATwpkUg6PT0fZxOLxTMB5Eokkl+IxeJkAH+VSCRTPT0vYmjI+zFiRBKLxfMA\nrAfwP94YcO+bDaAQACQSSQUAoVgs5nt6UsTQkD1dYsQRi8X+AHYCmCORSJQuHosL4G8AQgBwAPxB\nIpGcdOWYDkQASh0ey+8/1+Wm8QkXIEGXGImeBxAIQCIWi23P5UgkkkYXjJUF4LpEInlXLBZHAfgS\ngLuCbt8zFRrp0D3ykT1dL1FaWkrxeLzXWSxWMo1GI9tGLqBSqYJlMtmk5OTkr9wxXkNDwyQmk6kL\nDQ2tMhgMFZs2bXrJarVOlkgk3e4Yn3ANEnS9RFVV1Ztjx44Vc7lci6fn4o2am5uTTCYTUyQS3eVw\nODp3jKnVan1VKlVYeHh4tVKp9C0oKOAsW7ZsnDvGJlyHrIi8BIvFSiYB13UiIiIqRSLR3fb29nHu\nWqhwudx7LBZL29zcnKTVaiMyMjK+dcvAhEuRPV0vQbYUXEOn03EZDIaRyWQa769waWazmcFgMEzu\nGD8oKKjF9rHJZPLWLI1RhbxQCeIBdDodT6VSifB90GNYLBaKTqe7JeAS3okEXcIpqqqqWL6+vlMy\nMjISHf9ra2vrt5J2dXU169///jcXAJYuXTq2srLykYvxXrt2zefWrVvswX6+UCicPNjPFQgEcrPZ\nzGhubk6USqXxY8aMaSTNPYmhINsLhNOMGzeup7i4uGown/vFF1/4aTQaatasWdq//vWvTUMZ9x//\n+IcwPT393qRJk/RD+Tr9oSjKGhoaWufsr0uMXiToeiOTnoaOWue2cQiMMYDBfqQTpIKCAv7mzZvD\nORyOJSgoyPjxxx837tixI4zBYFijoqIMu3fvFuXn5zccPXo0oKOjg1FXV8duampib9iwoeXgwYOB\nzc3NrM8//7w6Pj7ekJ2dPU4qlbJ0Oh21fv361tjYWMMnn3wSdPLkSYFIJDLq9Xpq/fr14Uwm0xoW\nFmY4cuRIA51Ot86fPz+mtbWVlZKScq+/Oebn5wfs27cvhKIo6+rVq9uWL1+u2rx5c8g///lPocVi\nwWv6faEAAAoKSURBVNy5czv/9Kc/SdeuXRv2oDmOHz/esHr16vCrV6/yLBYLbcWKFe0rVqxQZmdn\nR7NYLKtSqWQcPXq0Ljs7O0ar1VI6nY7avXt346xZs7Tr168XnThxQkBRFH72s5+pt2/fLhvy740Y\ndsj2AuFyH3zwQfDOnTubSkpKqp5//nmlyWTC888/r1ixYkXbokWLeh0OqVQq+sWLF6uzsrJUhw4d\nGnPx4sXqp59+WvXZZ58J2tvbGXPnzu0qKSmpkkgkNXl5eWEZGRm6mTNndv7+979vmTVrlnbNmjWR\np06dultUVHQnODjYdODAAWFBQYG/0Wik3bx5szInJ0epVqsZfcakduzYEVZUVFR5/vz56mPHjgXY\n/t/169crb968WXns2LFApVJJPWyOp0+f5jU2NrKuX79edfny5aqdO3eGajQaGr7f1jCdOXOmprm5\nmbl06dKOa9eu3cnLy2vZvn17KADs3bs3pLS0tLKsrKxSKBSa3fYLItyKrHS9EYNthSjZ6W+1H6au\nro6TkZGRaHscFxfXc+TIkYbs7GzlK6+8ErVgwQLF4sWLlZGRkQMeRKWnp98DgNDQUAONRrMCQEhI\niFGhUDACAwPNJSUlvqmpqUE0Gs3aN3g2NTUxGhoa2FlZWXH4Ps+VCgwMNEqlUuYTTzyhAYCf/vSn\n9zgcTq/Uups3b3Li4uJ6eDyelcfjmc+dO1eD71O2LJmZmYl0Oh1qtZohl8sZD5vjxYsXeTdu3PC1\n/RwsFgsaGxuZAJCZmXkPAMLDw02bNm0Svv/++yF6vZ6ypfr9/Oc/V02fPj1RLBYrli9frnDir4YY\nRkjQJZxmoD3dVatWKZ955pmuo0ePCrKysuIlEknNQF+DwWBYHT62P2+1WmkfffRRgEqlopeUlFS2\nt7cz0tLSkh3/LYfDsQYHBxv7zmHjxo0hjrV2LRZLr5MwBoMBi6V3ivOdO3dYe/fuDbl161a5v7+/\nJT4+/rHBzJHFYpkXLVrU8c477/zX1gCLxbICwB//+MfgsLAwQ2FhYd2FCxe469atGwsAhw8fbrxx\n4wbn8OHDwunTpyfdunWrnMlkDvSjIkYosr1AuFxubm4oi8Wyrlu3ruPZZ59V3rp1i0NRlNVkMv2g\nNICOjg5GdHS0gU6n4/DhwwKj0UjD/fq6JpOJFhQUZMb3V6I5ALBt27bga9eu+SQlJfWUlZVxAeDL\nL7/0NRgMvcadPHlyT21tLaezs5PSarW0adOmxbe1tTHGjBlj8vf3t1y6dInb2trK0uv1D53vtGnT\n7p0+fVpgNpuh1Wppv/nNb8b2933ExsbqAeDTTz8VGo1GmlKppNatWxc6ZcqUnvfee08qFApNSqWS\n9FD3QmSlSzhN3+0FANixY0dTZGSk4Sc/+UmCv7+/2d/f37Rx48Y2Pp9vWbFiRXRQUNCgc15//etf\nq7KysuKmTp3qm5OT0xESEmLMzc0NnTFjRvfrr78+ls/nmz/88MP6JUuWRDOZTKtIJDKuXbtWnpKS\n0nPgwIHA9PT0xMcee0wbHBxsdPy6fD7f8vbbb7fOnDkzwWq1YtWqVW1Tp07Vcrlcc2pqalJmZmb3\nokWL5CtXroyybVMMZO7cufdmzJjRPWXKlCSr1Upbvnx5e9/PWbp0qWLJkiXjCgoKhC+//HL78ePH\nA/7+978L5XI5Y+LEicm+vr7mjIwMTUhICNnX9UKk9oKXqK+v/3t0dHTyID6VGKHq6+sroqOjvbJD\nxmhCthcIgiDciARdgiAINyJBlyAIwo1I0CUIgnAjEnQJgiDciARdgiAINyJ5uoTT3L59m/3qq6+O\n7ejoYOD7bguG/fv3N4aGhpqmTp2aYDababW1tZyAgACjQCAw//jHP+567733pJ6eN0G4Ewm6hFOY\nTCZkZ2fH7tmzp3HevHkaAFi/fr3opZdeGnvixIm6q1ev3gGA7Ozs6AULFqh+9atfkS4IxKhEgq4X\nMumtNEWDyamlHcdEMQwMNm3AmzSFhYX8xMREnS3gAsDWrVtlP+TyzeXLl31WrVoVRVEU0tLSNB99\n9FFzYWGh35YtW8KZTKbV39/fdPLkydqvvvqKt3v37mAGg2G9ffs293e/+5307Nmz/t999x03Ly+v\n+YUXXlAfPHhQsHv3bhGdTrempKTc+8tf/tK8Z8+eMWfOnPGXyWTMzz77rHbbtm0hN27c8NXr9dTS\npUvla9eu7ehbhvL48eN1bPajlbQkiP6QPV3CKcrLyzkTJkzo1SWXTqf3KgjzMK+++mrkhx9+2FBW\nVlYpl8sZd+7cYSmVSsaxY8dqS0pKqvz8/MwFBQX8++NxCwoK6vbs2dO4devWiGPHjtXv2bOn4eDB\ng2M6OzupHTt2hF6+fLmqpKSkqqWlhXX27FlfAGhpaWGVlJRUhYSEmKKjow2lpaVVRUVFldu3bw9D\nP2UoB+p8QRCPiqx0vRCDTbOGJDDdWtrRVnTG9nj27Nmx3d3dDJlMxvzuu+/K/fz8HtqpuL6+npOZ\nmakDgOPHj9fj+2pf7CVLlkSbTCZaU1MTe9asWd18Pt+QnJys9fHxsUZERBjGjRvXw+fzLWFhYcbu\n7m56aWmpj1QqZc2cOTMBALq7u+m1tbVsAEhJSblHURS4XK5VqVQypkyZksRkMq1KpZKB77c/Bl2G\nkiAeBVnpEk4xceJEXWlpKdf2+Ny5czXFxcVVZrOZ1rds4kD66z22cuXK6Pz8/MaSkpKqJ598Um17\n3rG8Ip3+/4tRq9VKY7PZlscee0xbXFxcVVxcXFVRUVG+cuVKJRzKK37++ee8Cxcu+BUVFVUVFxdX\n2bYQVq1apfzmm2+qAgMDTVlZWfE3btzgDOHHQhD/hQRdwimysrK6pVIp68iRI/625y5dusS9d+8e\nnU6nD2pPNC4uTnf+/HlfABCLxVFlZWUcjUZDj4uLM3R0dNCvXLni17csY38mTZqkr6mp4bS0tDAA\nYM2aNWF1dXW9CtPK5XJGWFiYgc1mWw8fPuxvNptpPT09tP7KUD7SD4QgBkCCLuEUFEXhyy+/rD50\n6NCYCRMmJKempia98cYb4Z9++mk1j8cbVNDds2dPU25ubsTjjz+eKBAIzKmpqT2LFy9uz8jISMrJ\nyYl67bXXZLt27QptaWl5YGVvPz8/y/bt25vmzZsXn5qamqRQKBhRUVG9yjlmZWV119XVcdLT0xPv\n3r3LnjVrljonJyfSVoZy2rRpCd9++63Pc8891zXUnw1BOCKlHb0EKe3o/UhpR+9AVroEQRBuRIIu\nQRCEG5Gg6yWsVuvgUgSIEYv8jr0DCbpewmAwVGi1WvL79FJarZYyGAwVnp4HMXTkcoSX0Gg07zY1\nNYHFYiXTaDQSfL2I1Wq1GAyGCo1G866n50IMHcleIAiCcCOyIiIIgnAjEnQJgiDciARdgiAINyJB\nlyAIwo1I0CUIgnCj/wPKaIUIIPwFTQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625449207824" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625435141520" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAAENCAYAAACsBrZAAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nIOzofwGNHDq9Xju9YAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139625435468368" + }, + "output_type": "display_data" + } + ], + "source": [ + "# initialize the absolute log-rotations/translations with random entries\n", + "log_R_absolute_init = torch.randn(N, 3).float().cuda()\n", + "T_absolute_init = torch.randn(N, 3).float().cuda()\n", + "\n", + "# futhermore, we know that the first camera is a trivial one \n", + "# (see the description above)\n", + "log_R_absolute_init[0, :] = 0.\n", + "T_absolute_init[0, :] = 0.\n", + "\n", + "# instantiate a copy of the initialization of log_R / T\n", + "log_R_absolute = log_R_absolute_init.clone().detach()\n", + "log_R_absolute.requires_grad = True\n", + "T_absolute = T_absolute_init.clone().detach()\n", + "T_absolute.requires_grad = True\n", + "\n", + "# the mask the specifies which cameras are going to be optimized\n", + "# (since we know the first camera is already correct, \n", + "# we only optimize over the 2nd-to-last cameras)\n", + "camera_mask = torch.ones(N, 1).float().cuda()\n", + "camera_mask[0] = 0.\n", + "\n", + "# init the optimizer\n", + "optimizer = torch.optim.SGD([log_R_absolute, T_absolute], lr=.1, momentum=0.9)\n", + "\n", + "# run the optimization\n", + "n_iter = 2000 # fix the number of iterations\n", + "for it in range(n_iter):\n", + " # re-init the optimizer gradients\n", + " optimizer.zero_grad()\n", + "\n", + " # compute the absolute camera rotations as \n", + " # an exponential map of the logarithms (=axis-angles)\n", + " # of the absolute rotations\n", + " R_absolute = so3_exponential_map(log_R_absolute * camera_mask)\n", + "\n", + " # get the current absolute cameras\n", + " cameras_absolute = SfMPerspectiveCameras(\n", + " R = R_absolute,\n", + " T = T_absolute * camera_mask,\n", + " device = \"cuda\",\n", + " )\n", + "\n", + " # compute the relative cameras as a compositon of the absolute cameras\n", + " cameras_relative_composed = \\\n", + " get_relative_camera(cameras_absolute, relative_edges)\n", + "\n", + " # compare the composed cameras with the ground truth relative cameras\n", + " # camera_distance corresponds to $d$ from the description\n", + " camera_distance = \\\n", + " calc_camera_distance(cameras_relative_composed, cameras_relative)\n", + "\n", + " # our loss function is the camera_distance\n", + " camera_distance.backward()\n", + " \n", + " # apply the gradients\n", + " optimizer.step()\n", + "\n", + " # plot and print status message\n", + " if it % 200==0 or it==n_iter-1:\n", + " status = 'iteration=%3d; camera_distance=%1.3e' % (it, camera_distance)\n", + " plot_camera_scene(cameras_absolute, cameras_absolute_gt, status)\n", + "\n", + "print('Optimization finished.')\n" + ] + } + ], + "metadata": { + "bento_stylesheets": { + "bento/extensions/flow/main.css": true, + "bento/extensions/kernel_selector/main.css": true, + "bento/extensions/kernel_ui/main.css": true, + "bento/extensions/new_kernel/main.css": true, + "bento/extensions/system_usage/main.css": true, + "bento/extensions/theme/main.css": true + }, + "file_extension": ".py", + "kernelspec": { + "display_name": "pytorch3d (local)", + "language": "python", + "name": "pytorch3d_local" + }, + "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.7.5+" + }, + "mimetype": "text/x-python", + "name": "python", + "npconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": 3 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb b/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb new file mode 100644 index 00000000..b1314da5 --- /dev/null +++ b/docs/tutorials/camera_position_optimization_with_differentiable_rendering.ipynb @@ -0,0 +1,697 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Camera position optimization using differentiable rendering\n", + "\n", + "In this tutorial we will learn the [x, y, z] position of a camera given a reference image using differentiable rendering. \n", + "\n", + "We will first initialize a renderer with a starting position for the camera. We will then use this to generate an image, compute a loss with the reference image, and finally backpropagate through the entire pipeline to update the position of the camera. \n", + "\n", + "This tutorial shows how to:\n", + "- load a mesh from an `.obj` file\n", + "- initialize a `Camera`, `Shader` and `Renderer`,\n", + "- render a mesh\n", + "- set up an optimization loop with a loss function and optimizer\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up and imports" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import numpy as np\n", + "from tqdm import tqdm_notebook\n", + "import imageio\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import matplotlib.pyplot as plt\n", + "from skimage import img_as_ubyte\n", + "\n", + "# io utils\n", + "from pytorch3d.io import load_obj\n", + "\n", + "# datastructures\n", + "from pytorch3d.structures import Meshes, Textures\n", + "\n", + "# 3D transformations functions\n", + "from pytorch3d.transforms import Rotate, Translate\n", + "\n", + "# rendering components\n", + "from pytorch3d.renderer import (\n", + " OpenGLPerspectiveCameras, look_at_view_transform, look_at_rotation, \n", + " RasterizationSettings, MeshRenderer, MeshRasterizer, BlendParams,\n", + " SilhouetteShader, PhongShader, PointLights\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Load the Obj\n", + "\n", + "We will load an obj file and create a **Meshes** object. **Meshes** is a unique datastructure provided in PyTorch3d for working with **batches of meshes of different sizes**. It has several useful class methods which are used in the rendering pipeline. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set the cuda device \n", + "device = torch.device(\"cuda:0\")\n", + "torch.cuda.set_device(device)\n", + "\n", + "# Load the obj and ignore the textures and materials.\n", + "verts, faces_idx, _ = load_obj(\"./data/teapot.obj\")\n", + "faces = faces_idx.verts_idx\n", + "\n", + "# Initialize each vertex to be white in color.\n", + "verts_rgb = torch.ones_like(verts)[None] # (1, V, 3)\n", + "textures = Textures(verts_rgb=verts_rgb.to(device))\n", + "\n", + "# Create a Meshes object for the teapot. Here we have only one mesh in the batch.\n", + "teapot_mesh = Meshes(\n", + " verts=[verts.to(device)], \n", + " faces=[faces.to(device)], \n", + " textures=textures\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "\n", + "## Optimization setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a renderer\n", + "\n", + "A **renderer** in PyTorch3d is composed of a **rasterizer** and a **shader** which each have a number of subcomponents such as a **camera** (orthgraphic/perspective). Here we initialize some of these components and use default values for the rest. \n", + "\n", + "For optimizing the camera position we will use a renderer which produces a **silhouette** of the object only and does not apply any **lighting** or **shading**. We will also initialize another renderer which applies full **phong shading** and use this for visualizing the outputs. " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize an OpenGL perspective camera.\n", + "cameras = OpenGLPerspectiveCameras(device=device)\n", + "\n", + "# To blend the 100 faces we set a few parameters which control the opacity and the sharpness of \n", + "# edges. Refer to blending.py for more details. \n", + "blend_params = BlendParams(sigma=1e-4, gamma=1e-4)\n", + "\n", + "# Define the settings for rasterization and shading. Here we set the output image to be of size\n", + "# 256x256. To form the blended image we use 100 faces for each pixel. Refer to rasterize_meshes.py\n", + "# for an explanation of this parameter. \n", + "raster_settings = RasterizationSettings(\n", + " image_size=256, \n", + " blur_radius=np.log(1. / 1e-4 - 1.) * blend_params.sigma, \n", + " faces_per_pixel=100, \n", + " bin_size=0\n", + ")\n", + "\n", + "# Create a silhouette mesh renderer by composing a rasterizer and a shader. \n", + "silhouette_renderer = MeshRenderer(\n", + " rasterizer=MeshRasterizer(\n", + " cameras=cameras, \n", + " raster_settings=raster_settings\n", + " ),\n", + " shader=SilhouetteShader(blend_params=blend_params)\n", + ")\n", + "\n", + "\n", + "# We will also create a phong renderer. This is simpler and only needs to render one face per pixel.\n", + "raster_settings = RasterizationSettings(\n", + " image_size=256, \n", + " blur_radius=0.0, \n", + " faces_per_pixel=1, \n", + " bin_size=0\n", + ")\n", + "# We can add a point light in front of the object. \n", + "lights = PointLights(device=device, location=((2.0, 2.0, -2.0),))\n", + "phong_renderer = MeshRenderer(\n", + " rasterizer=MeshRasterizer(\n", + " cameras=cameras, \n", + " raster_settings=raster_settings\n", + " ),\n", + " shader=PhongShader(device=device, lights=lights)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Create a reference image\n", + "\n", + "We will first position the teapot and generate an image. We use helper functions to rotate the teapot to a desired viewpoint. Then we can use the renderers to produce an image. Here we will use both renderers and visualize the silhouette and full shaded image. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAEfCAYAAACDGogmAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAwuph6AHQDgpAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267769944592" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Select the viewpoint using spherical angles \n", + "distance = 3 # distance from camera to the object\n", + "elevation = 40.0 # angle of elevation in degrees\n", + "azimuth = 10.0 # angle of azimuth rotation in degrees\n", + "\n", + "# Get the position of the camera based on the spherical angles\n", + "R, T = look_at_view_transform(distance, elevation, azimuth, device=device)\n", + "\n", + "# Render the teapot providing the values of R and T. \n", + "silhouete = silhouette_renderer(meshes_world=teapot_mesh, R=R, T=T)\n", + "image_ref = phong_renderer(meshes_world=teapot_mesh, R=R, T=T)\n", + "\n", + "silhouete = silhouete.cpu().numpy()\n", + "image_ref = image_ref.cpu().numpy()\n", + "\n", + "plt.figure(figsize=(10, 10))\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(silhouete.squeeze()[..., 3]) # only plot the alpha channel of the RGBA image\n", + "plt.grid(\"off\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(image_ref.squeeze())\n", + "plt.grid(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Set up a basic model \n", + "\n", + "Here we create a simple model class and initialize a parameter for the camera position. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class Model(nn.Module):\n", + " def __init__(self, meshes, renderer, image_ref):\n", + " super().__init__()\n", + " self.meshes = meshes\n", + " self.device = meshes.device\n", + " self.renderer = renderer\n", + " \n", + " # Get the silhouette of the reference RGB image by finding all the non zero values. \n", + " image_ref = torch.from_numpy((image_ref[..., :3].max(-1) != 0).astype(np.float32))\n", + " self.register_buffer('image_ref', image_ref)\n", + " \n", + " # Create an optimizable parameter for the x, y, z position of the camera. \n", + " self.camera_position = nn.Parameter(\n", + " torch.from_numpy(np.array([3.0, 6.9, -2.5], dtype=np.float32)).to(meshes.device))\n", + "\n", + " def forward(self):\n", + " \n", + " # Render the image using the updated camera position. Based on the new position of the \n", + " # camer we calculate the rotation and translation matrices\n", + " R = look_at_rotation(self.camera_position[None, :], device=self.device) # (1, 3, 3)\n", + " T = -torch.bmm(R.transpose(1, 2), self.camera_position[None, :, None])[:, :, 0] # (1, 3)\n", + " \n", + " image = self.renderer(meshes_world=self.meshes.clone(), R=R, T=T)\n", + " \n", + " # Calculate the silhouette loss\n", + " loss = torch.sum((image[..., 3] - self.image_ref) ** 2)\n", + " return loss, image\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialize the model and optimizer\n", + "\n", + "Now we can create an instance of the **model** above and set up an **optimizer** for the camera position parameter. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# We will save images periodically and compose them into a GIF.\n", + "filename_output = \"./teapot_optimization_demo.gif\"\n", + "writer = imageio.get_writer(filename_output, mode='I', duration=0.3)\n", + "\n", + "# Initialize a model using the renderer, mesh and reference image\n", + "model = Model(meshes=teapot_mesh, renderer=silhouette_renderer, image_ref=image_ref).to(device)\n", + "\n", + "# Create an optimizer. Here we are using Adam and we pass in the parameters of the model\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=0.05)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualise the starting position and the reference position" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Reference silhouette')" + ] + }, + "execution_count": 12, + "metadata": { + "bento_obj_id": "140267760329488" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlYAAAEtCAYAAADKqC6AAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nWEmSJJXEYCVJklQSg5UkSVJJ/j8aiYrAsm1hZQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267802952144" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "\n", + "_, image_init = model()\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(image_init.detach().squeeze().cpu().numpy()[..., 3])\n", + "plt.grid(\"off\")\n", + "plt.title(\"Starting position\")\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(model.image_ref.cpu().numpy().squeeze())\n", + "plt.grid(\"off\")\n", + "plt.title(\"Reference silhouette\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run the optimization \n", + "\n", + "We run several iterations of the forward and backward pass and save outputs every 10 iterations. When this has finished take a look at `./teapot_optimization_demo.gif` for a cool gif of the optimization process!" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2d3e3feb01f74f29a767dea9f99e1315", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=200), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAD2JJREFUeJzt3X2M5PVdwPH3Z3Zmd2YfDrjdS7Fw\nFyINyEMVailpaxMhgGnVQpEIhXC2xlofGmJtrRGbHliEVpNaLWpS1GDbqFXApq2aIwZbaXuUPohQ\nCQ8eFfFIjuO43b2HmZ2nr3/w+01+N7d7zHJ3nT3m/Up+2b35zcNv5vb3nu/vYXYjpYSk0VYa9gJI\nGj5DIMkQSDIEkgyBJAyBJAzB6kREIyLeMezlGFREpIi4atjLobXPEKxCSqmaUvpHXlzJTouIa4/l\n40XEuoj4TETsiIjnI+ILEfFDx/Ixj7aIuCMLaHFqRsT3B5mfXeeKiPhuROyNiEcj4pcK88Yi4qMR\n8XRE7I+IJyLigy+xTNWI+OOI6C4Xyoh4d0T8V0Tsy+7vN4/+K7PGpJScXsYEfAD48jF+jL8F7gNe\nDZwE/B3w9VXcPgFXDfu1Wma57gZ+f5D5wDnAEvDzwARwMbAfuDSbfzPwBHBW9sZ2EVAHrl7hvk8G\nvgfcsdzrA1wO7AMuAcrZ1wZwxbBft2P6fzLsBTiepvwHB/gw0MmmBnAKEMBvA48DB7Kv1xdueyfw\nOeCLwGJ22YeB76zwWHNAG3hT4bKN2TKct5rlzb4fBz4OPJWtKP8JvL1w3QuArwELwB7gn4CN2bwN\nwD8Az2crybeAiwq3bQDvGHCZfgb4H2BykPnAJ4F7+67zl8AXsu/fClzQN/+7wG0r3P+5eSRWCMF1\nwG/0XfYV4JPD/vk7pj/bw16A42nqW7HuLI4IgF8HngFeC4wBb8veyV5fuP5u4FqgNMBjXZo9XrXv\n8ueA97yM5f14FqcfyaLwPqAJvCab/wTw0exdcB3wWeDz2bxPA1uzy8vZbXcA5VW+fmXgSeCaQecD\nXwc+1ne9XwN2LHP7CeCdWczesJrX5zDXKQHbgQ8O++fvWE7uIzh63gt8KqX0SEqpk1L6Z+DLwLsK\n13khpfQ3KaXuAPe3AWiklBp9l7+QjRZW6z3AH6aUHkspNVNKtwP/B1yZzT8R2J9SaqeUFoFfSCld\nXZjXBA5k828HTk0ptVe5DNcDLeDvVzF/QzZCKTrkNYiIO7KRzh8Bm1NKD65y2VZyK1AF/uIo3d+a\nZAiOnjOAW4o7vYCfBTYVrvP9w9x+UJG9kw1+g4iTsn0Mj/bN+m/gh7PvPwR8OCIei4hPAW8pXO9j\nwHnAjoj4XES8Mxv1rNaHgE8cJoQvNb/3lPpfg5TSe4BaNjK7MyKuXPnmLy0iShHxCeDdwFtTSvNH\ncn9rnSE4eurAe7MjC/k0nlJ6e+E6zVXc306gGhFTfZfPZfNWo7rC5ZF/k1K6EzgVuCV7F94aER/L\n5n03C8a7gHngT4CvRMTAMYiIH8ti+cVVzt+5zAho2dcgpbSUUrob+Axww6DLtsyyVLJ9Ij8FvDGl\n9PDLva/jhSE4ep7M3jV7ImLTalaWPv+R7Sx8feH+XgOsB7at8r52Anuz/Rf5fZWy/QVPZv+eSynN\np5Q+l1K6JtsO/9Vs3om8uKL9S0rpfcCFwJuBH13FMlwBfCul9Nwq5z9YfA0yFwLfyJbtGxHxy33z\nJ7JNjJfrs9nRhTenlJ46gvs5bhiCl68ObIyIEyNiHPhT4Bcj4tKIKEfEG4HvZJsHq5ZSeiE7fHhL\nRLw6ImaBP8j2oD/GiyvBbRHx5wPcVxf4a+ADEfGaiJgAfiuLyucj4lTg2Yj4uey4fC2L2pPZXTyQ\nLcdUFpALsx2h/7uKp3QBcLh31pXmfxp4U0RcGxETEXFZtl/j9mz+14DfjYjzs2V/S7bD8AvZa/SG\nbHPnxEEWMiKuzjaLfvqVvjlwkGHvrTyepr698D+R7cHfC/x4Nsz+nWzlqGd76H+lcNs7+887ONzh\nw2z+NPBX2XB8MduJNtt3n18ccHlrwJ9lyzcP/Ht+RCObfxXwSHaMfnd2+PDMbN5rgX/LlmExO3z4\ntsJtX/LwYRbFW1/O/OwIzPey+DwJXFuYN56dS/Bs9ro/kUUusvk/mb0Oc4XXvJFNKdtca+SHKIF/\nLRwWLk73Hu75He9T/mLpOBQRm4DfSym9a4CrSyty0+D4dmV2sot0RBwRSHJEIMkQSMrO7R6KiHCb\nRDrGUkoxwNUcEUgyBJIMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQM\ngSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQM\ngSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQM\ngSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQM\ngSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMgSQMwWi66aabhr0IWmMipTScB44YzgOPuFtv\nvZXx8XGazSbNZtMovMKllGKQ6xmCEXLbbbexYcMGWq0W7XabZrPJ4uIiN99887AXTceIIdCytm7d\nys6dO2m1WjSbTRqNBgsLC44MXqEMgZZ17733Mjk5ya5du3ohWFpa4tlnnz0oBnfccQfnnHMODz30\nEO12m263S0qJiGBiYoLzzjuPBx54gPe///1DfT46PEOgFW3bto0DBw6wb98+lpaWqNfr7Nmzh/n5\neV71qlexadMmHnvsMfbv30+n0yHi4J+lPAjr1q3j7LPPZmlpicsvv3xoz0crMwRa0YMPPkij0WDv\n3r10Oh3q9TqPPvoo559/Pk899RSLi4tEBJVKhfHx8UNun1JiaWmJdrsNwOTkJBdccAFf/epX3cRY\nYwYNQfnYL4rWmohgbGyM8fFxFhcXmZyc5IwzzuChhx5ibGyMarVKpVLpjQQigv43jFqtRkqJVqvF\ngQMHuP/++zn33HOH9Ix0pBwRjKD77ruPyclJGo0G+/bt45FHHqHRaPQCUC6/+P5QDEDx5yQPREqJ\nlBKdTodms0mr1SKl5FGINWTQEYEnFI2giy++GIBSqcS3v/1tZmdnmZqaolqtMj4+TqlUYmxsrLfC\nLyws0Gg0qNfrLC4u9vYR5NerVCq925555pls2bJlyM9Qq+WIYERt2bKFcrnMhg0bmJ+fZ926dQfN\nz9/tK5UKFEYH+ZTvHyjuSEwpsXv3bubm5ti1a5cjgzXAEYEOKyKYnZ2l3W5Tq9UolUrLTtVqlVqt\n1vuaf082ouifZmZmaDabnHLKKY4MjiOGYAQV9+w3Gg3K5fIhK/TY2BhjY2PMzc1RrVapVqtMTExQ\nrVZZv359b37/7crlMnv37qVWqxERHkU4TnjUYETlOwYnJiZ6IaBvqB8R7Nmzh9NPP52IoNvt0m63\nefzxx3s7FItSSpTLZarVKvv37/+BPh8dGUMwgkqlUu/wYPGdnUII8p2B1WqV+fl5arUa3W6Xffv2\nMT09Tb1eh8K+hPz7/LAkQKVSodVqDe15anDuLBwxW7ZsYWZmhlqtRqvV4oQTTqBUKh0yEsin/ChC\nPr/b7dLpdGi1Wr3Tjosh6Ha71Ot1ZmZmeO6556jX63S7XTcRhsQTirSs4mjgpJNO6o0K+s8TyKd8\n5S6GoHj4sD8EZCOBfHRQLpdpNptDerYalCEYMeVyuTeNjY31Lut0OgddrxgCCit5/rV/BJFS6m1e\nVCoVOp1Ob7NDa58hGCE33XRT78zBcrncW4Hz77vd7iG36f/AEYVILDe/2+0yMTFBvV7vjQiGtfmp\nwXn4cITkK33xnbpWq/Hwww9TLpepVCqHHBLsl6/4yx027D/6UDwMqbXNEIyQfMUsrqApJV73utf1\nDiPmI4aVTjDKV/D8azEg+aFD+kJQKpXcWbjGuWkwQvpX9vxrfsjv6aef5qyzzqLT6dBut3sfKFpu\naJ9vHuQx2bVrF7Ozs9Tr9V4giqcpexhxbXNEMEKazWbvnbr4rp5/f/bZZ9Ptdrn//vuZnp5mcnLy\noLMKi1N+qvG2bdsolUqcfPLJBx1t6H8MP3ewthmCEfKRj3wECu/m+Yqafw8wPj7OZZddRrfbZdeu\nXdRqNaanp5mZmWF6eprp6WlqtVrvnf+iiy7qfTCJvkOPxcfQ2uamwQjqX1mXm8bHx9m4cSP0nTsA\nMDY2xvr163snF/XfbzEw+e21thmCEVP8+HBx6r+Mvh1+ueLHkFfad0DfIcb8MbV2uWkwYm644YZD\nLusPACucP1D8fQQr3Uf/bVNK3HjjjUfxGehYMAQjKP+VYoNY7leVLffvoohg586dbN++fdlzEbT2\n+L80gjZv3ky32+1t+7+U1ZwZGBEsLCz09jPs2LHjCJdWPwjuIxhRS0tLh5wCXFzhl/tMweE2DXLF\nDxjl1yueTOSJRWuTI4IRdf3119NoNA76K0bLreiHW/n7L+8fYXQ6Haampti0aRObNm3ikksu4Utf\n+tIP4NlptQzBCLvuuutYXFyk1Wr1ziBcbqIvCPlHk/t/menExMRB9z87O8vpp5/O3NwclUqF3bt3\nMzMzw9atW4f0jLUSQzDiNm/ezPPPP0+73abT6dDpdHr7D/KVfbkRQ/+U7xTMz0Zcv349p512Giec\ncAJTU1Ns3LiR7du3s7S0BMBdd9015GeuIn9DkQ5yzz33MDU11fuwUP4RZfpGBfmfVm+32xw4cICr\nr74asj+ekkeh2WzywgsvcM011xz0GN/85jd55plnuOqqq4bwDEeLf/tQR+zuu+9mZmZm2RAsLCz0\nVn6tXYZAkn/gRNLgDIEkQyDJEEgyBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIw\nBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIw\nBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIw\nBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIw\nBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIwBJIw\nBJIwBJIwBJIwBJIwBJIAIqU07GWQNGSOCCQZAkmGQJIhkIQhkIQhkIQhkIQhkIQhkIQhkIQhkIQh\nkIQhkIQhkIQhkIQhkIQhkIQhkIQhkIQhkIQhkIQhkATw///mkSj4OiM4AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267769472976" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nBJIwCCRhEEjCIJCEQSAJg0ASBoEkgP8FtdAvPCBp9f4AAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267769510800" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267769471504" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nPHIbeOQAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267376690832" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAFf1JREFUeJzt3X2QnVVhx/Hvue/37k12E0jYQEIZ\nihFpAGfqSyUwyCBibEk0OkBLHaNTR61p69gS2hnLbiqjWGpUoFULMhYYGaFTC74wMp0xOh2LAxYb\nagaEpAGaZeKa7GZfct/v6R855+nZZ+/dvRuSvcnN7zPzzGbv83Kf+2TP7znnPOd5rrHWIiKnt0S3\nd0BEuk9BICIKAhFREIiIgkBEUBCICAqCuRljysaY93Z7P44XY4w1xry/2/shJx8FwRystTlr7bc5\nWojOM8b8wWK9tzHmva7gbgleW2qMud8Ys98Y82tjzL8aY1Yt1j4dD8aYLe5zlWPTx9z8e1rMqxpj\n/ifYxgeNMf9tjJkyxuwzxvydMSbb6fpz7NsSY8wrxpidsdc/ZIz5hXu/XxpjPnVijk73KAg69z5g\nUYLAGLMU+BIwHZv1NWA18GbgdUAZ+OfF2Kfj7CUXsuH0VY6G70fi84DvAN/k6LG5ErgH+BSwFLjG\n/d98upP15/E5YEn4gjFmE3AX8GfAAPDHwGeNMe85QcemO6y1mtpMgAXe7/7IGm4qA+cABrgFeB44\n4n5+IFj3G8CDwGPAhHvt08DPOnjff3DTPmCLe+1MoA5cFiy3xu3jGxfyedy/M8Dngb1ACfgvYGOw\n7JuBfwcOA2PA94A1bt4K4BHg18AU8BRwVbBuGXhvm33YAuxbwP/B77njUHC/3wzsiS1zL/CdTtaf\n431+B9gP7AB2Bq/fBHwytuxO4Evd/vs8rn/r3d6Bk3mKFZxvAN8N5n0CeAW4GEgC7wYqwJuC5Q+6\nWkRiAe95GfC/QH8sCK5x+5OLLf8r4CPH8Hk+78LrQhcKW4EqcIGb/0vgM0DKnXkfAL7l5v0j8AP3\nesqtux9IdbAPW9xx+TYwCrwKDLVa1237BeDG4LVLXPBuBNLAWnec/qiT9dvsUxp4FrgeGA6DoMWy\nCWAP8Bfd/vs8npOaBsfuo8Bd1tpnrbUNa+33ge+6P3TvkLX2m9baZicbNMakXSH7pLX2cGz2CqBs\nrS3HXj/kagsL9RHgDmvtc9baqrX2bhdAm938AWDaWlu31k4AH7TW3hDMqwJH3Py7gdXW2noH7zsK\n7AK+CJztgvJPgW0tlv0AUAMe9i9Ya3cBH3avVVyYfd9ae28n67exzTVX5lsO4LNAztVCeoaC4Nit\nBW4LO6WA64Bzg2Xm7aCK+Utgr7V2Ie1+4870na9gzDJgGbA7NutF4Hz3723Ap40xzxlj7gKuCJa7\nHXgjsN8Y86Ax5vddrWhe1trvWWuvstb+2Fpbs9b+0LXBP9Ri8W3AjjBIjTGXA19x/QIF4FLgSmPM\nZzpZv8WxeB3wSdf2b8sYkzDG7HD7ucFaO97J5z1VKAiOXQn4aKxjKmOt3RgsU+10Y8aY1wN/4poc\nrRwAcsaYvtjrZ7p5C5Frtxv+H9bab7iOydtcbeQHxpjb3bz/dIGxBRgH7gR2GmM6CoMW9gAzrn4Y\nYy51YftYbNlPAI+7QCm7GsIOV0PrZP24rwG3WWtfbreAq6k9AlwLvM29Z09REBy7F9xZMWKMOfc1\nFIYbXb/AM+7S4K9dZ+BdxphHgWdcZ+Gbgve7AFgO/McC3+sAMOn6N/y2Eq6/4AX3+5nW2nFr7YPW\n2hvdGfPjbt4ARwPhcWvtVuCtwHrXfp+TMebjxpg/jL18kauNhN4DPGWt/VXs9XSL2ke2xVu1Wz/c\nl98ArgL+Ojjm24D17vc1btEHgEFgvbV273yf8VSkIOhcCVhjjBkwxmSAvwc+bIy5xhiTMsa8DfiZ\nax4ciy8Cv+nCxU8jwK2uI+wQ8JBrjpxtjDkD+FvgCWvtcxz9w/6cMeYr872Rqyr/E/DnxpgL3DX4\nm12ofMsYsxoYMca8zxiTNMbk3f684DbxpNuPPhcgb3Xt9bZn1UDShdvl7rhd7QLm7thyb3Z9CXHf\nBq4LjvvrXEj9SyfrG2POcc2d33J9Imtix/yrwNP++BtjbnDNot/ttebADN3urTyZp1gv++Wuh34S\n+G1Xjf4r98dfcp1WHwvWnXGVwS7g8mGwfHTVwP1eBO5z1fEJ1wl2Ruw9H+vw8+TdJcqX3fZ+7K94\nuPnvdz3p066X/3vA6928i4Efun2YcJcP3x2sO9flQ3/Z9UV33Pa5IDCx5X4GfLbNNj4O/MJdutzn\nxlwUO1kfOM8dhze12fZw7PLhvwWXjcPpiW7/fR7PyVg9oahnGGPOBf7GWrulg8VFImoa9JbNbrCL\nyIKoRiAiqhGIiIJARNxY7K4wxqhNInKCWWtNB4upRiAiCgIRURCICAoCEUFBICIoCEQEBYGIoCAQ\nERQEIoKCQERQEIgICgIRQUEgIigIRAQFgYigIBARFAQigoJARFAQiAgKAhFBQSAiKAhEBAWBiKAg\nEBEUBCKCgkBEUBCICAoCEUFBICIoCEQEBYGIoCAQERQEIoKCQERQEIgICgIRQUEgIigIRAQFgYig\nIBARFAQigoJARFAQiAgKAhFBQSAiKAhEBAWBiKAgEBEUBCKCgkBEUBCICAoCEUFBICIoCEQEBYGI\noCAQERQEIoKCQERQEIgICgIRQUEgIigIRAQFgYigIBARFAQigoJARFAQiAgKAhFBQSAiKAhEBAWB\niKAgEBEUBCKCgkBEUBCICAoCEUFBICIAqW7vgJx8hoaGMMawevVqLr30Uqy1s6Znn32WkZERtm/f\n3u3dlePAWGu788bGdOeNpaXh4WHOO+881q1bR7VaZcmSJSQSCZ544gk4+v8V/TTGsGbNGtLpNMVi\nkUajwZ49exgZGWF4eLjLn0RC1lrTyXIKAmFoaIgNGzZw1lln8dhjj1Gv16lWq1QqlbbrJBIJMpkM\n2WyWTCbDmWeeSX9/P08++aTC4CSiIJB5DQ0NcdVVV5FIJHj66acplUpUq9Xo7I8r8GFtwGs2mzOa\nCqlUimKxyNq1azl06BB79uxRIJwEFAQyp+HhYTZs2BAFwOTkJLjCnkwmSSQSJBIJUqnUjADwyzQa\nDay1USA0m03q9Tr9/f0MDAywfPlyXnnlFbZu3dqlTygoCHqL77zL5XLRa9Za6vU6jUZjQWfeoaEh\n3vKWt/Dcc88xMTERFfJcLkcymZx19vd9Al6rUPB8GDQaDcrlMsuXLyebzapTsYsUBD1iaGgoao/n\n8/mo4Pn/t2azyZEjR6jVavMWtqGhId7whjewb98+SqUSxpjorJ/JZOYNgfi8VprNJs1mk0ajwdTU\nFGeccQaDg4Ps3r1bTYUuUBD0iOHhYfr6+kin02SzWQgKoW+f12q1qABOT0/TaDRmhcLw8DD9/f3k\n83leffVVjDGkUqloSiQSM7YdF68VzFVT8PvSbDaZmJjg7LPPJpvNsnfvXtUMFlmnQaABRSe5QqHA\nkiVL6OvrI5/Pk8vlZvTWZzIZcrlcNA0MDDAwMMDtt98ebcOfidetWxc1B3wtIJ1ORx2CrWoAAIcP\nH2Z8fJzx8XHGxsZmzPO1inD9ZDIZBczAwADVapXR0VHOOusshoaGFuGoyUKpRnCSu++++6LCmkwm\nIWgWNBqNqBruO+z8a/V6nUqlwvT0NNZarrjiCnbt2sX4+DjpdDqaaNEECP8mpqeno47DsNCHtZNw\n/fh2ms0mk5OTDAwMkMvlOHjwIJOTk6oZLJJOawQaWXiSSyaTrFy5kmKxSLPZpFKpMDY2RjKZjKrf\ntVptVhD46v7U1BSrVq1i9+7djI+PR7WBdDo9qy8gflI4fPgw+Xw+CoLwzD8xMUF/f/+sEGjVhCgU\nCjQaDWq1GitXrpxzfIJ0h2oEp4C7776bSy65hFwuFxWocrlMqVRiZGSEFStWkMlkoiDw0/PPP082\nm2XJkiWMjo5ijCGTyVAoFKBNTcBP4+Pj9Pf3R7WReBgkEgmazSbVanXWWIN488IHVrVapa+vj2Qy\nyejoKNu2bVvkI3n6UY2gh2zdupWHH36Y888/H1yB9VXzc845h40bN0bLPvroo6TT6ai5cMEFF/Dy\nyy9jjCGdTkeXCONVeWvtjFqBXz4eBD4E/JWMsbGxOZsHBIOSEokE1loajQb5fH6Rjp50Qp2Fp4jr\nr7+eer0e9RX4zr5cLseDDz4YLbdp0yY2btwYFUzfV4BrZoRBEJ8ICrFfNryy4JsUqVSKXC7XstkQ\n7zj0nYfJZDIKr0QiQTab5bbbbuvKsZTZFASnkJGRERqNxqww6O/v55FHHuHLX/4yuKsEzzzzDP39\n/Rw8eJBqtUomk2kbBMQ6/fzZ3r+HL/zhNDAwQCaTmTcEwnm+XwOIrnio0/DkoCA4hWzevJmXXnqJ\nRqMx44ydzWbJ5/OsXr2ae++9F1zBzmQy1Go1iFXP5yqsfvIjDbPZ7KwQ8JcxDxw4QCqVahswrS4r\nhqMX/WVQ6T51Fp6ifvKTn5BKpaLhvLVajVqtRqVSYdeuXQCsWrWKUqnE+Pg4hUIhKsjxfgIv/Fvw\nfQbnnntudDZPJpNR4d23bx/1en3GzUfthO/TaDSi16anpymXy0xPT3PrrbeegKMk6izscZdddhm4\nzsGVK1dGVfinnnoqKsR9fX2Uy+UZbX1/Q1G7kYHxM3qpVCKXy0WXI+v1OuVymVTq6J9OeONRu0CI\n1wr8VQ0/rNmPj5DuUdPgFLdp0ybq9TqpVIof/ehHUQiE5uogjBd8P/kaAMENTrVajWq1GjU3WoXH\nXNs2wZ2N8ebNHXfc0YWjJ56CoAdcccUVjI+PzzobT01NRfcQ+J+0KLjtLg+GYwX8g0oqlQrVajUK\nnIWEQPjT1zLCJod0j4KgR2zYsGHW4KBSqTTr1uJOC23YdPA1An+LsQ+cePB0UsvwgZTNZqMQCGsf\n0h0Kgh4Rv5nHuIeH+LOvtbZlIZ9rTIHn2/7t+gIW0uTwg4p8n0MYBDt27FikoyVx6izsMfEe+mQy\nST6fp1KpzDrrM08hxg0PjgdH/P3Cfol4B6Rx9zb4963X6zPGNIS1i3q9vghHSFpRjaCHNRoNSqXS\njDNx+NyBuWoBtCj07bQq/OFVAv/wE78PuVxuVn9E2GyQxacj3yNaFVp/OzKuTe6Xma+JMN92273/\nXCEQ9gGENQQTjDpUP0H3KAh6mL9MV6/XmZycbDmqcL6mQSdarRteEfAFf+/evRSLxZZXJ4zGE3SV\n+gh6RHjXIMFZ39/t558dQFBwaVOtD39vp91yJvYUZF/gy+Uya9eujQYUhf0Vvh9CTYPuURD0CF/o\nw+v7vjCGDysJ59GmQM8VGO1+er4vIHwcur8Dsq+vb0bHYjwEFATdoyPfQ8JCHl6WSyQS1Go16vV6\nNL/dXYXxgtzJFN4Snc1myWazFAoF+vr6AMjn86xcuTIa09BqbIG/41FPOu4O1Qh6UKvr977G4DsQ\n43cCzre9+M9WowUTiUT08BPfHCiVShQKhWgMQqvOSb+NkZERCB622i4U/Ot+ewqP1053H/YIXxhM\n8BTh+Og9fwYuFApYa9mzZw8XXXTRjOv53nxNhvj9C37b2WyWZrNJuVymXq+zdOlSCL4izTdT/LMW\n/WjFAwcOUC6XqVQqlEqlWZ8v3geCq2msX7+earXK2NgYe/fu5eabbz4hx/dUpbsPTzNhQWk3+TOv\n7y+48MILKZfLUZU+vi1a9Bf43+PVfH+VoFKpMDo6yuDgIMViEeNGOIYDj1p1UPrHqzWbzSgI4p8J\n1weRTqfJ5/Pk83mstaTTaVasWMGyZct4/PHHOXToEDfddNOiHPdeoRpBDxkeHo4KVasaga8V+Op7\n+GwC/3s46tBrVSOIP8vQP2E5fM4hrjCHtYBwCmsEhw8fplKpUC6XmZycjO5wDJsTy5Yti7bvH5hS\nKBQoFArRpUff9PnpT3+qJoNqBNLJOAHfZ+CvJpRKJY4cOcKLL77I+vXrZz27ID75OxN37tzJunXr\nGBwcnPX9jHPtk3+tVqtFD1nxBd0POfbLZbNZBgYGZj1H8ec//zmrV68mkUgwODgYPQ7t4osvXuQj\nfmpTEPSY+W4PbnW7Ma5A5vN5+vr6GBwcnLFcvPASjA7M5XJcd911s/YhrlXTwP87/N5Ff7kzlUpR\nq9VIJpMsXbqUJUuWMDAwMOP7GAAuv/xyCL7E9cCBA+zfv5/ly5efoCPcm9Q06DHDw8PRg0F99Tne\nPIhX68NmQTwo4sOB4/0NtBhLEN5I5JsG4R2M4fcc+O9u9A8+qdVqTE1NRUOj8/k8xWKRYrEYXX2o\n1Wq8613v6sLRPfWoaXCamu/5gaH4WT4+71jfnxYdjq32qdFozLoHwvc3hM8tKBaL0Ze7vOMd7zim\n/ZK5aUBRj9m+fXt0qS7Uqrc+Pm+uZeZyrLVK/70IfkCS/+r3vr6+6Mtfly5dGi2nEDhxVCPoQfV6\nvW3h7KSwt7tqcKKY4P4EP+TYN2t8beLKK688oftwulONoAdt3759zjDwXmsBjz/+vJPlw6aD//JW\nHwS+XyOfz0dPSa5UKrz97W9/Tfsp81NnYQ/7whe+QDabjcYVhA8KjY/1b9dZGA4canUVgg46C+Pj\nB/yt0ddee21XjsvppNPOQtUIetjExEQ0mGchZ+9W8+daZ75th8Hgg0BfjX5yURD0sO3bt1Mul6PL\nd2EgtHsScbxQt/q91bpzLRvWCvw3M4Xf4CzdpyDocbfccgvVajX6erJ2YTDXZcf5zvLx11tNfujv\n2NiYQuAkpD6C08Sdd95JJpMhnU5Ho/Di9x+0eoRYu29JavVgEy8eAI1Gg2q1yjXXXNOFT35667SP\nQEFwGvr6178ehUL4XMFWjxjrpLMwFA+ARqPB1Vdf3ZXPKQoCmUc8DMIHirSqEcx130HIDyn2Vwbe\n+c53Lvpnk/+nIJCO3H///bNuWT7WIPB3DDYaDTUDThIKAlmQhx56aFYzIXycWbu+gXh/wKFDh7jh\nhhu6/GnEUxDIMbnnnnsoFoszagitagQEzYByuczmzZu7vevSgoJAjqsHHnhgRkfijTfe2O1dkg4o\nCEREQ4xFpHMKAhFREIiIgkBEFAQigoJARFAQiAgKAhFBQSAiKAhEBAWBiKAgEBEUBCKCgkBEUBCI\nCAoCEUFBICIoCEQEBYGIoCAQERQEIoKCQERQEIgICgIRQUEgIigIRAQFgYigIBARFAQigoJARFAQ\niAgKAhFBQSAiKAhEBAWBiKAgEBEUBCKCgkBEUBCICAoCEUFBICIoCEQEBYGIoCAQERQEIoKCQERQ\nEIgICgIRQUEgIigIRAQFgYigIBARFAQigoJARFAQiAgKAhFBQSAiKAhEBAWBiKAgEBEUBCKCgkBE\nUBCICAoCEUFBICIoCEQEBYGIoCAQERQEIoKCQERQEIgICgIRQUEgIigIRAQFgYigIBARFAQigoJA\nRFAQiAgKAhFBQSAiKAhEBAWBiKAgEBEUBCKCgkBEUBCICAoCEQEw1tpu74OIdJlqBCKiIBARBYGI\nKAhEBAWBiKAgEBEUBCKCgkBEUBCICAoCEUFBICIoCEQEBYGIoCAQERQEIoKCQERQEIgICgIRQUEg\nIigIRAQFgYigIBARgP8Dgs6M0ev77boAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267360935888" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nrjLOdPQ9nwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267790171216" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267360973264" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267360479440" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nB2h30LjPguQAAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267360183056" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267759762576" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nCAD8H+kNZdOpqJ32AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267359577808" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAH0NJREFUeJztnXuQJEd957+/7p5+zGNnhmV3tas9\ns6tgJWMZY2Sbs60zNsacTw64kIWkA0lwiwJJxisJTogwljDTe3EYmyBM2MKckYGQCLEWoFgH8hqf\nHcZgX8gieB4nY4VZsKV9sDuz0s6jd6Zf1ZX+g8wiOzerurqnZ7pn5vuJqOjuquqqrOrOb/4emVmi\nlAIhZGuTGXQBCCGDh0JACKEQEEIoBIQQCgEhBBQCQggoBMmISE1Efn3Q5VgvRORLIvLhQZeDrD8U\nggSUUkWl1J/jB5Vkn4jctNbnFJG9IvIFEVEi8kLP9mkReVRv/2lnm4jI74jIcRFZEpF/FJGfX+sy\n9xsR+c8i8mURqYjIWRH5MxHZgx/+DkpE6lqozXLEOcbVIvKvIvJPKc73iyLyf0VkUUTOiMhhERFr\n+6iI/G8ROa/L9BcisnuNLn8gUAjS83oAayoEIvJKAF8BcDpm+48B+CaA5ZhD3A7gNwHcCGAXgMcA\n/KWI7FjLcvcTEbkcwF8A+BMA0wBeDuBSAB93dr1CC7VZbrKO8Q4ARwA8neJ8lwH4vF4uAfAqff/u\nsnZ7EMCLAVwJYD+AeWf7xkcpxSVmAaAAXA/gPQBaeqnpP6YA+C0A/wJgRb++yfruQwAeAfA4gCW9\n7j0Avp5wvusB/CSAX9LnfqGz/VUAfhnAPr39p53t/w/Afc667wJ4R8rr/RKAD1uf/zuAp/T1PQvg\ntwGI3rYDwGcBPAfgAoCvAniV3pYB8PsATunvfhfAIeu4fwPgQzFleDGAm5x1dwM4o9+ba9+XcB3v\nAPBCAGUA/9Thmn/THNta998A/LN+/yMAQgAvHvT/cU3/64MuwDAvRgjUDyv2MWvbIQAnAbwUQBbA\nrwGom8qp939eWxGZLs/rFQJr+0VCAKCoheq/OPt+BsCnUp43EgIA12jR+1UAOQC/CGAJwJv19gcB\n/DWAbXr7ndqSyelrPqPLKQCuBrAI4KVd3gcBYKygDzrX/qgWp0UtuNs9308jBIcAzDrrXqMr/yiA\nmwHMAbgDwDP6/UMAJgf9/+znQtegd+4A8IBS6imlVEsp9XkAxwActPY5r5Q6opQK16E8L9At8byz\n/rxuHbvldgCPKaX+WikVKKX+Xrsab9DbpwA0AKzo7R8GsFcpFehtLQAX1A94AsC0UuqptCfXblJD\nWyRf1tYXtNh+WVsVlwP4GQA/CuDPerhGAPg/ACZF5D4RKYnIPgD3aBGaBrAXwASAn9XW2i/ocz7Q\n4/mGEgpB71wO4H/ZASsAr9OmpOHfBlg+g+gWtFsuA/DPzrrv6vUA8Hu6YpwWkUdE5I3aMoKulP8G\n4ISIHBORu7U4pEYp9Q8A8gB+XPvmj+n1Z5RSP6eU+oRSqq6U+g6AewG8RkQu7fYilVLfA3Cddsvm\ntAX1sN7c1PevCOAepdSCUupfAPwugBtFJNvh8BsGCkHvVAHc4QSs8kqp/2rt01jH8jyvW2G39X8h\ngNkejlf0rIsi6Uqpb2hROAhgAcAfAfiSiGSVUvNKqV/Q7sTXAbwNwNMi8qJuCqCtiacBvB3Atbq1\n9vE9/dpTJF8p9Xml1FVKqQml1Cu0W1PT9/Ssvq+L1leeAVAAsL2X8w0jFILeOa5bxAgR+ZFBtRJK\nqTqAbwGIUoo6BfYzAP6xh0N+V8c/bK7U1w0RmdLn/Sul1J0A/qOOBfyEiBREZEIp9VWl1AyAn9AB\nxes6nVRE/oeI/K2zuqBfmyLyKyLyP53tP6atnu+hS0RkSkRuFZERa/U1AJ5QSrUAfFtbOva92K8b\ngnPdnm9YoRCkpwrgP+g/Th7AHwO4VUReIyI5Efk53fq9boBl/GMAh0Tkp0SkpP3qgg6sQUR+XUS+\nnvJYnwBwna54ORH5FV2RP6G3f1m7RmMiktFCUAdwQlsHR61c+49qf/t4ivP+HYBXisidWlAuAXAY\nwFeVUqd1luLdInKHiORF5IDOUBxRSrnxES8i8kkReY/+2ATwB/qYWRH5JR1A/H38QOi+CuBJAH8o\nIjtFZL/OnnxCqU00mcego5XDvDhZg/+kfcgKgJ/SZvJv6z9+VacPf8P6bluWQaVLH/6NNkkb+tw1\nvbxHb/9T/bmut9f15z+1jvFbOm1X05bAVda2gyaVGXN+N314l44TXNBBOzs9+lIAX9SZhCWdPvw1\nvW1KR/Kf0+nD4wDuda7Tmz5UP4zaf11fw1ktZHut7a/T2y/oVvkPAYxZ2819C3T033x+Zcx1vgrA\n/9e/43EAtzjluQTAn+vffkEHCkuD/n/2czE5YbJFEJG/U0r98qDLQYYLugZbCBH5SZ17J6QNWgSE\nEFoEhBAKASFE9wsfCCJCn4SQNUYpJSl2o0VACKEQEEIoBIQQUAgIIaAQEEJAISCEgEJACAGFgBAC\nCgEhBBQCQggoBIQQUAgIIaAQEEJAISCEgEJACAGFgBACCgEhBBQCQggoBIQQUAgIIaAQEEJAISCE\ngEJACAGFgBACCgEhBBQCQggoBIQQUAgIIaAQEEJAISCEgEJACAGFgBACCgEhBBQCQggoBIQQUAgI\nIaAQEEJAISCEgEJACAGFgBACCgEhBBQCQggoBIQQUAgIIaAQEEJAISCEAEBu0AUgw8n73vc+ZDIZ\n5HI5ZDIZZDIZiAhEJPoMAIcOHRp0UUkfEKXUYE4sMpgTk0Te//73I5vNRpV9ZGTkIiEwYmDeA8Ct\nt9466KITD0opSbMfhYAAAMrlMrLZLCYnJ9uEIMkisD/n83kopXDttdcO+lKIRVohoGtAIkQESilk\ns9lIAHK5XJsFYF6z2SxEBPl8Hvl8HrlcDq1Wa9CXQHqEQkAiMpkMwjBEJpNBNptFNpvFyMhIVOmN\nJZDNZlEsFpHL5ZDL5ZDNZgEAzWZz0JdAeoSuwRbk0Ucfxe7duzE6OgoACMMQQRDgi1/8IrZt24Zi\nsYhisYhCoRBVeGMdGIEoFAqRdaCUQhAEWFhYiGIGSimEYYhqtYobbrhhwFe8daFrQCIefPBBvOQl\nL0GpVAIANBoNBEGAarUK6ErbbDYRBAEuXLiAXC4H00AYN8Fu/c0CLSKNRgPPPfcc6vV6dDzzmslk\ncPToUWQyGbRaLbz+9a8f0F0gSdAi2GR88pOfxBVXXAERQbVaRT6fx65duzA5OYl6vY6PfvSjUStv\nWm87GwAAi4uLyGQyGB0dxfT0NPL5PEZGRiIhEBFs374dpVIJ3/nOd3D+/PnY8oRhiEKh0CYO5nV0\ndBTFYhGVSgW33XbbutyfrQazBluMhx9+GFdccQXCMES9Xkc2m8XevXuRz+fxsY99LIrsGwGwRcCH\nEQMjBLZFkM/n8bKXvQxf+cpXsLi4eNGxfMc0rkKr1YKIIAzDaFuhUMDIyAiKxSJuueWWNbpDWxMK\nwRbiySefRBiGqNVqUYBvdHQUjz/+eNSaw9Py+7Bb7Eqlgm3btkUV1VgFExMTAICTJ09GQUT7+Ia4\n8xhRWF5ebjtfLpdDoVDAnXfe2ce7s7WhEGwBHnjgAbz85S9HtVqFUgoigmKxiC984QuRae+2/nbl\ntH/7MAyjCqqUglIKtVoNO3bsQKFQQKFQiEQln88jDEOcOHGiTVziLI04QQjDEGEY4vz5820Wws6d\nOzEyMsJOSn2AQrDJ+fjHP47LL78cKysraLVayGazePLJJyMXYGRkxFs53d/bVPpWqxUFDe004J49\nezA6OorR0dFIEIyFcfLkSdTr9bZK7Kv0SRYILEE4e/YswjCEiGB0dBQ7d+7EwYMHV32vtjIUgk3M\nkSNHsGfPHlSrVQRBgFOnTmF2djYy3U1FtU12H0YEjCUQBEFUKTOZDIrFInbv3o3x8XEUi0Xk83kU\nCgVks1nU63UsLi5GZWg0GpE1YY5tpxINncoCLTCGqakpTE5O4i1veUvf7t9WgkKwCfnsZz+Lbdu2\noVarIQxDnDp1CpVKpS3Hb1sARgiSML+/+Y7pXpzP55HNZjE2NhZZGCZtaIJ9YRhGaccgCNBqtRAE\nQVultt93wpTBHOPZZ5+N1r/oRS+iGPQA+xFsQiYnJ7G8vIwwDHH69GksLS0BQFRJ3aBdGjPddhvs\nnoP2gCNT6U2lNi6GcScM5ru2leG6I0miYMqSz+dRr9exb98+PPPMM22iQNYGzkewQZiZmcGFCxcQ\nBAFOnjyJ+fn5aFyAqbi+wJ1voJB5b1d8u7OQXaGNCJhWv9lsotFoRJ2SjDth8I1QdAco+crllq1U\nKkFEsH//fkALyKc//ekB/gKbGwrBBmFsbAzNZhMnT57EwsJCrAj4BME3ctBu+e2xBfZcA9BmeqvV\nioKIjUYjcgdarVZbXCBJiDoJhG+fUqmETCYTiYGIUAzWCLoGfaRcLmNsbOyiFtf11X2mspu6u+ee\ne6J9ZmZmsGvXLjz//POo1WqANp/jrAHEuAe+NGKSaJh9TPDQuAW+LIT7ihTZgjjXxZQBAIrFIur1\nOi677LKorwHpPwwWrhIzjt9E1e1hu7YIdKoUboDNFoW5uTns3r0b9XodCwsLCMMQxWKxzZc3ff/j\nhMD36sYHOrXa7vc6XYO93t0v7hhiDXE2GJcEACYmJrCysoI3vvGNifeT/AAGC9eBD3zgA1FHG5NW\nc/3dpIpj8EXZzefjx48DAGq1WlvO3jXvO1kESdYAnFSj3dKbgJ+7PzqIW6dtvu1xLoMpm4lljI2N\nJd5P0j20CHqkXC5j+/bt0cQcduTebVUNSZXDbUGVUnjqqaei70xNTaHZbGJ5eTnK8ZuovitA6EEI\n0r73vfaC+103hmELgFIKjUYjsoLCMMTS0hLe8IY39Hz+rQItgjVkZmYGorvz+vL3bvrM/KltH9tt\niV3sNJ3okYSFQiEaIpxkaXRyC3zvu6ncbtnS4Kv4vvLGCYEZQ2E+5/P5VOcl6aAQ9MjY2FjkDoju\nYFOv11Gr1drMe7O4UXnTkidZEnZFC4IAO3fujNJ2Jq3nG03YTXzAJu1+Np38fd97e12cK2AWI6jH\njx/HVVddFX0epBCUy2WMj49j165dOHDgQNvvb1KtJqNSrVbRaDRw0003Day8aaAQ9IA9OYf54ZvN\nJqrVKt7+9rf3dMwPfvCDURfhXC6HM2fOtFkYZtKQ7du3Y25uri2g6FZ8m06uATpYAd20+r5jJYmB\nb3Zk0cFCs97ERA4cOBB1bjJi8ZnPfAY33nhj6rL1g5mZmWhQ1J49e7y/g5nRyZS9UCjgc5/7XCQO\nQRAMnVtDIeiBbDaLiYkJiEjbEN/x8fGej3nvvfe2fS6Xy4BTERuNRjRu30TRO7XIaYTAXe/u79s3\nbl3a93FBVbGyBiKCJ554Aq94xSswOTnZZjGEYRjd+/WiXC5jdHQUpVIJuVwOZ8+eRavVwv79+y/q\nfWkHfFutFlZWVi4a0DVMUAh6oNFoQCmFqampyDK48sor8e1vf7vv57IrT7PZxMrKSjRuP5/PY2Vl\nBWEYtk0walcYpDD510IE3ErvtvpucNPtd3H27Fns2LEDr371q9tcBFj9GtbDPSiXy9GQbjOj0tjY\nWNv8DLVaLRrv4YqbKffzzz+PEydO4K677lrzMvcChaAHzA9tKmMmk8H8/DxyuRwee+wxXH/99Wty\nXtO/31SmZrOJUqnUNtDH1+kHHksgbeXuVgx88Ym4HoS+7sUigvn5eVxyySVt06m5x04Tv1gtpo+I\nPQzbZIjs2Z0NZtCV3S379OnTuP3229e0nP2AXYx7oFwuRxN1mj/k4uIicrkcisXiqo8/MzPjXd9q\ntS5agiBAoVBoK4tbKX1djH3vffvHLb5xC3bsxJ701F1vT5Vux0VOnDgRxUF8QVSDXYYjR46s+n7H\nYfosmMCwSRWbXp1ujMN0xW40GqhUKjhz5syGEAHQIuidpaWlqBIaE9xYCUePHsV11123Jue1BwLZ\no/vy+by3VY4TByRYC4Y4qyDpGGkWWzhEBKdOncL09DT27dvXNkOyfc12mexlrdwD0128VCpFHcZs\nC9DtOWqGZNdqNSwsLGy42ZUoBD1Sq9XQbDYvitqbYN5qkJgcvf3ZngjUPGHIbqHiBgLBM2FJkhB0\nEoM04hMXvzh79iymp6exd+/ettbfxu2z4Lvf/cYEak1MwAiB6cBlYgGwhLnVamF2dnbDzpnAnoWr\n4MiRI3jBC16AiYmJaGowMzKvWq1ieXm5a8vA/Al92A8ktRe3h6F5tYNXphKZ6cjGx8cTKzV6bPl9\nbsXi4iJGR0ejcrpuCRwBiutybeY/MNZQq9VCvV5HtVrtW1zGdBabmJjAjh07otiA7aqYsgRBgHPn\nzg31dGrsWbgOzM7ORi2G7fsqpVAoFNrG6feCbRUkVT5YLROsSmUHD2FF721z2q5Q09PTia28fWy3\nwn//+99HLpeLUmv2Mj09fVFvQfuYaYmzdPrlHhgRMBXfDCJzYxWmz8j8/PyGcwHiYLBwFSwsLGBp\naQnVajVqrUTnwU2K79ixY6mPl2QN+NwEX6WF08XZzWm73zUBzqmpqWi7b7Sg3QqbyLh97D179mDX\nrl2Ynp7Gtm3bMDY2Fo2H8FWm1eBzXx5++OFVHdOIAPQQbyMEbm9QY1FduHBh04gAKASr4/Dhwzh9\n+jSWl5ejeQTtQJgRg8cffzzV8eLctDgrwN7ue29X4E7C4Eb/3eswEf58Ph9ZQWadvfi6UsfFH5JI\nE6uw3ZF+xGWgewGaa7RdLfsRb8vLy3jTm960qvMNGxSCVXL//ffj3LlzqFQq0aQh5s9pngpknjnY\nCbdFd7cluQZxJr3BN/7BJwpJ54vrEuyr1J0q+mpiU77rNCnUXjDpWvNwVyMG9lgQWMI6bN2D+wGF\noA8cOnQIc3NzqFQqbSMOTWuaz+c7WgWuW+BrBeNIammTttlC4Osem0Y04oSkX0HoTtdmxyxWew43\nTWjcGrF6CBqx32wwa9BHZmZmcPXVV2NiYiKaUsuY5rVaDY1GA/V6Hc888wzuvvvutu/GxQfslthk\nAdzOLO6sSLZF4kbyXZO9U2uf1CsQCZYKrApmV9I07oE7y5FPrMx7ezr1er3e1dOWzT0X/UCV8fFx\njI+Po1QqoVQqYWxsDGKNLJyfn99wMyOlzRrQIugjhw8fxvz8fDTbsNKPBTeV2Pie+/fvxyOPPNLV\nsTvFB+IqmO99L6b8oOlk6RhBTEO5XG7rvWlbAiYOYtLBJlVYqVQ2nAh0A4Wgzzz99NN47rnnsLS0\n1JZJMGJgOhxNTU3h6NGjQIpsQZqMAbp0C9aTtXAT7HVJsQqXcrl80W9ihMB9/Du0RVetVnHDDTf0\n5RqGFfYj6DPlchnlchkHDhxAGIaYnJxs+2PZrZaI4CMf+Qjm5uY6Hjftn73bCH3aCpR0rvXEDqim\nCVrCcQF8YyTs6ebsaefsVOFmhzGCNeShhx7Crl27IjEweXh7wFC1WsU3vvEN7/fdP6yJEbiLnaO3\nfX3fxKbdDDRKGnzkpgWTYgRxgc9uYgSwnthsxwjMbEDmfj777LPR4B/bIjOLO/mr6HkkzDwDpVIp\nmnkqCAJUKhVce+21fftPrDeMEQwBBw8exKlTp6LHfpvKaY/OKxQKqU3nTq1fWmuh075xFbff9DOF\naLj00kujim0vpu+D2//BVH7bGjAC0Wg0NrQIdANdgzXmtttuAwB86lOfisYl+MYCwHkgqQk0dqr4\naVphpBCB1QhMN7iDqXyffedXnqcr29dqWvggCDA+Po5CodDWAxJWPwClH5RixKBYLEYxApOBCYIA\n11xzTd+ue9ihRbBO3HzzzVEgsV6vt3VHhuPzoofKOgjiWvRu+xUkdWzqhHs/7DEOdstvr3MtA7sD\nkXEfgiDouiwbGQrBOnLPPffgm9/8JmZnZ1GpVBAEQeLYe5ukjMBq9u0nvs5GafbrliSRdCdFcYXB\nThMagbAtAZMuNBPPbBXoGqwzhw8fBgB86EMfwr59+/Ctb33rolGGNkkWwHpVeN/cCL51g8SUxbTq\npnzuiEzXerC7EEMHJE2QcCvBrMGAOXbsGL72ta9dVLHcjEFc1kCcnoX2q69noTizBPuyCe56eOIR\ncZmCbiY96YT93/R1dTZZGHuOQNu0d4dhu+e03QdYswwtLS2t2byT6w2zBhuE1772tUCHAUeGQcQH\n0jYUbqqv07G6aYA67esKke0O2K6Cbz5FM7TYpCJXVlY2jQh0A12DISLO3O4mA+DLHvRyfjcyn1TO\nJNch6TidytIt9hOQMs4U6Ab38XTQT5EyYwluueWWrs+7GaAQDBGrae3jvtutL99rxe3m+LbY9Ds1\naeNzbewBUGb/RqOB5eXlLSsCoGswfHTTuWgQpMkMdJM+7HXftN9zYy1mP9OfoNVqoVarrfuj04YN\nWgRDxjBF4juRpnNQWtci6RxpyoEUwUhbAGBlCM6dO9fxHJsdCgFJzWpN+dW4Be7cBL7tGeshqb7t\nbrbBjEm44447er6mzQKFYMhwg2yd9lvNObrZH04rGxdYtMvvCxamPXfaDIMtDEop1Ov1i9KatgDU\n63U0m03Mzc0N7XMIBwGFYAPg88vdSphkbq+mQ1C/OhPFHQcxU6jFHSPus6nopi+BmxkwFsD58+ej\n8R/kh1AIhoy0vnMcaf1yJFTEpG1JcQCfNdCvGIHrGvg+NxqN6LHj7hyGQRCg2WxSBGJg1mAISJqh\nyFcR4rb1iq/XXtrvdXuebr7b6frs9cYaWFlZaVuq1Sqq1SpmZ2fx5je/uavybiVoEQwx3Vb0NFH8\n1ZYlztePswaSvpdkMcSVwbeYLsbNZhPLy8toNpuoVCp473vf2/P1bjUoBENIXAwgbdR9NdH5Tsfr\nZXtSmdIERX372SlAs9x8880pr4i40DUYEsykmrCi72mfNYAULoTvc9rF9z33uGnL6Hvv0qnlt5/c\nZHz/lZWVPv8iWwsKwRBhhijD6hIbV9ls0vjQ6FD5OpF0zm78fd/7JNFI2mZEodFobPmegauFQjBk\nuIHDTi1zXGtr7+vSjRh0Eh7f+07mfKcy+I5juwJuXIDWwOphjGAD4FZ8N0jn8799lS4ucJgUUPRt\nSwoC+l59+/nO5V4zOoiAeebAZnsg6SCgRTCEuFZBUqwAHXLrSbECd30nnz2OuJY/7tyd4gm+8vtE\noNVqbeqnD60nFIINQicxQExQMG59WvcgybVIOm4nkUpzTjsW4IrAZn4g6SDgVGVDjGsZmDn33Qeb\nuFOYSYcHmfgebOKbOr3TelhBTft90uQoabs1u4s9UCgIAiwvL9MaSAGnKtsE+FwEN33msxSQwix3\nt3WyMtJYG2lM/E7ncFt9e2k2m2g0GqjVahSBPkMhGHJsMfA98st9n9Z16MY/d7/fydz3uQfu92EJ\nW9x12CIQBAEajQZThWsEhWADYMRA6Qk2fRaB23q6FapTq+ySptInHTNJBHxCFncdZs4AYw1QBNYG\nxgg2ELZ14JuN18QM4h6CmjTNedIDT5MWxMQJEBMjsElyNZT1gFPTe5Ai0D1pYwTsR7CBUFYO3jzp\nF1oUlDNjry+4F4ZhNLsvtGluz+Pno1PO3zeJiorpSxB3Te6rsQSCIIhEYCs8mnyQ0CLYoNjWgT2H\nv51BcB+Xbl7tKb3jsgbudiQ85ASe1r9TpsAWI9dFMJW/Uqlw/oBVktYioBBsYGZmZqJK5j7EI5PJ\ntKUbe3UNfOsR80QjOJYIOrgFxqpx4wMrKyucO6BPUAi2EDMzM4AjBq4Q+PofpLEI0sYIfK/uezdg\naAuBHRzkcOL+QSHYYhgxEJFIAGxRiHuGoq+TUZxFAI97gBRBQYObMTDPLTSZgSAI8Na3vnXN79VW\ngkKwhZmZmUEmk0E+n/daBD6Xwfdg1DSuAVIKADxCUKvVonjA2972tjW+K1sTCgEBnDiCqfCFQsFr\nKaQVAnEeHebD/l+5WYALFy7gXe9615pfO6EQkBhmZmYueiqwee+r/EmxAxtfFsCOBVSrVbzzne8c\n0FVvXSgEJBGTfjRWQi6XixWCODFAQo9B2wp497vfPeCr3bpQCEhXuAOcTOU3gUWfEJjW3ixjY2NY\nWVnB/fffP7DrIO1QCEhfKZfLUR+ETCaD++67b9BFIimgEBBCUgsBRx8SQigEhBAKASGEQkAIAYWA\nEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAh\nIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQ\nCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEE\nFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAI\nAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQ\nQkAhIISAQkAIAYWAEAIKASEEFAJCCCgEhBBQCAghoBAQQkAhIISAQkAIAYWAEAIKASEEFAJCCCgE\nhBBQCAghACBKqUGXgRAyYGgREEIoBIQQCgEhhEJACAGFgBACCgEhBBQCQggoBIQQUAgIIaAQEEJA\nISCEgEJACAGFgBACCgEhBBQCQggoBIQQUAgIIaAQEEJAISCEgEJACAGFgBACCgEhBAD+HZZAIBWa\nf/2yAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140267360608656" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhAD4/8ra93eprvotAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266491010064" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nEAIKASEEFAJCCAD8H19TE6W0UXZdAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266490568400" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQkAhIIQAwP8BFvVSR4ODOyEAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266490416912" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhBBQCAghoBAQQkAhIISAQkAIAYD/B2EIkQdyVavyAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266490120848" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266489824208" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQCEghIBCQAgBhYAQAgD/D/gMYMHD6wYuAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266489511376" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQiCEQEIghEBCIIRAQiCEAPj/H6FflwRh8HAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266489284432" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQIAAAEICAYAAAC01Po2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "140266489631952" + }, + "output_type": "display_data" + } + ], + "source": [ + "loop = tqdm_notebook(range(200))\n", + "for i in loop:\n", + " optimizer.zero_grad()\n", + " loss, _ = model()\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " loop.set_description('Optimizing (loss %.4f)' % loss.data)\n", + " \n", + " if loss.item() < 200:\n", + " break\n", + " \n", + " # Save outputs to create a GIF. \n", + " if i % 10 == 0:\n", + " R = look_at_rotation(model.camera_position[None, :], device=model.device)\n", + " T = -torch.bmm(R.transpose(1, 2), model.camera_position[None, :, None])[:, :, 0] # (1, 3)\n", + " image = phong_renderer(meshes_world=model.meshes.clone(), R=R, T=T)\n", + " image = image[0, ..., :3].detach().squeeze().cpu().numpy()\n", + " image = img_as_ubyte(image)\n", + " writer.append_data(image)\n", + " \n", + " plt.figure()\n", + " plt.imshow(image[..., :3])\n", + " plt.title(\"iter: %d, loss: %0.2f\" % (i, loss.data))\n", + " plt.grid(\"off\")\n", + " plt.axis(\"off\")\n", + " \n", + "writer.close()" + ] + } + ], + "metadata": { + "bento_stylesheets": { + "bento/extensions/flow/main.css": true, + "bento/extensions/kernel_selector/main.css": true, + "bento/extensions/kernel_ui/main.css": true, + "bento/extensions/new_kernel/main.css": true, + "bento/extensions/system_usage/main.css": true, + "bento/extensions/theme/main.css": true + }, + "kernelspec": { + "display_name": "pytorch3d (local)", + "language": "python", + "name": "pytorch3d_local" + }, + "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.7.5+" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/data/bundle_adjustment_final.png b/docs/tutorials/data/bundle_adjustment_final.png new file mode 100644 index 00000000..61624789 Binary files /dev/null and b/docs/tutorials/data/bundle_adjustment_final.png differ diff --git a/docs/tutorials/data/bundle_adjustment_initialization.png b/docs/tutorials/data/bundle_adjustment_initialization.png new file mode 100644 index 00000000..4c99c206 Binary files /dev/null and b/docs/tutorials/data/bundle_adjustment_initialization.png differ diff --git a/docs/tutorials/data/camera_graph.pth b/docs/tutorials/data/camera_graph.pth new file mode 100644 index 00000000..e610cf22 Binary files /dev/null and b/docs/tutorials/data/camera_graph.pth differ diff --git a/docs/tutorials/data/cow_mesh/README.md b/docs/tutorials/data/cow_mesh/README.md new file mode 100644 index 00000000..27c1a6e0 --- /dev/null +++ b/docs/tutorials/data/cow_mesh/README.md @@ -0,0 +1,6 @@ + +# Acknowledgements + +Thank you to Keenen Crane for allowing the cow mesh model to be used freely in the public domain. + +###### Source: http://www.cs.cmu.edu/~kmcrane/Projects/ModelRepository/ diff --git a/docs/tutorials/data/cow_mesh/cow.mtl b/docs/tutorials/data/cow_mesh/cow.mtl new file mode 100755 index 00000000..c3bc0543 --- /dev/null +++ b/docs/tutorials/data/cow_mesh/cow.mtl @@ -0,0 +1,9 @@ +newmtl material_1 +map_Kd cow_texture.png + +# Test colors + +Ka 1.000 1.000 1.000 # white +Kd 1.000 1.000 1.000 # white +Ks 0.000 0.000 0.000 # black +Ns 10.0 diff --git a/docs/tutorials/data/cow_mesh/cow.obj b/docs/tutorials/data/cow_mesh/cow.obj new file mode 100755 index 00000000..6fb82827 --- /dev/null +++ b/docs/tutorials/data/cow_mesh/cow.obj @@ -0,0 +1,12015 @@ + +mtllib cow.mtl + +v 0.348799 -0.334989 -0.0832331 +v 0.313132 -0.399051 0.881192 +v 0.266758 0.181628 0.122726 +v 0.229555 0.0663178 0.828702 +v 0.353623 -0.0486456 0.443969 +v 0.335878 -0.384495 0.425693 +v 0.305362 0.0307983 -0.00655663 +v 0.279611 -0.0552387 0.858547 +v 0.266719 0.10578 0.46681 +v 0.149341 -0.451522 0.166423 +v 0.12606 -0.162036 -0.185668 +v 0.114009 -0.358339 -0.0759521 +v 0.101546 -0.475382 0.663157 +v 0.240757 -0.435635 0.421981 +v 0.385825 -0.174501 0.180766 +v 0.358602 -0.37797 0.17897 +v 0.345953 -0.229705 0.664126 +v 0.316102 -0.419396 0.649153 +v 0.131961 -0.201382 0.951731 +v 0.0876766 -0.391182 0.901606 +v 0.161859 0.285356 0.303098 +v 0.177264 0.282839 0.0875537 +v 0.158786 0.0751889 -0.141343 +v 0.310974 -0.0974099 -0.0697762 +v 0.138236 0.191142 0.700393 +v 0.13061 0.109881 0.873657 +v 0.287544 -0.214549 0.864938 +v 0.25445 0.101336 0.680112 +v 0.34304 -0.0541165 0.672286 +v 0.369388 -0.0242775 0.205838 +v 0.273782 0.160332 0.273861 +v 0.36907 -0.228332 0.435279 +v 0.146074 0.206063 0.488052 +v 0.15689 0.317253 -0.0179554 +v 0.184529 0.181235 -0.238574 +v 0.229877 0.446038 -0.0428095 +v 0.326584 0.303676 -0.375494 +v 0.257915 0.488969 -0.517721 +v 0.187711 0.730295 -0.437134 +v 0.190442 0.122856 -0.437696 +v 0.271501 0.201979 -0.579853 +v 0.227961 0.337016 -0.641468 +v 0.323288 -0.645898 -0.0650069 +v 0.277559 -0.660659 0.872426 +v 0.15321 -0.671553 0.116597 +v 0.153343 -0.652512 -0.0628489 +v 0.129752 -0.680413 0.714233 +v 0.310744 -0.658159 0.12474 +v 0.270197 -0.670204 0.705429 +v 0.125665 -0.664371 0.877017 +v 0.264169 0.646946 -0.369897 +v 0.180359 0.68646 -0.148279 +v 0.263204 0.560375 -0.137191 +v 0.371765 0.683869 -0.321196 +v 0.432195 0.751246 -0.233457 +v 0.424574 0.680439 -0.150855 +v 0.379346 0.604049 -0.213075 +v 0 -0.192084 -0.196407 +v 0 0.505678 -0.563016 +v 0 0.340641 -0.665066 +v 0 0.0414775 -0.241591 +v 0 0.117615 -0.305384 +v 0 0.100384 -0.450564 +v 0 0.182587 -0.616155 +v -4.33681e-19 0.765067 -0.449072 +v -4.33681e-19 0.834757 -0.307668 +v 0 -0.434774 0.0615192 +v 0 -0.354126 -0.0677048 +v 0 0.326124 0.139538 +v 0 0.352207 0.0388631 +v 0 0.499175 0.0586613 +v -4.33681e-19 0.723906 -0.0597107 +v 0 0.816061 -0.189369 +v 0 -0.435249 0.726548 +v 0 -0.533724 0.415511 +v 0 0.301194 0.312719 +v 0 0.233342 0.49566 +v 0 -0.340037 0.891691 +v 0 -0.194995 0.971379 +v 0 0.220553 0.711025 +v 0 0.130478 0.891171 +v 0.164015 0.929339 -0.232094 +v 0.205905 0.915741 -0.313374 +v 0.15338 0.935554 -0.282029 +v 0.221786 0.905461 -0.256021 +v 0.115236 0.837896 -0.222054 +v 0.086327 0.812209 -0.211465 +v 0.172231 0.819312 -0.334104 +v 0.162464 0.791078 -0.351846 +v 0.0787362 0.822102 -0.294366 +v 0.102999 0.844736 -0.288229 +v 0.219399 0.754552 -0.28348 +v 0.199751 0.790382 -0.244881 +v 0.184684 0.762009 -0.196152 +v 0.279703 0.762439 -0.233186 +v 0.120311 -0.456517 0.243094 +v 0.111282 -0.477316 0.58188 +v 0.186164 -0.487701 0.417533 +v 0 -0.462404 0.208739 +v 0 -0.483948 0.606421 +v 0.17185 -0.0410977 0.94527 +v 0.106249 -0.0142167 0.968533 +v 0.107395 -0.0653463 0.975253 +v 0 0.00228925 0.987177 +v 0 -0.0756163 0.995507 +v 0.0517509 -0.0608359 1.02473 +v 0.0517951 -0.0798093 1.0112 +v 0 -0.0688251 1.04807 +v 0 -0.0952192 1.02642 +v -0.348799 -0.334989 -0.0832331 +v -0.313132 -0.399051 0.881192 +v -0.266758 0.181628 0.122726 +v -0.229555 0.0663178 0.828702 +v -0.353623 -0.0486456 0.443969 +v -0.335878 -0.384495 0.425693 +v -0.305362 0.0307983 -0.00655663 +v -0.279611 -0.0552387 0.858547 +v -0.266719 0.10578 0.46681 +v -0.149341 -0.451522 0.166423 +v -0.12606 -0.162036 -0.185668 +v -0.114009 -0.358339 -0.0759521 +v -0.101546 -0.475382 0.663157 +v -0.240757 -0.435635 0.421981 +v -0.385825 -0.174501 0.180766 +v -0.358602 -0.37797 0.17897 +v -0.345953 -0.229705 0.664126 +v -0.316102 -0.419396 0.649153 +v -0.131961 -0.201382 0.951731 +v -0.0876766 -0.391182 0.901606 +v -0.161859 0.285356 0.303098 +v -0.177264 0.282839 0.0875537 +v -0.158786 0.0751889 -0.141343 +v -0.310974 -0.0974099 -0.0697762 +v -0.138236 0.191142 0.700393 +v -0.13061 0.109881 0.873657 +v -0.287544 -0.214549 0.864938 +v -0.25445 0.101336 0.680112 +v -0.34304 -0.0541165 0.672286 +v -0.369388 -0.0242775 0.205838 +v -0.273782 0.160332 0.273861 +v -0.36907 -0.228332 0.435279 +v -0.146074 0.206063 0.488052 +v -0.15689 0.317253 -0.0179554 +v -0.184529 0.181235 -0.238574 +v -0.229877 0.446038 -0.0428095 +v -0.326584 0.303676 -0.375494 +v -0.257915 0.488969 -0.517721 +v -0.187711 0.730295 -0.437134 +v -0.190442 0.122856 -0.437696 +v -0.271501 0.201979 -0.579853 +v -0.227961 0.337016 -0.641468 +v -0.323288 -0.645898 -0.0650069 +v -0.277559 -0.660659 0.872426 +v -0.15321 -0.671553 0.116597 +v -0.153343 -0.652512 -0.0628489 +v -0.129752 -0.680413 0.714233 +v -0.310744 -0.658159 0.12474 +v -0.270197 -0.670204 0.705429 +v -0.125665 -0.664371 0.877017 +v -0.264169 0.646946 -0.369897 +v -0.180359 0.68646 -0.148279 +v -0.263204 0.560375 -0.137191 +v -0.371765 0.683869 -0.321196 +v -0.432195 0.751246 -0.233457 +v -0.424574 0.680439 -0.150855 +v -0.379346 0.604049 -0.213075 +v -0.164015 0.929339 -0.232094 +v -0.205905 0.915741 -0.313374 +v -0.15338 0.935554 -0.282029 +v -0.221786 0.905461 -0.256021 +v -0.115236 0.837896 -0.222054 +v -0.086327 0.812209 -0.211465 +v -0.172231 0.819312 -0.334104 +v -0.162464 0.791078 -0.351846 +v -0.0787362 0.822102 -0.294366 +v -0.102999 0.844736 -0.288229 +v -0.219399 0.754552 -0.28348 +v -0.199751 0.790382 -0.244881 +v -0.184684 0.762009 -0.196152 +v -0.279703 0.762439 -0.233186 +v -0.120311 -0.456517 0.243094 +v -0.111282 -0.477316 0.58188 +v -0.186164 -0.487701 0.417533 +v -0.17185 -0.0410977 0.94527 +v -0.106249 -0.0142167 0.968533 +v -0.107395 -0.0653463 0.975253 +v -0.0517509 -0.0608359 1.02473 +v -0.0517951 -0.0798093 1.0112 +v 0.287063 -0.417912 0.42339 +v 0.223323 -0.431749 0.300839 +v 0.262599 -0.446574 0.214165 +v 0.345683 -0.367458 0.305622 +v 0.284862 -0.410239 0.304857 +v 0.320467 -0.390454 0.538527 +v 0.218649 -0.474853 0.619945 +v 0.19621 -0.447285 0.538732 +v 0.257025 -0.429064 0.536591 +v 0.240602 -0.341214 -0.117452 +v 0.12147 -0.249274 -0.145022 +v 0.221157 -0.120393 -0.146058 +v 0.328715 -0.192761 -0.0778193 +v 0.229478 -0.212011 -0.133147 +v 0.307987 -0.0331195 -0.049691 +v 0.139893 -0.0548182 -0.181103 +v 0.237075 0.0521949 -0.0759725 +v 0.227173 -0.0372356 -0.128413 +v 0.301492 -0.292885 0.870674 +v 0.213279 -0.204742 0.922518 +v 0.117499 -0.281642 0.935739 +v 0.211816 -0.394732 0.922409 +v 0.215547 -0.286415 0.919674 +v 0.364968 -0.12541 0.046235 +v 0.382458 -0.25968 0.176197 +v 0.385194 -0.351205 0.0306159 +v 0.375418 -0.216313 0.0359591 +v 0.382575 -0.209764 0.311653 +v 0.361147 -0.316624 0.430338 +v 0.374384 -0.294532 0.308248 +v 0.368668 -0.137134 0.438729 +v 0.385132 -0.101185 0.188168 +v 0.365146 -0.0406368 0.324829 +v 0.381949 -0.125584 0.315412 +v 0.350232 0.00253885 0.0908221 +v 0.361458 -0.0619596 0.0609153 +v 0.343331 -0.409171 0.778577 +v 0.341862 -0.313907 0.657949 +v 0.328019 -0.223318 0.773747 +v 0.336544 -0.303107 0.775339 +v 0.283052 -0.132631 0.863571 +v 0.351001 -0.142438 0.668828 +v 0.322487 -0.0565049 0.774019 +v 0.329 -0.140489 0.774308 +v 0.349301 -0.0521301 0.560904 +v 0.357572 -0.233122 0.551664 +v 0.360647 -0.141814 0.556564 +v 0.349272 -0.319879 0.544579 +v 0.23281 0.229543 0.110217 +v 0.170184 0.299829 0.20555 +v 0.221341 0.236481 0.293418 +v 0.272682 0.181352 0.189589 +v 0.227226 0.252859 0.204008 +v 0.271155 0.129527 0.366223 +v 0.153276 0.244216 0.39384 +v 0.20969 0.164574 0.478658 +v 0.215375 0.198113 0.382954 +v 0.24282 0.0875955 0.770725 +v 0.198521 0.154682 0.689709 +v 0.134533 0.161682 0.796578 +v 0.187262 0.086887 0.854887 +v 0.191558 0.132026 0.78245 +v 0.141545 0.196582 0.593509 +v 0.26179 0.101674 0.574769 +v 0.204392 0.157257 0.584394 +v 0.327755 0.0676272 0.239516 +v 0.317321 0.0335117 0.454173 +v 0.324726 0.0469262 0.344192 +v 0.307072 0.0296092 0.675079 +v 0.253941 0.0157408 0.848168 +v 0.289863 0.0225221 0.77107 +v 0.190901 0.188016 -0.0300482 +v 0.288174 0.116771 0.0639197 +v 0.239299 0.151564 0.0118342 +v 0.313467 0.030566 0.566851 +v 0.317033 0.0909783 0.142973 +v 0.150018 0.148066 -0.170355 +v 0.192003 0.257627 -0.114007 +v 0.150923 0.290686 0.0162651 +v 0.172619 0.221245 -0.0722104 +v 0.274031 0.23831 -0.301318 +v 0.294876 0.383503 -0.203773 +v 0.194068 0.37243 -0.0269037 +v 0.248629 0.311098 -0.153862 +v 0.196806 0.141274 -0.362924 +v 0.23911 0.14497 -0.502892 +v 0.324701 0.24108 -0.502727 +v 0.278147 0.181024 -0.423508 +v 0.263786 0.27805 -0.630217 +v 0.250979 0.388662 -0.601302 +v 0.318198 0.390558 -0.446528 +v 0.314593 0.32071 -0.563292 +v 0.338046 -0.680095 0.0309463 +v 0.228165 -0.692422 0.147407 +v 0.12828 -0.689708 0.0245746 +v 0.238161 -0.677382 -0.0918856 +v 0.229681 -0.733842 0.0266899 +v 0.20056 -0.687393 0.898863 +v 0.107919 -0.696884 0.796995 +v 0.199176 -0.699686 0.68654 +v 0.291818 -0.690195 0.788408 +v 0.198244 -0.736784 0.793448 +v 0.307855 -0.55258 0.89062 +v 0.294592 -0.571581 0.678753 +v 0.335563 -0.561971 0.78431 +v 0.0593616 -0.458076 0.795932 +v 0.110927 -0.595142 0.691599 +v 0.102733 -0.558625 0.896274 +v 0.0716769 -0.583028 0.796447 +v 0.203007 -0.591569 0.647127 +v 0.206666 -0.553636 0.930804 +v 0.339121 -0.546516 0.150832 +v 0.352933 -0.520557 -0.0885122 +v 0.383244 -0.532332 0.0297109 +v 0.132569 -0.534652 -0.0767316 +v 0.24402 -0.524662 -0.124285 +v 0.143499 -0.577512 0.141914 +v 0.241073 -0.571789 0.188527 +v 0.0964942 -0.434904 0.0342915 +v 0.0999951 -0.56397 0.0317575 +v 0.271576 0.561647 -0.416318 +v 0.282894 0.56989 -0.257283 +v 0.23851 0.520387 -0.0907886 +v 0.293195 0.482084 -0.276654 +v 0.213045 0.609177 -0.109989 +v 0.321376 0.576724 -0.185683 +v 0.422878 0.632073 -0.168661 +v 0.32688 0.680784 -0.145207 +v 0.326345 0.612341 -0.141546 +v 0.312594 0.674309 -0.341185 +v 0.379053 0.63587 -0.283895 +v 0.3154 0.606871 -0.278418 +v 0.417773 0.731266 -0.288914 +v 0.460287 0.727236 -0.177367 +v 0.454185 0.684351 -0.230461 +v 0 0.320051 0.223298 +v 0.0857686 0.301184 0.309872 +v 0.0922474 0.320203 0.127906 +v 0.0910385 0.318251 0.216664 +v 0 0.227033 0.602086 +v 0.0710686 0.213115 0.708099 +v 0.0750596 0.22755 0.493766 +v 0.0724773 0.219588 0.599773 +v 0 0.186603 0.810651 +v 0.0670456 0.125156 0.886255 +v 0.0695062 0.18012 0.806775 +v 0 -0.40432 -0.00187701 +v 0.0502685 -0.34467 -0.0665397 +v 0.0661753 -0.432919 0.0879789 +v 0.056363 -0.399912 0.0126968 +v 0 -0.395546 0.810009 +v 0.0398588 -0.442711 0.714357 +v 0.0361117 -0.34665 0.891624 +v 0.0321101 -0.404726 0.804765 +v 0 0.264692 0.401284 +v 0.0798727 0.262384 0.399618 +v 0 0.330325 0.0716557 +v 0.0874752 0.345901 0.0284499 +v 0.0858416 0.32349 0.0605597 +v 0 0.409384 0.0515977 +v 0.124296 0.487548 0.0340513 +v 0.105997 0.402715 0.0360884 +v 0 0.641579 -0.507325 +v 0.104733 0.755088 -0.444831 +v 0.214286 0.629383 -0.484754 +v 0.136392 0.50382 -0.556974 +v 0.121817 0.636846 -0.502061 +v 0 0.412943 -0.623842 +v 0.139278 0.340909 -0.661549 +v 0.138945 0.411476 -0.620153 +v 0 -0.271137 0.943676 +v 0.0622199 -0.197393 0.966789 +v 0.0501277 -0.274014 0.941915 +v 0 -0.286073 -0.138523 +v 0.0553298 -0.185801 -0.197022 +v 0.050202 -0.275405 -0.142323 +v 0 -0.0695404 -0.225378 +v 0.0766662 0.0457919 -0.217551 +v 0.0655056 -0.0670069 -0.214493 +v 0 0.101519 -0.264918 +v 0.0933959 0.130309 -0.285229 +v 0.0838463 0.11062 -0.238883 +v 0 0.106874 -0.369301 +v 0.114603 0.104637 -0.445501 +v 0.102596 0.115199 -0.359834 +v 0 0.126441 -0.539369 +v 0.153665 0.185489 -0.611191 +v 0.137484 0.129002 -0.534091 +v 0 0.259825 -0.661348 +v 0.150371 0.262453 -0.657355 +v 0.0819636 0.707011 -0.0978848 +v 0 0.613137 0.0118372 +v 0.128934 0.593549 -0.0276065 +v 0.230899 0.696193 -0.415496 +v 0.2462 0.632058 -0.451998 +v 0.2255 0.918412 -0.287909 +v 0.182289 0.937359 -0.304334 +v 0.155831 0.94592 -0.253016 +v 0.199042 0.926972 -0.236591 +v 0.198381 0.950853 -0.26973 +v 0.195536 0.768708 -0.323732 +v 0.162591 0.796641 -0.337706 +v 0.198135 0.804412 -0.300184 +v 0.204856 0.767832 -0.258627 +v 0.190344 0.780419 -0.305321 +v 0.158595 0.817014 -0.220186 +v 0.102838 0.815304 -0.21903 +v 0.12548 0.786281 -0.190531 +v 0.18859 0.771476 -0.215131 +v 0.14521 0.793415 -0.208712 +v 0.113814 0.810725 -0.339255 +v 0.0911506 0.822276 -0.28966 +v 0.134346 0.834135 -0.324328 +v 0.12321 0.811864 -0.327105 +v 0.0699464 0.823757 -0.248502 +v 0.0956349 0.846841 -0.248877 +v 0.0836698 0.824545 -0.249204 +v 0.24364 0.757848 -0.207433 +v 0.246443 0.756953 -0.257453 +v 0.21289 0.762245 -0.22883 +v 0.355751 0.762428 -0.238497 +v 0.249966 0.723503 -0.332259 +v 0.32003 0.739642 -0.304714 +v 0.181848 0.741315 -0.180043 +v 0.328516 0.741977 -0.181175 +v 0.0499681 0.812176 -0.199395 +v 0 0.785709 -0.129116 +v 0.0788354 0.774284 -0.158189 +v 0.0505691 0.828853 -0.304368 +v 0.168022 0.778755 -0.386065 +v 0 0.821114 -0.378707 +v 0.0897195 0.811796 -0.373587 +v 0 0.831803 -0.246303 +v 0.0404745 0.828353 -0.247459 +v 0.211302 0.744371 -0.365196 +v 0.193702 0.87269 -0.329392 +v 0.216553 0.856661 -0.251136 +v 0.218551 0.860755 -0.297102 +v 0.126841 0.897388 -0.285836 +v 0.157513 0.887986 -0.320358 +v 0.138938 0.890583 -0.222912 +v 0.120161 0.900194 -0.247801 +v 0.181137 0.872948 -0.224154 +v 0.106299 -0.467348 0.612794 +v 0.156751 -0.485651 0.517662 +v 0.218865 -0.458568 0.419816 +v 0.177713 -0.464461 0.527871 +v 0 -0.459742 0.666605 +v 0.0640756 -0.481225 0.60015 +v 0.0486808 -0.462533 0.655449 +v 0.129769 -0.445891 0.210992 +v 0.0674919 -0.459184 0.218582 +v 0 -0.445956 0.12884 +v 0.0638357 -0.444618 0.15006 +v 0.160168 -0.471758 0.313909 +v 0.192938 -0.45045 0.307624 +v 0 -0.518477 0.519852 +v 0.106971 -0.518553 0.416032 +v 0.0913755 -0.507594 0.518132 +v 0 -0.503509 0.307563 +v 0.0906862 -0.492986 0.310407 +v 0.148938 -0.0188178 0.950827 +v 0.109744 -0.0412763 0.976341 +v 0.152295 -0.0598695 0.957881 +v 0.133131 -0.0374762 0.965091 +v 0.129144 -0.123186 0.961976 +v 0.214922 -0.0472768 0.917853 +v 0.202946 -0.113321 0.930645 +v 0.124777 0.0448234 0.926767 +v 0.189431 0.0176502 0.907717 +v 0.0541294 -0.000582154 0.980957 +v 0 0.0636729 0.946137 +v 0.0627521 0.0592134 0.940397 +v 0.0544734 -0.0758718 0.989219 +v 0 -0.121134 0.98554 +v 0.0631528 -0.123094 0.979468 +v 0.0716307 -0.0432 1.00541 +v 0.052795 -0.0725924 1.01945 +v 0.0717681 -0.0690106 0.994894 +v 0.0809297 -0.0558501 0.997263 +v 0 -0.0400118 1.02513 +v 0.0297219 -0.0653048 1.04059 +v 0.0406958 -0.0395224 1.01839 +v 0.0297587 -0.0908237 1.02001 +v 0 -0.0782912 1.00911 +v 0.0407812 -0.0765567 1.00299 +v 0 -0.0903561 1.04431 +v 0.0264068 -0.0851806 1.03686 +v -0.345683 -0.367458 0.305622 +v -0.262599 -0.446574 0.214165 +v -0.223323 -0.431749 0.300839 +v -0.287063 -0.417912 0.42339 +v -0.284862 -0.410239 0.304857 +v -0.19621 -0.447285 0.538732 +v -0.218649 -0.474853 0.619945 +v -0.320467 -0.390454 0.538527 +v -0.257025 -0.429064 0.536591 +v -0.328715 -0.192761 -0.0778193 +v -0.221157 -0.120393 -0.146058 +v -0.12147 -0.249274 -0.145022 +v -0.240602 -0.341214 -0.117452 +v -0.229478 -0.212011 -0.133147 +v -0.237075 0.0521949 -0.0759725 +v -0.139893 -0.0548182 -0.181103 +v -0.307987 -0.0331195 -0.049691 +v -0.227173 -0.0372356 -0.128413 +v -0.211816 -0.394732 0.922409 +v -0.117499 -0.281642 0.935739 +v -0.213279 -0.204742 0.922518 +v -0.301492 -0.292885 0.870674 +v -0.215547 -0.286415 0.919674 +v -0.385194 -0.351205 0.0306159 +v -0.382458 -0.25968 0.176197 +v -0.364968 -0.12541 0.046235 +v -0.375418 -0.216313 0.0359591 +v -0.361147 -0.316624 0.430338 +v -0.382575 -0.209764 0.311653 +v -0.374384 -0.294532 0.308248 +v -0.365146 -0.0406368 0.324829 +v -0.385132 -0.101185 0.188168 +v -0.368668 -0.137134 0.438729 +v -0.381949 -0.125584 0.315412 +v -0.350232 0.00253885 0.0908221 +v -0.361458 -0.0619596 0.0609153 +v -0.328019 -0.223318 0.773747 +v -0.341862 -0.313907 0.657949 +v -0.343331 -0.409171 0.778577 +v -0.336544 -0.303107 0.775339 +v -0.322487 -0.0565049 0.774019 +v -0.351001 -0.142438 0.668828 +v -0.283052 -0.132631 0.863571 +v -0.329 -0.140489 0.774308 +v -0.357572 -0.233122 0.551664 +v -0.349301 -0.0521301 0.560904 +v -0.360647 -0.141814 0.556564 +v -0.349272 -0.319879 0.544579 +v -0.272682 0.181352 0.189589 +v -0.221341 0.236481 0.293418 +v -0.170184 0.299829 0.20555 +v -0.23281 0.229543 0.110217 +v -0.227226 0.252859 0.204008 +v -0.20969 0.164574 0.478658 +v -0.153276 0.244216 0.39384 +v -0.271155 0.129527 0.366223 +v -0.215375 0.198113 0.382954 +v -0.187262 0.086887 0.854887 +v -0.134533 0.161682 0.796578 +v -0.198521 0.154682 0.689709 +v -0.24282 0.0875955 0.770725 +v -0.191558 0.132026 0.78245 +v -0.26179 0.101674 0.574769 +v -0.141545 0.196582 0.593509 +v -0.204392 0.157257 0.584394 +v -0.317321 0.0335117 0.454173 +v -0.327755 0.0676272 0.239516 +v -0.324726 0.0469262 0.344192 +v -0.253941 0.0157408 0.848168 +v -0.307072 0.0296092 0.675079 +v -0.289863 0.0225221 0.77107 +v -0.288174 0.116771 0.0639197 +v -0.190901 0.188016 -0.0300482 +v -0.239299 0.151564 0.0118342 +v -0.313467 0.030566 0.566851 +v -0.317033 0.0909783 0.142973 +v -0.150923 0.290686 0.0162651 +v -0.192003 0.257627 -0.114007 +v -0.150018 0.148066 -0.170355 +v -0.172619 0.221245 -0.0722104 +v -0.194068 0.37243 -0.0269037 +v -0.294876 0.383503 -0.203773 +v -0.274031 0.23831 -0.301318 +v -0.248629 0.311098 -0.153862 +v -0.324701 0.24108 -0.502727 +v -0.23911 0.14497 -0.502892 +v -0.196806 0.141274 -0.362924 +v -0.278147 0.181024 -0.423508 +v -0.318198 0.390558 -0.446528 +v -0.250979 0.388662 -0.601302 +v -0.263786 0.27805 -0.630217 +v -0.314593 0.32071 -0.563292 +v -0.238161 -0.677382 -0.0918856 +v -0.12828 -0.689708 0.0245746 +v -0.228165 -0.692422 0.147407 +v -0.338046 -0.680095 0.0309463 +v -0.229681 -0.733842 0.0266899 +v -0.291818 -0.690195 0.788408 +v -0.199176 -0.699686 0.68654 +v -0.107919 -0.696884 0.796995 +v -0.20056 -0.687393 0.898863 +v -0.198244 -0.736784 0.793448 +v -0.294592 -0.571581 0.678753 +v -0.307855 -0.55258 0.89062 +v -0.335563 -0.561971 0.78431 +v -0.102733 -0.558625 0.896274 +v -0.110927 -0.595142 0.691599 +v -0.0593616 -0.458076 0.795932 +v -0.0716769 -0.583028 0.796447 +v -0.203007 -0.591569 0.647127 +v -0.206666 -0.553636 0.930804 +v -0.352933 -0.520557 -0.0885122 +v -0.339121 -0.546516 0.150832 +v -0.383244 -0.532332 0.0297109 +v -0.132569 -0.534652 -0.0767316 +v -0.24402 -0.524662 -0.124285 +v -0.143499 -0.577512 0.141914 +v -0.241073 -0.571789 0.188527 +v -0.0964942 -0.434904 0.0342915 +v -0.0999951 -0.56397 0.0317575 +v -0.23851 0.520387 -0.0907886 +v -0.282894 0.56989 -0.257283 +v -0.271576 0.561647 -0.416318 +v -0.293195 0.482084 -0.276654 +v -0.32688 0.680784 -0.145207 +v -0.422878 0.632073 -0.168661 +v -0.321376 0.576724 -0.185683 +v -0.213045 0.609177 -0.109989 +v -0.326345 0.612341 -0.141546 +v -0.379053 0.63587 -0.283895 +v -0.312594 0.674309 -0.341185 +v -0.3154 0.606871 -0.278418 +v -0.460287 0.727236 -0.177367 +v -0.417773 0.731266 -0.288914 +v -0.454185 0.684351 -0.230461 +v -0.0922474 0.320203 0.127906 +v -0.0857686 0.301184 0.309872 +v -0.0910385 0.318251 0.216664 +v -0.0750596 0.22755 0.493766 +v -0.0710686 0.213115 0.708099 +v -0.0724773 0.219588 0.599773 +v -0.0670456 0.125156 0.886255 +v -0.0695062 0.18012 0.806775 +v -0.0661753 -0.432919 0.0879789 +v -0.0502685 -0.34467 -0.0665397 +v -0.056363 -0.399912 0.0126968 +v -0.0361117 -0.34665 0.891624 +v -0.0398588 -0.442711 0.714357 +v -0.0321101 -0.404726 0.804765 +v -0.0798727 0.262384 0.399618 +v -0.0874752 0.345901 0.0284499 +v -0.0858416 0.32349 0.0605597 +v -0.124296 0.487548 0.0340513 +v -0.105997 0.402715 0.0360884 +v -0.136392 0.50382 -0.556974 +v -0.214286 0.629383 -0.484754 +v -0.104733 0.755088 -0.444831 +v -0.121817 0.636846 -0.502061 +v -0.139278 0.340909 -0.661549 +v -0.138945 0.411476 -0.620153 +v -0.0622199 -0.197393 0.966789 +v -0.0501277 -0.274014 0.941915 +v -0.0553298 -0.185801 -0.197022 +v -0.050202 -0.275405 -0.142323 +v -0.0766662 0.0457919 -0.217551 +v -0.0655056 -0.0670069 -0.214493 +v -0.0933959 0.130309 -0.285229 +v -0.0838463 0.11062 -0.238883 +v -0.114603 0.104637 -0.445501 +v -0.102596 0.115199 -0.359834 +v -0.153665 0.185489 -0.611191 +v -0.137484 0.129002 -0.534091 +v -0.150371 0.262453 -0.657355 +v -0.0819636 0.707011 -0.0978848 +v -0.128934 0.593549 -0.0276065 +v -0.230899 0.696193 -0.415496 +v -0.2462 0.632058 -0.451998 +v -0.199042 0.926972 -0.236591 +v -0.155831 0.94592 -0.253016 +v -0.182289 0.937359 -0.304334 +v -0.2255 0.918412 -0.287909 +v -0.198381 0.950853 -0.26973 +v -0.204856 0.767832 -0.258627 +v -0.198135 0.804412 -0.300184 +v -0.162591 0.796641 -0.337706 +v -0.195536 0.768708 -0.323732 +v -0.190344 0.780419 -0.305321 +v -0.18859 0.771476 -0.215131 +v -0.12548 0.786281 -0.190531 +v -0.102838 0.815304 -0.21903 +v -0.158595 0.817014 -0.220186 +v -0.14521 0.793415 -0.208712 +v -0.134346 0.834135 -0.324328 +v -0.0911506 0.822276 -0.28966 +v -0.113814 0.810725 -0.339255 +v -0.12321 0.811864 -0.327105 +v -0.0956349 0.846841 -0.248877 +v -0.0699464 0.823757 -0.248502 +v -0.0836698 0.824545 -0.249204 +v -0.246443 0.756953 -0.257453 +v -0.24364 0.757848 -0.207433 +v -0.21289 0.762245 -0.22883 +v -0.249966 0.723503 -0.332259 +v -0.355751 0.762428 -0.238497 +v -0.32003 0.739642 -0.304714 +v -0.181848 0.741315 -0.180043 +v -0.328516 0.741977 -0.181175 +v -0.0499681 0.812176 -0.199395 +v -0.0788354 0.774284 -0.158189 +v -0.168022 0.778755 -0.386065 +v -0.0505691 0.828853 -0.304368 +v -0.0897195 0.811796 -0.373587 +v -0.0404745 0.828353 -0.247459 +v -0.211302 0.744371 -0.365196 +v -0.216553 0.856661 -0.251136 +v -0.193702 0.87269 -0.329392 +v -0.218551 0.860755 -0.297102 +v -0.126841 0.897388 -0.285836 +v -0.157513 0.887986 -0.320358 +v -0.138938 0.890583 -0.222912 +v -0.120161 0.900194 -0.247801 +v -0.181137 0.872948 -0.224154 +v -0.218865 -0.458568 0.419816 +v -0.156751 -0.485651 0.517662 +v -0.106299 -0.467348 0.612794 +v -0.177713 -0.464461 0.527871 +v -0.0640756 -0.481225 0.60015 +v -0.0486808 -0.462533 0.655449 +v -0.0674919 -0.459184 0.218582 +v -0.129769 -0.445891 0.210992 +v -0.0638357 -0.444618 0.15006 +v -0.160168 -0.471758 0.313909 +v -0.192938 -0.45045 0.307624 +v -0.106971 -0.518553 0.416032 +v -0.0913755 -0.507594 0.518132 +v -0.0906862 -0.492986 0.310407 +v -0.152295 -0.0598695 0.957881 +v -0.109744 -0.0412763 0.976341 +v -0.148938 -0.0188178 0.950827 +v -0.133131 -0.0374762 0.965091 +v -0.214922 -0.0472768 0.917853 +v -0.129144 -0.123186 0.961976 +v -0.202946 -0.113321 0.930645 +v -0.124777 0.0448234 0.926767 +v -0.189431 0.0176502 0.907717 +v -0.0541294 -0.000582154 0.980957 +v -0.0627521 0.0592134 0.940397 +v -0.0544734 -0.0758718 0.989219 +v -0.0631528 -0.123094 0.979468 +v -0.0717681 -0.0690106 0.994894 +v -0.052795 -0.0725924 1.01945 +v -0.0716307 -0.0432 1.00541 +v -0.0809297 -0.0558501 0.997263 +v -0.0297219 -0.0653048 1.04059 +v -0.0406958 -0.0395224 1.01839 +v -0.0297587 -0.0908237 1.02001 +v -0.0407812 -0.0765567 1.00299 +v -0.0264068 -0.0851806 1.03686 +v 0.313121 -0.40468 0.424303 +v 0.289638 -0.411984 0.363044 +v 0.317818 -0.392423 0.305485 +v 0.341299 -0.375944 0.366232 +v 0.317288 -0.397295 0.364448 +v 0.23935 -0.43199 0.361842 +v 0.251544 -0.422435 0.302332 +v 0.261632 -0.427221 0.422701 +v 0.262332 -0.422664 0.362137 +v 0.2099 -0.457622 0.202318 +v 0.274846 -0.418754 0.252658 +v 0.194817 -0.437402 0.239358 +v 0.231211 -0.430966 0.245486 +v 0.350284 -0.364453 0.244783 +v 0.312495 -0.42258 0.208415 +v 0.316601 -0.396416 0.250199 +v 0.328162 -0.387696 0.483083 +v 0.291362 -0.413379 0.536815 +v 0.275025 -0.421949 0.482067 +v 0.303426 -0.408222 0.482265 +v 0.26979 -0.455493 0.624003 +v 0.236564 -0.444228 0.584476 +v 0.315111 -0.397679 0.592146 +v 0.280089 -0.425608 0.586435 +v 0.156119 -0.458526 0.595789 +v 0.222989 -0.439421 0.53835 +v 0.164011 -0.483033 0.631406 +v 0.191143 -0.453861 0.591118 +v 0.225399 -0.440193 0.480871 +v 0.247502 -0.431674 0.481825 +v 0.300873 -0.335808 -0.11045 +v 0.23546 -0.269794 -0.12322 +v 0.283535 -0.198083 -0.11242 +v 0.339519 -0.257182 -0.0802831 +v 0.292915 -0.260195 -0.110308 +v 0.119478 -0.295776 -0.113872 +v 0.173106 -0.230478 -0.142628 +v 0.176383 -0.34915 -0.10631 +v 0.174532 -0.282877 -0.121531 +v 0.172014 -0.141551 -0.170002 +v 0.224047 -0.163495 -0.142015 +v 0.123113 -0.206388 -0.170045 +v 0.171621 -0.184999 -0.160037 +v 0.318497 -0.140059 -0.0746981 +v 0.26898 -0.103901 -0.112945 +v 0.274851 -0.146856 -0.114171 +v 0.307808 -0.00318692 -0.0317095 +v 0.269878 -0.0318881 -0.0928838 +v 0.232462 0.00608204 -0.106821 +v 0.273281 0.0420733 -0.0438498 +v 0.272342 0.00331308 -0.0724007 +v 0.222802 -0.0788504 -0.141507 +v 0.308256 -0.0631453 -0.0619102 +v 0.26804 -0.0666021 -0.106124 +v 0.131964 -0.111136 -0.188613 +v 0.182883 -0.0457092 -0.157469 +v 0.176218 -0.0952439 -0.168768 +v 0.199052 0.0623656 -0.105989 +v 0.148915 0.00578811 -0.165362 +v 0.190658 0.0074224 -0.137241 +v 0.30851 -0.340088 0.875405 +v 0.263105 -0.289222 0.900577 +v 0.214141 -0.334681 0.919903 +v 0.26887 -0.396352 0.909752 +v 0.266995 -0.336923 0.904292 +v 0.253262 -0.209214 0.897882 +v 0.215216 -0.244729 0.920604 +v 0.293898 -0.252639 0.867139 +v 0.258195 -0.248301 0.898482 +v 0.126656 -0.240414 0.945024 +v 0.164801 -0.284207 0.93026 +v 0.172003 -0.202637 0.93974 +v 0.169955 -0.242358 0.935335 +v 0.149733 -0.3934 0.920339 +v 0.104904 -0.328487 0.922781 +v 0.15673 -0.332639 0.924128 +v 0.358457 -0.200112 -0.0267162 +v 0.380901 -0.277243 0.032671 +v 0.375987 -0.340814 -0.0337268 +v 0.367895 -0.263853 -0.0306343 +v 0.342627 -0.106257 -0.015664 +v 0.369603 -0.166291 0.0406057 +v 0.349444 -0.148083 -0.0217878 +v 0.385185 -0.214712 0.178025 +v 0.382253 -0.237542 0.105277 +v 0.379025 -0.149836 0.112764 +v 0.38088 -0.190046 0.108528 +v 0.379176 -0.364086 0.102343 +v 0.375596 -0.311145 0.175939 +v 0.381399 -0.294389 0.103665 +v 0.363729 -0.333817 0.306674 +v 0.367965 -0.307651 0.370431 +v 0.351404 -0.354331 0.427814 +v 0.35769 -0.345276 0.36828 +v 0.379525 -0.278609 0.243679 +v 0.369702 -0.323364 0.243084 +v 0.386398 -0.194374 0.247084 +v 0.380079 -0.252636 0.309953 +v 0.384425 -0.235652 0.245143 +v 0.366553 -0.273812 0.432936 +v 0.376188 -0.22098 0.374406 +v 0.373629 -0.265433 0.372527 +v 0.363531 -0.0923241 0.440867 +v 0.375379 -0.132559 0.377674 +v 0.376221 -0.0834201 0.319025 +v 0.359143 -0.0454376 0.384517 +v 0.369754 -0.0887861 0.380331 +v 0.383633 -0.167556 0.313214 +v 0.370145 -0.182621 0.437038 +v 0.377148 -0.176656 0.375911 +v 0.386429 -0.137312 0.183762 +v 0.385994 -0.115397 0.252169 +v 0.387444 -0.154662 0.24911 +v 0.369328 -0.0337485 0.265179 +v 0.380073 -0.0641595 0.195141 +v 0.380479 -0.0754649 0.257209 +v 0.331012 0.0171674 0.0389716 +v 0.357964 -0.0317511 0.0731655 +v 0.338487 -0.0443826 0.00235778 +v 0.336366 -0.0157204 0.0175237 +v 0.37698 -0.0821329 0.123634 +v 0.363023 -0.0117289 0.147082 +v 0.372551 -0.0487428 0.133083 +v 0.363023 -0.0919062 0.0524717 +v 0.378431 -0.114848 0.117331 +v 0.339774 -0.073126 -0.00816016 +v 0.336842 -0.40362 0.835552 +v 0.340911 -0.350598 0.77666 +v 0.324728 -0.29766 0.82767 +v 0.331904 -0.344898 0.831349 +v 0.334716 -0.360298 0.654176 +v 0.340676 -0.308781 0.717453 +v 0.335933 -0.414813 0.716014 +v 0.339263 -0.356428 0.715872 +v 0.338685 -0.226798 0.720092 +v 0.331546 -0.262105 0.774295 +v 0.344609 -0.271269 0.661246 +v 0.339619 -0.266826 0.718796 +v 0.311718 -0.219243 0.822794 +v 0.317327 -0.257308 0.824743 +v 0.282982 -0.0932074 0.86163 +v 0.309753 -0.137557 0.821642 +v 0.32815 -0.0982774 0.774453 +v 0.304296 -0.0566442 0.818942 +v 0.309064 -0.0966912 0.82069 +v 0.328063 -0.182474 0.773912 +v 0.284251 -0.173813 0.864211 +v 0.309915 -0.178867 0.822052 +v 0.348891 -0.186539 0.666645 +v 0.342261 -0.141944 0.72292 +v 0.340465 -0.184932 0.72153 +v 0.335097 -0.0554519 0.724795 +v 0.349859 -0.0980743 0.670701 +v 0.341372 -0.0985454 0.724072 +v 0.350887 -0.0507559 0.502911 +v 0.3576 -0.096426 0.55865 +v 0.364199 -0.140124 0.498352 +v 0.360004 -0.0947951 0.500374 +v 0.356689 -0.14249 0.613383 +v 0.34723 -0.0531297 0.617509 +v 0.354744 -0.0974434 0.615492 +v 0.35206 -0.232064 0.608144 +v 0.360088 -0.187609 0.554338 +v 0.355112 -0.187591 0.610995 +v 0.363053 -0.232129 0.494204 +v 0.364779 -0.186112 0.496433 +v 0.354812 -0.320109 0.488079 +v 0.338808 -0.358381 0.541229 +v 0.344689 -0.357576 0.485189 +v 0.354746 -0.277669 0.548235 +v 0.360332 -0.277544 0.491251 +v 0.344841 -0.317709 0.600763 +v 0.349578 -0.27523 0.604646 +v 0.335024 -0.360119 0.596759 +v 0.253104 0.203435 0.118078 +v 0.22988 0.247545 0.157829 +v 0.250535 0.219935 0.200112 +v 0.270021 0.183796 0.151405 +v 0.251096 0.217673 0.158942 +v 0.173937 0.295795 0.151795 +v 0.201028 0.279793 0.204606 +v 0.208445 0.255016 0.0997486 +v 0.204742 0.274117 0.153286 +v 0.19325 0.264928 0.298974 +v 0.224342 0.248556 0.249012 +v 0.166122 0.2964 0.255682 +v 0.197174 0.276415 0.252836 +v 0.273837 0.172969 0.230557 +v 0.247672 0.201215 0.285394 +v 0.249328 0.213762 0.242242 +v 0.269047 0.115689 0.415447 +v 0.243641 0.166107 0.375362 +v 0.21248 0.178956 0.429644 +v 0.238934 0.137098 0.472953 +v 0.241351 0.149381 0.423 +v 0.218341 0.218477 0.337805 +v 0.272811 0.14513 0.319056 +v 0.245762 0.184358 0.32963 +v 0.157504 0.266542 0.348704 +v 0.185529 0.224498 0.389084 +v 0.189327 0.246276 0.344018 +v 0.178799 0.187723 0.48375 +v 0.149393 0.222637 0.439843 +v 0.181979 0.203634 0.435289 +v 0.235856 0.0765799 0.805621 +v 0.217701 0.11212 0.775527 +v 0.188626 0.112308 0.821548 +v 0.212012 0.0755801 0.841201 +v 0.213324 0.0965225 0.811853 +v 0.226814 0.130295 0.684497 +v 0.195015 0.146226 0.738197 +v 0.249108 0.0961373 0.728207 +v 0.222367 0.12354 0.732548 +v 0.136442 0.179619 0.750387 +v 0.163968 0.1484 0.789706 +v 0.169138 0.174847 0.695193 +v 0.166543 0.164739 0.744396 +v 0.159999 0.0987976 0.865373 +v 0.13257 0.138159 0.837992 +v 0.161693 0.126272 0.830304 +v 0.207042 0.158534 0.530777 +v 0.233686 0.131486 0.579487 +v 0.264402 0.101968 0.520397 +v 0.236433 0.132176 0.525634 +v 0.143538 0.198754 0.539805 +v 0.173735 0.178964 0.589175 +v 0.176115 0.180806 0.535582 +v 0.201599 0.157166 0.637907 +v 0.139858 0.195421 0.647569 +v 0.171473 0.178284 0.642915 +v 0.258575 0.102323 0.628487 +v 0.230534 0.131902 0.632959 +v 0.34742 0.00319315 0.333602 +v 0.320929 0.0389878 0.398635 +v 0.337836 -0.00655256 0.448549 +v 0.342419 -0.00261151 0.390867 +v 0.351215 0.0204208 0.221415 +v 0.327429 0.0566863 0.291075 +v 0.350974 0.0108683 0.277027 +v 0.298744 0.0894187 0.355449 +v 0.30121 0.115034 0.257783 +v 0.300703 0.102007 0.305644 +v 0.293232 0.0711038 0.460405 +v 0.296022 0.0786559 0.407077 +v 0.328122 -0.0112347 0.673608 +v 0.30029 0.0266191 0.725054 +v 0.308985 -0.0158364 0.772679 +v 0.320738 -0.0133772 0.724898 +v 0.267341 0.0573644 0.769829 +v 0.281859 0.0674534 0.67711 +v 0.275748 0.0634772 0.725933 +v 0.24017 0.0457536 0.838346 +v 0.274888 0.0183198 0.812257 +v 0.256292 0.0501447 0.807253 +v 0.268509 -0.018423 0.854481 +v 0.291897 -0.0177918 0.816142 +v 0.181753 0.135303 -0.0848536 +v 0.213035 0.170022 -0.00953204 +v 0.239418 0.102195 -0.0351077 +v 0.20757 0.117335 -0.0616182 +v 0.236523 0.195781 0.0609139 +v 0.190293 0.237055 0.0258931 +v 0.212268 0.218116 0.0448664 +v 0.276588 0.155574 0.0981021 +v 0.265278 0.133372 0.0353559 +v 0.258648 0.173682 0.0768666 +v 0.298292 0.0729821 0.0271766 +v 0.270541 0.0874645 -0.00640695 +v 0.311113 0.0304905 0.622016 +v 0.288873 0.0678482 0.57056 +v 0.286019 0.0682635 0.624906 +v 0.334099 -0.00961306 0.563635 +v 0.332102 -0.0102295 0.619617 +v 0.315185 0.0311388 0.510574 +v 0.335537 -0.00863692 0.506376 +v 0.291063 0.0681481 0.515313 +v 0.33595 0.0447295 0.115485 +v 0.324423 0.0791082 0.189745 +v 0.346277 0.0318576 0.16704 +v 0.305188 0.103086 0.100412 +v 0.320025 0.0585873 0.0683354 +v 0.295396 0.137443 0.169109 +v 0.288286 0.145212 0.129998 +v 0.299573 0.127115 0.211987 +v 0.149034 0.119255 -0.152767 +v 0.167034 0.18223 -0.122798 +v 0.177314 0.204818 -0.0510199 +v 0.168725 0.158519 -0.103729 +v 0.194921 0.221357 -0.173014 +v 0.177164 0.238112 -0.093383 +v 0.160058 0.168229 -0.195838 +v 0.175228 0.201681 -0.146613 +v 0.149721 0.3008 -0.00470029 +v 0.167426 0.259011 -0.0241111 +v 0.17918 0.290497 -0.0609743 +v 0.168557 0.27236 -0.0447148 +v 0.159665 0.285267 0.0452783 +v 0.175009 0.248965 0.00116269 +v 0.233098 0.21084 -0.267301 +v 0.26422 0.274293 -0.228207 +v 0.21819 0.281995 -0.133552 +v 0.227725 0.245742 -0.199837 +v 0.314639 0.343639 -0.292523 +v 0.27622 0.344814 -0.176785 +v 0.306638 0.268641 -0.338166 +v 0.294985 0.306469 -0.259249 +v 0.21453 0.407775 -0.0317089 +v 0.225521 0.344757 -0.0845003 +v 0.267222 0.417414 -0.116444 +v 0.249809 0.379204 -0.0978893 +v 0.173263 0.341693 -0.0238379 +v 0.200073 0.314908 -0.0732157 +v 0.192666 0.159829 -0.308601 +v 0.240251 0.15911 -0.387649 +v 0.279797 0.207117 -0.366981 +v 0.238726 0.181983 -0.331175 +v 0.213461 0.12942 -0.465108 +v 0.265715 0.160342 -0.469212 +v 0.195451 0.128497 -0.407372 +v 0.233311 0.142158 -0.432916 +v 0.305787 0.218563 -0.547441 +v 0.307399 0.208213 -0.46356 +v 0.259412 0.1698 -0.542722 +v 0.290901 0.186126 -0.509143 +v 0.330786 0.26947 -0.445487 +v 0.31171 0.235804 -0.406418 +v 0.32675 0.280027 -0.535933 +v 0.321008 0.352655 -0.511417 +v 0.329541 0.345256 -0.410956 +v 0.333345 0.309542 -0.480189 +v 0.272516 0.239582 -0.609537 +v 0.296456 0.295786 -0.60247 +v 0.307295 0.256707 -0.578835 +v 0.240548 0.35766 -0.62796 +v 0.289278 0.358786 -0.584918 +v 0.246645 0.312827 -0.640337 +v 0.274305 0.331026 -0.617491 +v 0.295245 0.436762 -0.484187 +v 0.255976 0.429549 -0.563622 +v 0.295399 0.395443 -0.540067 +v 0.335047 -0.66747 -0.026194 +v 0.288313 -0.71953 0.0292002 +v 0.233667 -0.718383 -0.0394682 +v 0.288912 -0.666279 -0.0831981 +v 0.288523 -0.704927 -0.0329901 +v 0.276152 -0.679477 0.14116 +v 0.227442 -0.724741 0.0933852 +v 0.327044 -0.674066 0.0872825 +v 0.281161 -0.710704 0.0910758 +v 0.136631 -0.686121 0.0787634 +v 0.172796 -0.723594 0.0247169 +v 0.182766 -0.687312 0.135767 +v 0.176191 -0.716151 0.0857864 +v 0.187443 -0.669698 -0.0818819 +v 0.136552 -0.67511 -0.0280042 +v 0.179633 -0.708233 -0.0350267 +v 0.2461 -0.678205 0.889508 +v 0.198896 -0.723335 0.85193 +v 0.248642 -0.724519 0.790895 +v 0.288217 -0.679435 0.838379 +v 0.246831 -0.711912 0.845432 +v 0.113033 -0.684171 0.844965 +v 0.148661 -0.727347 0.795626 +v 0.15574 -0.680004 0.892121 +v 0.151829 -0.713932 0.849146 +v 0.157976 -0.694713 0.696986 +v 0.198408 -0.728532 0.734591 +v 0.115859 -0.693483 0.748115 +v 0.153047 -0.720555 0.741401 +v 0.283587 -0.684515 0.738785 +v 0.24088 -0.688682 0.691628 +v 0.244434 -0.716483 0.736358 +v 0.342489 -0.483419 0.78141 +v 0.32282 -0.565952 0.726198 +v 0.30391 -0.498066 0.668956 +v 0.331237 -0.488983 0.719836 +v 0.31354 -0.474577 0.887895 +v 0.331331 -0.556659 0.842236 +v 0.337524 -0.478425 0.840051 +v 0.319732 -0.633454 0.786428 +v 0.294197 -0.618974 0.884469 +v 0.315639 -0.625673 0.839496 +v 0.28283 -0.632563 0.691009 +v 0.308326 -0.632734 0.733956 +v 0.0634711 -0.431765 0.851899 +v 0.0654567 -0.515878 0.79543 +v 0.0774719 -0.570173 0.85133 +v 0.0969194 -0.478778 0.897495 +v 0.0707234 -0.496321 0.852392 +v 0.106684 -0.534636 0.682874 +v 0.0832655 -0.591144 0.740087 +v 0.069956 -0.47422 0.735292 +v 0.0773661 -0.528459 0.735056 +v 0.0840444 -0.64607 0.797118 +v 0.119063 -0.647679 0.702012 +v 0.0943475 -0.648249 0.746058 +v 0.112805 -0.624088 0.888986 +v 0.0899111 -0.634521 0.847274 +v 0.252371 -0.581833 0.652832 +v 0.208287 -0.52835 0.637223 +v 0.260651 -0.513618 0.642398 +v 0.20034 -0.651356 0.660475 +v 0.244653 -0.641994 0.666514 +v 0.15335 -0.595644 0.66033 +v 0.156436 -0.650983 0.672896 +v 0.153645 -0.534978 0.650489 +v 0.149543 -0.554429 0.922812 +v 0.209392 -0.47177 0.928314 +v 0.147798 -0.472236 0.922294 +v 0.203436 -0.628169 0.923071 +v 0.153584 -0.625261 0.914716 +v 0.262868 -0.552296 0.920108 +v 0.253551 -0.622939 0.912658 +v 0.267734 -0.472455 0.917082 +v 0.348561 -0.464054 0.158716 +v 0.369537 -0.538419 0.0961211 +v 0.387436 -0.440321 0.0296682 +v 0.376444 -0.45013 0.0999599 +v 0.368236 -0.614976 0.0306267 +v 0.325558 -0.615423 0.139592 +v 0.354786 -0.614851 0.0904298 +v 0.340742 -0.597899 -0.0798229 +v 0.378455 -0.525308 -0.0356201 +v 0.364087 -0.605614 -0.0296813 +v 0.354445 -0.427851 -0.0878125 +v 0.380964 -0.432504 -0.0361787 +v 0.243518 -0.430642 -0.121062 +v 0.182701 -0.527846 -0.109937 +v 0.12704 -0.448099 -0.0735785 +v 0.179139 -0.436248 -0.106528 +v 0.304443 -0.521287 -0.117606 +v 0.305291 -0.427537 -0.115465 +v 0.241923 -0.609859 -0.117359 +v 0.296601 -0.602967 -0.109127 +v 0.141316 -0.607217 -0.0730372 +v 0.186967 -0.607615 -0.104287 +v 0.148115 -0.512563 0.149929 +v 0.188536 -0.577394 0.174934 +v 0.25113 -0.502745 0.197094 +v 0.196177 -0.511769 0.183546 +v 0.233064 -0.638226 0.175543 +v 0.145237 -0.635178 0.13052 +v 0.185474 -0.638484 0.162245 +v 0.293784 -0.559568 0.181063 +v 0.282371 -0.626877 0.167977 +v 0.304357 -0.484216 0.189956 +v 0.105712 -0.548895 -0.0268432 +v 0.0997946 -0.492468 0.0352712 +v 0.0953701 -0.405611 -0.0214782 +v 0.102107 -0.469936 -0.0239275 +v 0.106751 -0.633108 0.0275567 +v 0.114552 -0.619641 -0.0267392 +v 0.113288 -0.573273 0.0910993 +v 0.117988 -0.635837 0.0828 +v 0.112515 -0.451919 0.0935688 +v 0.115559 -0.506404 0.0968639 +v 0.271184 0.525759 -0.460079 +v 0.285353 0.520853 -0.361551 +v 0.308658 0.43336 -0.368305 +v 0.291391 0.478507 -0.418527 +v 0.278055 0.600765 -0.320108 +v 0.282577 0.535883 -0.259681 +v 0.267 0.601931 -0.388185 +v 0.278645 0.563976 -0.33172 +v 0.247008 0.54474 -0.114114 +v 0.271214 0.498067 -0.167977 +v 0.277875 0.55689 -0.190965 +v 0.271665 0.531425 -0.180446 +v 0.298509 0.427522 -0.236282 +v 0.235335 0.485531 -0.0647615 +v 0.272045 0.45855 -0.143225 +v 0.317802 0.38717 -0.32759 +v 0.192626 0.647576 -0.125774 +v 0.267679 0.610284 -0.129549 +v 0.326452 0.645309 -0.138504 +v 0.252363 0.682167 -0.15033 +v 0.258116 0.645451 -0.13607 +v 0.289471 0.569074 -0.162469 +v 0.324346 0.587714 -0.15672 +v 0.239082 0.578957 -0.111996 +v 0.279361 0.583208 -0.137022 +v 0.401583 0.612716 -0.19176 +v 0.380321 0.61857 -0.152413 +v 0.35448 0.589213 -0.202564 +v 0.367842 0.597467 -0.17194 +v 0.388682 0.680406 -0.144893 +v 0.430349 0.658277 -0.154382 +v 0.384792 0.647908 -0.143704 +v 0.294439 0.591849 -0.266039 +v 0.318359 0.584666 -0.230094 +v 0.294318 0.572729 -0.209871 +v 0.28588 0.662049 -0.349089 +v 0.312606 0.638668 -0.319124 +v 0.290372 0.624108 -0.317788 +v 0.375881 0.662505 -0.310821 +v 0.343967 0.620068 -0.286887 +v 0.345079 0.681327 -0.333156 +v 0.34177 0.649107 -0.318477 +v 0.380591 0.614582 -0.245535 +v 0.347363 0.598425 -0.244565 +v 0.393743 0.706765 -0.3123 +v 0.444197 0.711394 -0.263256 +v 0.419572 0.658706 -0.261892 +v 0.412958 0.685943 -0.291128 +v 0.452589 0.744444 -0.206816 +v 0.471552 0.708579 -0.199184 +v 0.43241 0.746455 -0.258303 +v 0.460792 0.730831 -0.231063 +v 0.447289 0.655956 -0.196803 +v 0.447397 0.702392 -0.15815 +v 0.460337 0.681448 -0.17325 +v 0.417303 0.633713 -0.225256 +v 0 0.324094 0.180165 +v 0.0462436 0.320164 0.221337 +v 0.0925539 0.320139 0.170699 +v 0.0467382 0.325284 0.136739 +v 0.0468991 0.323707 0.17766 +v 0.0434892 0.30185 0.311934 +v 0.0886491 0.312396 0.263435 +v 0 0.312812 0.267846 +v 0.0450231 0.313323 0.266515 +v 0.132936 0.312061 0.210485 +v 0.125628 0.296564 0.306829 +v 0.129481 0.307575 0.259519 +v 0.135299 0.30832 0.112598 +v 0.13572 0.310986 0.159838 +v 0 0.228164 0.547798 +v 0.0364517 0.2252 0.601479 +v 0.0735327 0.221293 0.545706 +v 0.0377827 0.232065 0.495188 +v 0.0369868 0.226526 0.54726 +v 0.0357781 0.218679 0.710249 +v 0.0717153 0.218255 0.65442 +v 0 0.22586 0.657001 +v 0.0360809 0.22396 0.656319 +v 0.107651 0.210086 0.597079 +v 0.105384 0.203917 0.704755 +v 0.106456 0.208743 0.651454 +v 0.111325 0.219111 0.491389 +v 0.109197 0.212143 0.543201 +v 0 0.20702 0.762635 +v 0.035033 0.18494 0.809623 +v 0.0703592 0.199987 0.759265 +v 0.0354469 0.205232 0.761742 +v 0.0337403 0.129119 0.889852 +v 0.0684286 0.154761 0.849486 +v 0 0.160642 0.853891 +v 0.0344822 0.159128 0.852718 +v 0.10286 0.172311 0.802347 +v 0.0994805 0.118705 0.880737 +v 0.101303 0.147713 0.844481 +v 0.104202 0.191409 0.755412 +v 0 -0.422236 0.0297518 +v 0.0290027 -0.401336 0.00260959 +v 0.0619855 -0.419454 0.0516405 +v 0.032544 -0.433336 0.0684456 +v 0.0312142 -0.420036 0.03584 +v 0.024587 -0.350255 -0.0669927 +v 0.0524989 -0.374486 -0.0268658 +v 0 -0.38147 -0.0341137 +v 0.0265726 -0.377866 -0.0315624 +v 0.0804386 -0.407577 0.025012 +v 0.0781392 -0.343402 -0.0680291 +v 0.0771327 -0.378765 -0.022981 +v 0.101981 -0.43742 0.118873 +v 0.0918712 -0.426509 0.0746889 +v 0 -0.369655 0.853165 +v 0.0162142 -0.396858 0.808469 +v 0.032518 -0.377955 0.851217 +v 0.0173499 -0.340897 0.891348 +v 0.0161103 -0.370733 0.852319 +v 0.0190571 -0.436735 0.723869 +v 0.0352263 -0.426311 0.757202 +v 0 -0.417485 0.766409 +v 0.0173127 -0.418962 0.764189 +v 0.0473693 -0.423079 0.799815 +v 0.0641499 -0.454693 0.696538 +v 0.0543417 -0.44245 0.745122 +v 0.0576974 -0.360469 0.893822 +v 0.0495204 -0.395304 0.851292 +v 0 0.284012 0.356829 +v 0.0403407 0.264584 0.4009 +v 0.08278 0.283223 0.354838 +v 0.0418935 0.284411 0.356338 +v 0.0772361 0.242537 0.445498 +v 0 0.24666 0.447191 +v 0.0389355 0.245943 0.446792 +v 0.117787 0.25622 0.397308 +v 0.114267 0.235186 0.443214 +v 0.121652 0.278062 0.352302 +v 0 0.337744 0.0495788 +v 0.0441574 0.329119 0.0693112 +v 0.084777 0.331134 0.0392602 +v 0.0448664 0.351036 0.0368917 +v 0.0436281 0.336529 0.047541 +v 0.0891709 0.320583 0.0906503 +v 0 0.327327 0.102505 +v 0.0455092 0.326229 0.0998335 +v 0.122579 0.311429 0.0436831 +v 0.129137 0.308034 0.0737864 +v 0.125569 0.33518 0.0110101 +v 0.120968 0.319807 0.0225689 +v 0 0.450581 0.0596803 +v 0.0541098 0.40816 0.0483714 +v 0.116503 0.442256 0.0399308 +v 0.0632284 0.496693 0.0522852 +v 0.0593708 0.448955 0.0551193 +v 0.0954346 0.370179 0.029827 +v 0 0.37634 0.0420973 +v 0.0488177 0.375217 0.039732 +v 0.153438 0.391277 0.0121446 +v 0.13765 0.35956 0.0095734 +v 0.18104 0.470039 0.00485434 +v 0.169159 0.42866 0.0126096 +v 0 0.570891 -0.534672 +v 0.0626485 0.640189 -0.506046 +v 0.130136 0.568004 -0.528764 +v 0.0692761 0.505582 -0.562042 +v 0.0664738 0.570216 -0.533525 +v 0.0536794 0.762368 -0.447664 +v 0.113201 0.701726 -0.474505 +v 0 0.709164 -0.479338 +v 0.0582379 0.707055 -0.477971 +v 0.199905 0.685497 -0.462496 +v 0.174025 0.632377 -0.495223 +v 0.150533 0.744043 -0.44196 +v 0.161614 0.694175 -0.469576 +v 0.199187 0.49892 -0.545668 +v 0.232047 0.565216 -0.501918 +v 0.188173 0.564066 -0.51907 +v 0 0.376475 -0.648788 +v 0.0711811 0.413275 -0.623292 +v 0.138282 0.375681 -0.645424 +v 0.0726958 0.340957 -0.664799 +v 0.0716465 0.376815 -0.648416 +v 0.138821 0.452917 -0.589054 +v 0 0.45452 -0.593995 +v 0.0706181 0.454733 -0.593233 +v 0.199873 0.404748 -0.612935 +v 0.202195 0.446614 -0.579567 +v 0.193634 0.339499 -0.652866 +v 0.194895 0.370921 -0.637938 +v 0 -0.233549 0.959877 +v 0.0240468 -0.271835 0.943264 +v 0.057123 -0.235922 0.956621 +v 0.0306399 -0.195728 0.970285 +v 0.0277858 -0.234252 0.959139 +v 0.0425527 -0.311463 0.921053 +v 0 -0.306916 0.921405 +v 0.0202817 -0.307657 0.921165 +v 0.0802769 -0.277764 0.939515 +v 0.0688023 -0.319918 0.921674 +v 0.0956803 -0.199455 0.960676 +v 0.0895627 -0.238122 0.952018 +v 0 -0.322733 -0.103397 +v 0.0238367 -0.283103 -0.139843 +v 0.049547 -0.311956 -0.105817 +v 0.023709 -0.319134 -0.103998 +v 0.0267024 -0.190718 -0.197111 +v 0.0521008 -0.23408 -0.173683 +v 0 -0.242929 -0.170415 +v 0.0248684 -0.240765 -0.171792 +v 0.0816243 -0.264189 -0.144485 +v 0.0878074 -0.176513 -0.193941 +v 0.0840611 -0.222685 -0.173847 +v 0.0796433 -0.304819 -0.108871 +v 0 -0.132321 -0.213832 +v 0.0321871 -0.0691596 -0.222731 +v 0.0599751 -0.128388 -0.209467 +v 0.0292367 -0.131565 -0.213064 +v 0.0381981 0.0419961 -0.235526 +v 0.0713902 -0.00682142 -0.215572 +v 0 -0.00964083 -0.233734 +v 0.035269 -0.00935459 -0.229192 +v 0.101087 -0.0620719 -0.200364 +v 0.115674 0.055105 -0.187883 +v 0.109216 -0.00036684 -0.192884 +v 0.0937169 -0.121882 -0.201748 +v 0 0.0779149 -0.251636 +v 0.0428926 0.103386 -0.257977 +v 0.0803711 0.0844567 -0.225271 +v 0.0406901 0.0790388 -0.244814 +v 0.0470212 0.120443 -0.299626 +v 0.0884331 0.12573 -0.258533 +v 0 0.114136 -0.282485 +v 0.0449537 0.11665 -0.27594 +v 0.120922 0.124855 -0.209363 +v 0.138478 0.148595 -0.265069 +v 0.128964 0.142918 -0.232488 +v 0.118034 0.096215 -0.193935 +v 0 0.113801 -0.334664 +v 0.0518947 0.108853 -0.365753 +v 0.097999 0.124878 -0.319976 +v 0.0492429 0.116377 -0.329956 +v 0.0595919 0.101024 -0.449026 +v 0.107541 0.107031 -0.401861 +v 0 0.101009 -0.408276 +v 0.0552525 0.102268 -0.405836 +v 0.150911 0.126322 -0.356271 +v 0.16045 0.112915 -0.441079 +v 0.153901 0.116281 -0.399697 +v 0.145782 0.140078 -0.308863 +v 0 0.109177 -0.495145 +v 0.0709982 0.126709 -0.538642 +v 0.125551 0.112279 -0.490196 +v 0.065189 0.10952 -0.494143 +v 0.0790718 0.182988 -0.615599 +v 0.1475 0.153854 -0.575332 +v 0 0.151226 -0.580589 +v 0.0759743 0.151547 -0.579976 +v 0.194944 0.134806 -0.523346 +v 0.219301 0.191387 -0.600189 +v 0.210129 0.15949 -0.56385 +v 0.176258 0.119186 -0.482359 +v 0 0.219576 -0.64342 +v 0.0775425 0.260206 -0.661002 +v 0.154044 0.222564 -0.638941 +v 0.0792455 0.219987 -0.642965 +v 0.144378 0.302534 -0.665208 +v 0 0.300969 -0.668909 +v 0.0750102 0.301309 -0.668637 +v 0.213772 0.26767 -0.647803 +v 0.202463 0.304851 -0.656009 +v 0.21995 0.228648 -0.628685 +v 0.126715 0.537337 0.0111468 +v 0.0606884 0.60785 0.00104436 +v 0 0.554408 0.0408567 +v 0.0643107 0.550463 0.0321785 +v 0.191637 0.550233 -0.0477524 +v 0.185308 0.513743 -0.0172354 +v 0.171165 0.605799 -0.0764289 +v 0.209701 0.569968 -0.0807895 +v 0.126096 0.69557 -0.127071 +v 0.0987466 0.656786 -0.062447 +v 0.142824 0.650926 -0.0969906 +v 0 0.672219 -0.0228265 +v 0.0403517 0.7183 -0.0719016 +v 0.0504326 0.666442 -0.034872 +v 0.237614 0.630468 -0.469873 +v 0.258514 0.602197 -0.445199 +v 0.253217 0.578269 -0.474783 +v 0.212896 0.714905 -0.428435 +v 0.240943 0.662224 -0.43894 +v 0.224501 0.676789 -0.452578 +v 0.246529 0.67248 -0.397952 +v 0.254771 0.635976 -0.4207 +v 0.226436 0.912723 -0.26973 +v 0.21544 0.938681 -0.279423 +v 0.201014 0.943338 -0.25145 +v 0.214224 0.916672 -0.246046 +v 0.216965 0.931825 -0.261167 +v 0.196917 0.927676 -0.311546 +v 0.191876 0.948989 -0.288378 +v 0.216862 0.918936 -0.303965 +v 0.207634 0.937732 -0.29671 +v 0.1537 0.943252 -0.269054 +v 0.17745 0.953646 -0.260405 +v 0.165912 0.939303 -0.292739 +v 0.173109 0.951035 -0.277835 +v 0.179801 0.930945 -0.23207 +v 0.159856 0.939686 -0.239651 +v 0.180783 0.946411 -0.244635 +v 0.207814 0.759869 -0.30299 +v 0.191438 0.774734 -0.312022 +v 0.199084 0.77337 -0.281405 +v 0.209996 0.761876 -0.268358 +v 0.201734 0.767127 -0.28955 +v 0.161743 0.793141 -0.342758 +v 0.178221 0.788374 -0.325575 +v 0.180956 0.7796 -0.34144 +v 0.178357 0.783728 -0.331262 +v 0.18742 0.811743 -0.321532 +v 0.192387 0.789092 -0.301842 +v 0.165819 0.804418 -0.335288 +v 0.181068 0.796668 -0.322844 +v 0.202175 0.775482 -0.251997 +v 0.203233 0.797472 -0.273932 +v 0.199221 0.78193 -0.2764 +v 0.181336 0.804317 -0.228606 +v 0.151415 0.801648 -0.215482 +v 0.168503 0.781447 -0.210541 +v 0.192516 0.777938 -0.227759 +v 0.174268 0.789156 -0.220565 +v 0.108345 0.822919 -0.221075 +v 0.12229 0.805309 -0.211386 +v 0.135327 0.828572 -0.217894 +v 0.128262 0.813355 -0.215464 +v 0.103071 0.800257 -0.198013 +v 0.137434 0.789176 -0.20042 +v 0.0963023 0.812563 -0.21585 +v 0.114773 0.801816 -0.205592 +v 0.186175 0.766882 -0.204739 +v 0.153638 0.772539 -0.191376 +v 0.162292 0.776737 -0.200861 +v 0.13845 0.801677 -0.350685 +v 0.119159 0.809804 -0.331351 +v 0.143329 0.804627 -0.337252 +v 0.140844 0.802002 -0.341998 +v 0.086003 0.820458 -0.291304 +v 0.10501 0.817882 -0.310157 +v 0.0934554 0.817549 -0.318853 +v 0.100185 0.816042 -0.313185 +v 0.116614 0.840248 -0.308051 +v 0.127696 0.819206 -0.325202 +v 0.0961567 0.829666 -0.288835 +v 0.109848 0.825231 -0.308777 +v 0.153713 0.826966 -0.334024 +v 0.147191 0.8121 -0.335056 +v 0.0710179 0.824335 -0.270682 +v 0.0780919 0.822576 -0.248928 +v 0.084054 0.824638 -0.268864 +v 0.0786961 0.822795 -0.269513 +v 0.0899479 0.821575 -0.232115 +v 0.0751675 0.819879 -0.228529 +v 0.084018 0.819324 -0.230668 +v 0.102029 0.843892 -0.232989 +v 0.0888081 0.831892 -0.249223 +v 0.095203 0.828981 -0.232883 +v 0.0959818 0.847028 -0.267898 +v 0.0891348 0.832003 -0.268429 +v 0.208076 0.764415 -0.241789 +v 0.226075 0.759994 -0.240858 +v 0.231902 0.754223 -0.26947 +v 0.216972 0.759952 -0.252956 +v 0.20189 0.765574 -0.22074 +v 0.201854 0.770051 -0.234112 +v 0.215759 0.757673 -0.200462 +v 0.223444 0.760451 -0.217689 +v 0.205912 0.761992 -0.209879 +v 0.264144 0.760816 -0.243923 +v 0.265103 0.760852 -0.220189 +v 0.240714 0.760641 -0.229576 +v 0.278995 0.751255 -0.279238 +v 0.277858 0.727498 -0.319523 +v 0.234872 0.742799 -0.306286 +v 0.256224 0.744786 -0.293184 +v 0.311167 0.763685 -0.236173 +v 0.343965 0.756617 -0.269721 +v 0.300161 0.759231 -0.259113 +v 0.37536 0.738148 -0.30116 +v 0.402685 0.758643 -0.236201 +v 0.390758 0.753705 -0.27032 +v 0.317986 0.708047 -0.333577 +v 0.358205 0.712515 -0.324745 +v 0.258236 0.693552 -0.356883 +v 0.284726 0.698216 -0.343913 +v 0.183529 0.754714 -0.188935 +v 0.248651 0.737773 -0.18066 +v 0.277376 0.753251 -0.197126 +v 0.23327 0.750984 -0.191422 +v 0.329845 0.712932 -0.159268 +v 0.178779 0.718135 -0.16643 +v 0.252112 0.713887 -0.166078 +v 0.409003 0.736167 -0.174314 +v 0.39942 0.710994 -0.155057 +v 0.352617 0.756796 -0.208565 +v 0.409429 0.752424 -0.202781 +v 0.303456 0.759588 -0.213776 +v 0.0705006 0.811753 -0.205807 +v 0.0602661 0.797425 -0.177797 +v 0.106741 0.782082 -0.178969 +v 0.0845451 0.798015 -0.188581 +v 0 0.80352 -0.16013 +v 0.0359638 0.781745 -0.13792 +v 0.0258744 0.814456 -0.19275 +v 0.0313039 0.800824 -0.16616 +v 0.0771688 0.744134 -0.128582 +v 0 0.760454 -0.0953915 +v 0.0372542 0.755486 -0.106376 +v 0.128352 0.75368 -0.16956 +v 0.122404 0.729951 -0.151266 +v 0.140544 0.766364 -0.181936 +v 0.0269807 0.832763 -0.306956 +v 0.0647564 0.824008 -0.337021 +v 0.0438017 0.818098 -0.377412 +v 0 0.831312 -0.342444 +v 0.0352238 0.828719 -0.341387 +v 0.105446 0.812324 -0.352131 +v 0.0673729 0.8251 -0.299446 +v 0.0829065 0.820245 -0.328154 +v 0.163948 0.787613 -0.366372 +v 0.134148 0.794627 -0.38492 +v 0.134862 0.801108 -0.364702 +v 0.0968568 0.789376 -0.411772 +v 0.176513 0.760515 -0.410655 +v 0.140375 0.776566 -0.412207 +v 0 0.800708 -0.414889 +v 0.0494105 0.797681 -0.413491 +v 0.0431316 0.822381 -0.222498 +v 0.0209585 0.83068 -0.246717 +v 0 0.825505 -0.217769 +v 0.0222752 0.824379 -0.219341 +v 0.0571055 0.825864 -0.248034 +v 0.0611506 0.820889 -0.225684 +v 0.0427143 0.830406 -0.274631 +v 0.0589761 0.827121 -0.27268 +v 0 0.834904 -0.275945 +v 0.0223763 0.833445 -0.275661 +v 0.192333 0.761236 -0.378584 +v 0.220893 0.723503 -0.390265 +v 0.20182 0.742487 -0.402976 +v 0.202503 0.759013 -0.342238 +v 0.185497 0.772855 -0.357643 +v 0.229147 0.73046 -0.348619 +v 0.217964 0.748268 -0.323878 +v 0.238328 0.704586 -0.373617 +v 0.182638 0.844163 -0.332751 +v 0.20855 0.866089 -0.317157 +v 0.208154 0.830042 -0.298948 +v 0.197796 0.836731 -0.320106 +v 0.225435 0.891324 -0.293612 +v 0.202088 0.898609 -0.32219 +v 0.216036 0.894273 -0.311279 +v 0.221713 0.885753 -0.253374 +v 0.22169 0.856724 -0.273536 +v 0.227222 0.886884 -0.273083 +v 0.207473 0.823979 -0.249259 +v 0.212209 0.824662 -0.273398 +v 0.113654 0.869597 -0.287244 +v 0.140188 0.893495 -0.304854 +v 0.144889 0.85895 -0.323167 +v 0.127225 0.865094 -0.306986 +v 0.170407 0.915574 -0.314537 +v 0.141278 0.921251 -0.283964 +v 0.154011 0.919177 -0.300925 +v 0.17602 0.88052 -0.329499 +v 0.186655 0.907214 -0.322451 +v 0.164181 0.851772 -0.332764 +v 0.125921 0.862724 -0.222037 +v 0.126235 0.896792 -0.232757 +v 0.106278 0.87162 -0.248059 +v 0.112672 0.868658 -0.232446 +v 0.136706 0.926532 -0.249134 +v 0.152825 0.914652 -0.226568 +v 0.141818 0.921807 -0.235425 +v 0.120264 0.900007 -0.266157 +v 0.136018 0.925025 -0.266007 +v 0.106638 0.871852 -0.266963 +v 0.201725 0.863227 -0.234578 +v 0.169297 0.842653 -0.222278 +v 0.191458 0.831381 -0.232334 +v 0.191735 0.902282 -0.228209 +v 0.209229 0.892731 -0.238166 +v 0.158724 0.882351 -0.220155 +v 0.171199 0.908866 -0.224253 +v 0.146124 0.853579 -0.218747 +v 0.183641 -0.455489 0.534379 +v 0.20511 -0.461837 0.475502 +v 0.228365 -0.446181 0.420977 +v 0.21326 -0.450303 0.478539 +v 0.102981 -0.465723 0.632974 +v 0.142559 -0.466669 0.57469 +v 0.143787 -0.462243 0.587914 +v 0.132033 -0.481167 0.556781 +v 0.17086 -0.474631 0.521789 +v 0.109552 -0.472057 0.595485 +v 0.140849 -0.473458 0.563316 +v 0.206663 -0.472505 0.418626 +v 0.176881 -0.48852 0.469991 +v 0.194975 -0.474631 0.472428 +v 0.0439995 -0.453929 0.682063 +v 0.0755892 -0.465387 0.639018 +v 0.0705061 -0.461083 0.663389 +v 0 -0.448613 0.69461 +v 0.0238268 -0.46053 0.664171 +v 0.0210984 -0.44987 0.691901 +v 0.0329053 -0.483094 0.604968 +v 0.0549351 -0.471091 0.629642 +v 0 -0.470799 0.638539 +v 0.0276324 -0.470883 0.636565 +v 0.0917758 -0.479034 0.591505 +v 0.0815781 -0.471375 0.616771 +v 0.065741 -0.440111 0.119726 +v 0.0317646 -0.445352 0.134276 +v 0 -0.441491 0.0941719 +v 0.0323291 -0.440606 0.100743 +v 0.138015 -0.443895 0.192281 +v 0.0965198 -0.444834 0.175662 +v 0.101319 -0.442167 0.150389 +v 0.0981278 -0.457279 0.230677 +v 0.0636123 -0.450028 0.182161 +v 0.124102 -0.450719 0.228684 +v 0.0942201 -0.449501 0.201118 +v 0 -0.451738 0.166652 +v 0.034368 -0.461296 0.211229 +v 0.0320458 -0.45108 0.17059 +v 0.205661 -0.440923 0.30331 +v 0.163536 -0.447685 0.255959 +v 0.174785 -0.442414 0.24495 +v 0.213095 -0.454425 0.36305 +v 0.224677 -0.442616 0.362277 +v 0.178344 -0.481123 0.364052 +v 0.179537 -0.460826 0.31166 +v 0.199389 -0.4673 0.363772 +v 0.138385 -0.462583 0.271465 +v 0.153491 -0.454897 0.266081 +v 0 -0.501354 0.566258 +v 0.0472884 -0.515301 0.519274 +v 0.0774159 -0.49456 0.56248 +v 0.0400356 -0.499329 0.565268 +v 0.0552219 -0.529321 0.415644 +v 0.102374 -0.516827 0.468605 +v 0 -0.53078 0.469003 +v 0.0529288 -0.526727 0.468796 +v 0.12906 -0.497175 0.517019 +v 0.151776 -0.503865 0.416665 +v 0.144853 -0.503338 0.468859 +v 0.109485 -0.488354 0.558077 +v 0 -0.522771 0.361177 +v 0.046641 -0.500432 0.308431 +v 0.101727 -0.509066 0.362546 +v 0.0524328 -0.518796 0.361628 +v 0.0778956 -0.474931 0.261875 +v 0 -0.481524 0.256229 +v 0.0399262 -0.479506 0.257737 +v 0.12954 -0.482953 0.312862 +v 0.111951 -0.469275 0.268257 +v 0.144743 -0.495777 0.363499 +v 0.16267 -0.0297463 0.947597 +v 0.137897 -0.0298265 0.961061 +v 0.139042 -0.0451633 0.963659 +v 0.164631 -0.0504489 0.951176 +v 0.150007 -0.038161 0.957034 +v 0.109331 -0.0304408 0.974293 +v 0.122462 -0.037914 0.969963 +v 0.130968 -0.0135459 0.956851 +v 0.124172 -0.0273895 0.966259 +v 0.133714 -0.0642499 0.965416 +v 0.109851 -0.0516794 0.976283 +v 0.125245 -0.0487781 0.969619 +v 0.172782 -0.0812671 0.947651 +v 0.213918 -0.078022 0.922841 +v 0.18873 -0.0434748 0.935764 +v 0.185903 -0.064746 0.940486 +v 0.119758 -0.0911109 0.968067 +v 0.163882 -0.120989 0.949271 +v 0.149065 -0.0885975 0.957545 +v 0.209867 -0.161573 0.925244 +v 0.133001 -0.161124 0.956956 +v 0.170754 -0.160591 0.943861 +v 0.24743 -0.125194 0.898745 +v 0.2493 -0.167014 0.898651 +v 0.247517 -0.0516572 0.891815 +v 0.248772 -0.0872467 0.896118 +v 0.206641 -0.0168625 0.913183 +v 0.165953 -0.00373407 0.934179 +v 0.181563 -0.0218941 0.9332 +v 0.225597 0.0165132 0.878354 +v 0.237857 -0.0169093 0.886885 +v 0.188508 0.055577 0.881861 +v 0.216542 0.0481267 0.863247 +v 0.128713 0.0776757 0.9026 +v 0.155037 0.0342159 0.918365 +v 0.159167 0.0664178 0.894094 +v 0.116698 0.0146029 0.948102 +v 0.143447 0.00727528 0.940085 +v 0.0272441 0.00174637 0.985368 +v 0.0591053 0.0273947 0.96148 +v 0.0314129 0.062618 0.944549 +v 0 0.031249 0.967483 +v 0.0296124 0.0304081 0.965777 +v 0.0939443 0.0532189 0.93429 +v 0.0802969 -0.0053962 0.974961 +v 0.0883591 0.0217178 0.955411 +v 0.0652762 0.0925539 0.91594 +v 0.0973395 0.0863776 0.910036 +v 0 0.0974522 0.921309 +v 0.032753 0.0962353 0.919852 +v 0.0640997 -0.158632 0.974036 +v 0.0313918 -0.121887 0.983992 +v 0 -0.156323 0.979553 +v 0.0317497 -0.157085 0.978196 +v 0.0956523 -0.123707 0.972085 +v 0.0976501 -0.160225 0.966985 +v 0.0810019 -0.0733797 0.982855 +v 0.05977 -0.0942344 0.98419 +v 0.0898671 -0.0931811 0.977114 +v 0 -0.0930316 0.990478 +v 0.0273784 -0.0760818 0.993721 +v 0.0298425 -0.0936976 0.988793 +v 0.0955999 -0.0476973 0.985969 +v 0.0789269 -0.06284 0.994959 +v 0.0864529 -0.0640166 0.98579 +v 0.0940951 -0.0565412 0.98502 +v 0.0861068 -0.0306433 0.989153 +v 0.0788425 -0.0488271 1.00064 +v 0.0938769 -0.0385712 0.986828 +v 0.0525009 -0.0662129 1.0231 +v 0.0666347 -0.0644079 1.00864 +v 0.0598411 -0.0536198 1.01768 +v 0.0652608 -0.0582549 1.01251 +v 0.0598989 -0.0753391 1.00401 +v 0.0525276 -0.0775374 1.01483 +v 0.0652946 -0.0700523 1.00523 +v 0.0476184 -0.0223971 1.0006 +v 0.0582598 -0.0403976 1.0119 +v 0.0694706 -0.025394 0.994502 +v 0 -0.0210975 1.00705 +v 0.0209047 -0.039677 1.02317 +v 0.0242006 -0.0212264 1.00515 +v 0.0152462 -0.0676801 1.04602 +v 0.0344846 -0.0534302 1.03232 +v 0 -0.0555541 1.03946 +v 0.0177789 -0.0547726 1.03745 +v 0.0426567 -0.0627588 1.03251 +v 0.0490439 -0.0525287 1.02501 +v 0.0477856 -0.0718253 0.995571 +v 0.0209476 -0.0779737 1.00716 +v 0 -0.0724905 1.00177 +v 0.0242757 -0.0726037 0.999895 +v 0.0583871 -0.073576 0.998233 +v 0.0697639 -0.0690371 0.990088 +v 0.0427012 -0.0854758 1.01505 +v 0.0345351 -0.0845283 1.01121 +v 0.0491057 -0.0804193 1.00671 +v 0 -0.0876552 1.01738 +v 0.0152667 -0.0940994 1.02438 +v 0.0178069 -0.0869021 1.01538 +v 0.0271444 -0.0763309 1.04139 +v 0.0394909 -0.0796254 1.02906 +v 0.0399318 -0.0720589 1.03309 +v 0 -0.0809251 1.049 +v 0.0132272 -0.0889316 1.04223 +v 0.0137291 -0.0795664 1.04692 +v 0.0271637 -0.0905263 1.02914 +v 0 -0.0956202 1.03609 +v 0.01374 -0.0942759 1.03402 +v 0.0399551 -0.0846544 1.02277 +v -0.341299 -0.375944 0.366232 +v -0.317818 -0.392423 0.305485 +v -0.289638 -0.411984 0.363044 +v -0.313121 -0.40468 0.424303 +v -0.317288 -0.397295 0.364448 +v -0.312495 -0.42258 0.208415 +v -0.274846 -0.418754 0.252658 +v -0.350284 -0.364453 0.244783 +v -0.316601 -0.396416 0.250199 +v -0.194817 -0.437402 0.239358 +v -0.251544 -0.422435 0.302332 +v -0.2099 -0.457622 0.202318 +v -0.231211 -0.430966 0.245486 +v -0.261632 -0.427221 0.422701 +v -0.23935 -0.43199 0.361842 +v -0.262332 -0.422664 0.362137 +v -0.275025 -0.421949 0.482067 +v -0.291362 -0.413379 0.536815 +v -0.328162 -0.387696 0.483083 +v -0.303426 -0.408222 0.482265 +v -0.225399 -0.440193 0.480871 +v -0.222989 -0.439421 0.53835 +v -0.247502 -0.431674 0.481825 +v -0.164011 -0.483033 0.631406 +v -0.236564 -0.444228 0.584476 +v -0.156119 -0.458526 0.595789 +v -0.191143 -0.453861 0.591118 +v -0.315111 -0.397679 0.592146 +v -0.26979 -0.455493 0.624003 +v -0.280089 -0.425608 0.586435 +v -0.339519 -0.257182 -0.0802831 +v -0.283535 -0.198083 -0.11242 +v -0.23546 -0.269794 -0.12322 +v -0.300873 -0.335808 -0.11045 +v -0.292915 -0.260195 -0.110308 +v -0.26898 -0.103901 -0.112945 +v -0.224047 -0.163495 -0.142015 +v -0.318497 -0.140059 -0.0746981 +v -0.274851 -0.146856 -0.114171 +v -0.123113 -0.206388 -0.170045 +v -0.173106 -0.230478 -0.142628 +v -0.172014 -0.141551 -0.170002 +v -0.171621 -0.184999 -0.160037 +v -0.176383 -0.34915 -0.10631 +v -0.119478 -0.295776 -0.113872 +v -0.174532 -0.282877 -0.121531 +v -0.273281 0.0420733 -0.0438498 +v -0.232462 0.00608204 -0.106821 +v -0.269878 -0.0318881 -0.0928838 +v -0.307808 -0.00318692 -0.0317095 +v -0.272342 0.00331308 -0.0724007 +v -0.148915 0.00578811 -0.165362 +v -0.182883 -0.0457092 -0.157469 +v -0.199052 0.0623656 -0.105989 +v -0.190658 0.0074224 -0.137241 +v -0.222802 -0.0788504 -0.141507 +v -0.131964 -0.111136 -0.188613 +v -0.176218 -0.0952439 -0.168768 +v -0.308256 -0.0631453 -0.0619102 +v -0.26804 -0.0666021 -0.106124 +v -0.26887 -0.396352 0.909752 +v -0.214141 -0.334681 0.919903 +v -0.263105 -0.289222 0.900577 +v -0.30851 -0.340088 0.875405 +v -0.266995 -0.336923 0.904292 +v -0.104904 -0.328487 0.922781 +v -0.164801 -0.284207 0.93026 +v -0.149733 -0.3934 0.920339 +v -0.15673 -0.332639 0.924128 +v -0.172003 -0.202637 0.93974 +v -0.215216 -0.244729 0.920604 +v -0.126656 -0.240414 0.945024 +v -0.169955 -0.242358 0.935335 +v -0.293898 -0.252639 0.867139 +v -0.253262 -0.209214 0.897882 +v -0.258195 -0.248301 0.898482 +v -0.375987 -0.340814 -0.0337268 +v -0.380901 -0.277243 0.032671 +v -0.358457 -0.200112 -0.0267162 +v -0.367895 -0.263853 -0.0306343 +v -0.375596 -0.311145 0.175939 +v -0.382253 -0.237542 0.105277 +v -0.379176 -0.364086 0.102343 +v -0.381399 -0.294389 0.103665 +v -0.379025 -0.149836 0.112764 +v -0.369603 -0.166291 0.0406057 +v -0.385185 -0.214712 0.178025 +v -0.38088 -0.190046 0.108528 +v -0.342627 -0.106257 -0.015664 +v -0.349444 -0.148083 -0.0217878 +v -0.351404 -0.354331 0.427814 +v -0.367965 -0.307651 0.370431 +v -0.363729 -0.333817 0.306674 +v -0.35769 -0.345276 0.36828 +v -0.376188 -0.22098 0.374406 +v -0.380079 -0.252636 0.309953 +v -0.366553 -0.273812 0.432936 +v -0.373629 -0.265433 0.372527 +v -0.379525 -0.278609 0.243679 +v -0.386398 -0.194374 0.247084 +v -0.384425 -0.235652 0.245143 +v -0.369702 -0.323364 0.243084 +v -0.359143 -0.0454376 0.384517 +v -0.376221 -0.0834201 0.319025 +v -0.375379 -0.132559 0.377674 +v -0.363531 -0.0923241 0.440867 +v -0.369754 -0.0887861 0.380331 +v -0.380073 -0.0641595 0.195141 +v -0.385994 -0.115397 0.252169 +v -0.369328 -0.0337485 0.265179 +v -0.380479 -0.0754649 0.257209 +v -0.383633 -0.167556 0.313214 +v -0.386429 -0.137312 0.183762 +v -0.387444 -0.154662 0.24911 +v -0.370145 -0.182621 0.437038 +v -0.377148 -0.176656 0.375911 +v -0.338487 -0.0443826 0.00235778 +v -0.357964 -0.0317511 0.0731655 +v -0.331012 0.0171674 0.0389716 +v -0.336366 -0.0157204 0.0175237 +v -0.363023 -0.0919062 0.0524717 +v -0.339774 -0.073126 -0.00816016 +v -0.37698 -0.0821329 0.123634 +v -0.378431 -0.114848 0.117331 +v -0.363023 -0.0117289 0.147082 +v -0.372551 -0.0487428 0.133083 +v -0.324728 -0.29766 0.82767 +v -0.340911 -0.350598 0.77666 +v -0.336842 -0.40362 0.835552 +v -0.331904 -0.344898 0.831349 +v -0.311718 -0.219243 0.822794 +v -0.331546 -0.262105 0.774295 +v -0.317327 -0.257308 0.824743 +v -0.344609 -0.271269 0.661246 +v -0.340676 -0.308781 0.717453 +v -0.338685 -0.226798 0.720092 +v -0.339619 -0.266826 0.718796 +v -0.335933 -0.414813 0.716014 +v -0.334716 -0.360298 0.654176 +v -0.339263 -0.356428 0.715872 +v -0.304296 -0.0566442 0.818942 +v -0.32815 -0.0982774 0.774453 +v -0.309753 -0.137557 0.821642 +v -0.282982 -0.0932074 0.86163 +v -0.309064 -0.0966912 0.82069 +v -0.349859 -0.0980743 0.670701 +v -0.342261 -0.141944 0.72292 +v -0.335097 -0.0554519 0.724795 +v -0.341372 -0.0985454 0.724072 +v -0.328063 -0.182474 0.773912 +v -0.348891 -0.186539 0.666645 +v -0.340465 -0.184932 0.72153 +v -0.284251 -0.173813 0.864211 +v -0.309915 -0.178867 0.822052 +v -0.364199 -0.140124 0.498352 +v -0.3576 -0.096426 0.55865 +v -0.350887 -0.0507559 0.502911 +v -0.360004 -0.0947951 0.500374 +v -0.363053 -0.232129 0.494204 +v -0.360088 -0.187609 0.554338 +v -0.364779 -0.186112 0.496433 +v -0.356689 -0.14249 0.613383 +v -0.35206 -0.232064 0.608144 +v -0.355112 -0.187591 0.610995 +v -0.34723 -0.0531297 0.617509 +v -0.354744 -0.0974434 0.615492 +v -0.338808 -0.358381 0.541229 +v -0.354812 -0.320109 0.488079 +v -0.344689 -0.357576 0.485189 +v -0.344841 -0.317709 0.600763 +v -0.335024 -0.360119 0.596759 +v -0.354746 -0.277669 0.548235 +v -0.349578 -0.27523 0.604646 +v -0.360332 -0.277544 0.491251 +v -0.270021 0.183796 0.151405 +v -0.250535 0.219935 0.200112 +v -0.22988 0.247545 0.157829 +v -0.253104 0.203435 0.118078 +v -0.251096 0.217673 0.158942 +v -0.247672 0.201215 0.285394 +v -0.224342 0.248556 0.249012 +v -0.273837 0.172969 0.230557 +v -0.249328 0.213762 0.242242 +v -0.166122 0.2964 0.255682 +v -0.201028 0.279793 0.204606 +v -0.19325 0.264928 0.298974 +v -0.197174 0.276415 0.252836 +v -0.208445 0.255016 0.0997486 +v -0.173937 0.295795 0.151795 +v -0.204742 0.274117 0.153286 +v -0.238934 0.137098 0.472953 +v -0.21248 0.178956 0.429644 +v -0.243641 0.166107 0.375362 +v -0.269047 0.115689 0.415447 +v -0.241351 0.149381 0.423 +v -0.149393 0.222637 0.439843 +v -0.185529 0.224498 0.389084 +v -0.178799 0.187723 0.48375 +v -0.181979 0.203634 0.435289 +v -0.218341 0.218477 0.337805 +v -0.157504 0.266542 0.348704 +v -0.189327 0.246276 0.344018 +v -0.272811 0.14513 0.319056 +v -0.245762 0.184358 0.32963 +v -0.212012 0.0755801 0.841201 +v -0.188626 0.112308 0.821548 +v -0.217701 0.11212 0.775527 +v -0.235856 0.0765799 0.805621 +v -0.213324 0.0965225 0.811853 +v -0.13257 0.138159 0.837992 +v -0.163968 0.1484 0.789706 +v -0.159999 0.0987976 0.865373 +v -0.161693 0.126272 0.830304 +v -0.169138 0.174847 0.695193 +v -0.195015 0.146226 0.738197 +v -0.136442 0.179619 0.750387 +v -0.166543 0.164739 0.744396 +v -0.249108 0.0961373 0.728207 +v -0.226814 0.130295 0.684497 +v -0.222367 0.12354 0.732548 +v -0.264402 0.101968 0.520397 +v -0.233686 0.131486 0.579487 +v -0.207042 0.158534 0.530777 +v -0.236433 0.132176 0.525634 +v -0.201599 0.157166 0.637907 +v -0.258575 0.102323 0.628487 +v -0.230534 0.131902 0.632959 +v -0.139858 0.195421 0.647569 +v -0.173735 0.178964 0.589175 +v -0.171473 0.178284 0.642915 +v -0.143538 0.198754 0.539805 +v -0.176115 0.180806 0.535582 +v -0.337836 -0.00655256 0.448549 +v -0.320929 0.0389878 0.398635 +v -0.34742 0.00319315 0.333602 +v -0.342419 -0.00261151 0.390867 +v -0.298744 0.0894187 0.355449 +v -0.293232 0.0711038 0.460405 +v -0.296022 0.0786559 0.407077 +v -0.30121 0.115034 0.257783 +v -0.327429 0.0566863 0.291075 +v -0.300703 0.102007 0.305644 +v -0.351215 0.0204208 0.221415 +v -0.350974 0.0108683 0.277027 +v -0.308985 -0.0158364 0.772679 +v -0.30029 0.0266191 0.725054 +v -0.328122 -0.0112347 0.673608 +v -0.320738 -0.0133772 0.724898 +v -0.268509 -0.018423 0.854481 +v -0.274888 0.0183198 0.812257 +v -0.291897 -0.0177918 0.816142 +v -0.267341 0.0573644 0.769829 +v -0.24017 0.0457536 0.838346 +v -0.256292 0.0501447 0.807253 +v -0.281859 0.0674534 0.67711 +v -0.275748 0.0634772 0.725933 +v -0.239418 0.102195 -0.0351077 +v -0.213035 0.170022 -0.00953204 +v -0.181753 0.135303 -0.0848536 +v -0.20757 0.117335 -0.0616182 +v -0.298292 0.0729821 0.0271766 +v -0.265278 0.133372 0.0353559 +v -0.270541 0.0874645 -0.00640695 +v -0.236523 0.195781 0.0609139 +v -0.276588 0.155574 0.0981021 +v -0.258648 0.173682 0.0768666 +v -0.190293 0.237055 0.0258931 +v -0.212268 0.218116 0.0448664 +v -0.288873 0.0678482 0.57056 +v -0.311113 0.0304905 0.622016 +v -0.286019 0.0682635 0.624906 +v -0.315185 0.0311388 0.510574 +v -0.291063 0.0681481 0.515313 +v -0.334099 -0.00961306 0.563635 +v -0.335537 -0.00863692 0.506376 +v -0.332102 -0.0102295 0.619617 +v -0.324423 0.0791082 0.189745 +v -0.33595 0.0447295 0.115485 +v -0.346277 0.0318576 0.16704 +v -0.295396 0.137443 0.169109 +v -0.299573 0.127115 0.211987 +v -0.305188 0.103086 0.100412 +v -0.288286 0.145212 0.129998 +v -0.320025 0.0585873 0.0683354 +v -0.177314 0.204818 -0.0510199 +v -0.167034 0.18223 -0.122798 +v -0.149034 0.119255 -0.152767 +v -0.168725 0.158519 -0.103729 +v -0.159665 0.285267 0.0452783 +v -0.167426 0.259011 -0.0241111 +v -0.175009 0.248965 0.00116269 +v -0.17918 0.290497 -0.0609743 +v -0.177164 0.238112 -0.093383 +v -0.149721 0.3008 -0.00470029 +v -0.168557 0.27236 -0.0447148 +v -0.160058 0.168229 -0.195838 +v -0.194921 0.221357 -0.173014 +v -0.175228 0.201681 -0.146613 +v -0.21819 0.281995 -0.133552 +v -0.26422 0.274293 -0.228207 +v -0.233098 0.21084 -0.267301 +v -0.227725 0.245742 -0.199837 +v -0.173263 0.341693 -0.0238379 +v -0.225521 0.344757 -0.0845003 +v -0.200073 0.314908 -0.0732157 +v -0.267222 0.417414 -0.116444 +v -0.27622 0.344814 -0.176785 +v -0.21453 0.407775 -0.0317089 +v -0.249809 0.379204 -0.0978893 +v -0.306638 0.268641 -0.338166 +v -0.314639 0.343639 -0.292523 +v -0.294985 0.306469 -0.259249 +v -0.279797 0.207117 -0.366981 +v -0.240251 0.15911 -0.387649 +v -0.192666 0.159829 -0.308601 +v -0.238726 0.181983 -0.331175 +v -0.330786 0.26947 -0.445487 +v -0.307399 0.208213 -0.46356 +v -0.31171 0.235804 -0.406418 +v -0.259412 0.1698 -0.542722 +v -0.265715 0.160342 -0.469212 +v -0.305787 0.218563 -0.547441 +v -0.290901 0.186126 -0.509143 +v -0.195451 0.128497 -0.407372 +v -0.213461 0.12942 -0.465108 +v -0.233311 0.142158 -0.432916 +v -0.329541 0.345256 -0.410956 +v -0.321008 0.352655 -0.511417 +v -0.32675 0.280027 -0.535933 +v -0.333345 0.309542 -0.480189 +v -0.255976 0.429549 -0.563622 +v -0.289278 0.358786 -0.584918 +v -0.295245 0.436762 -0.484187 +v -0.295399 0.395443 -0.540067 +v -0.246645 0.312827 -0.640337 +v -0.296456 0.295786 -0.60247 +v -0.240548 0.35766 -0.62796 +v -0.274305 0.331026 -0.617491 +v -0.272516 0.239582 -0.609537 +v -0.307295 0.256707 -0.578835 +v -0.288912 -0.666279 -0.0831981 +v -0.233667 -0.718383 -0.0394682 +v -0.288313 -0.71953 0.0292002 +v -0.335047 -0.66747 -0.026194 +v -0.288523 -0.704927 -0.0329901 +v -0.136552 -0.67511 -0.0280042 +v -0.172796 -0.723594 0.0247169 +v -0.187443 -0.669698 -0.0818819 +v -0.179633 -0.708233 -0.0350267 +v -0.182766 -0.687312 0.135767 +v -0.227442 -0.724741 0.0933852 +v -0.136631 -0.686121 0.0787634 +v -0.176191 -0.716151 0.0857864 +v -0.327044 -0.674066 0.0872825 +v -0.276152 -0.679477 0.14116 +v -0.281161 -0.710704 0.0910758 +v -0.288217 -0.679435 0.838379 +v -0.248642 -0.724519 0.790895 +v -0.198896 -0.723335 0.85193 +v -0.2461 -0.678205 0.889508 +v -0.246831 -0.711912 0.845432 +v -0.24088 -0.688682 0.691628 +v -0.198408 -0.728532 0.734591 +v -0.283587 -0.684515 0.738785 +v -0.244434 -0.716483 0.736358 +v -0.115859 -0.693483 0.748115 +v -0.148661 -0.727347 0.795626 +v -0.157976 -0.694713 0.696986 +v -0.153047 -0.720555 0.741401 +v -0.15574 -0.680004 0.892121 +v -0.113033 -0.684171 0.844965 +v -0.151829 -0.713932 0.849146 +v -0.30391 -0.498066 0.668956 +v -0.32282 -0.565952 0.726198 +v -0.342489 -0.483419 0.78141 +v -0.331237 -0.488983 0.719836 +v -0.319732 -0.633454 0.786428 +v -0.28283 -0.632563 0.691009 +v -0.308326 -0.632734 0.733956 +v -0.294197 -0.618974 0.884469 +v -0.331331 -0.556659 0.842236 +v -0.315639 -0.625673 0.839496 +v -0.31354 -0.474577 0.887895 +v -0.337524 -0.478425 0.840051 +v -0.0969194 -0.478778 0.897495 +v -0.0774719 -0.570173 0.85133 +v -0.0654567 -0.515878 0.79543 +v -0.0634711 -0.431765 0.851899 +v -0.0707234 -0.496321 0.852392 +v -0.0840444 -0.64607 0.797118 +v -0.112805 -0.624088 0.888986 +v -0.0899111 -0.634521 0.847274 +v -0.119063 -0.647679 0.702012 +v -0.0832655 -0.591144 0.740087 +v -0.0943475 -0.648249 0.746058 +v -0.069956 -0.47422 0.735292 +v -0.106684 -0.534636 0.682874 +v -0.0773661 -0.528459 0.735056 +v -0.208287 -0.52835 0.637223 +v -0.252371 -0.581833 0.652832 +v -0.260651 -0.513618 0.642398 +v -0.15335 -0.595644 0.66033 +v -0.153645 -0.534978 0.650489 +v -0.20034 -0.651356 0.660475 +v -0.156436 -0.650983 0.672896 +v -0.244653 -0.641994 0.666514 +v -0.209392 -0.47177 0.928314 +v -0.149543 -0.554429 0.922812 +v -0.147798 -0.472236 0.922294 +v -0.262868 -0.552296 0.920108 +v -0.267734 -0.472455 0.917082 +v -0.203436 -0.628169 0.923071 +v -0.253551 -0.622939 0.912658 +v -0.153584 -0.625261 0.914716 +v -0.387436 -0.440321 0.0296682 +v -0.369537 -0.538419 0.0961211 +v -0.348561 -0.464054 0.158716 +v -0.376444 -0.45013 0.0999599 +v -0.354445 -0.427851 -0.0878125 +v -0.378455 -0.525308 -0.0356201 +v -0.380964 -0.432504 -0.0361787 +v -0.368236 -0.614976 0.0306267 +v -0.340742 -0.597899 -0.0798229 +v -0.364087 -0.605614 -0.0296813 +v -0.325558 -0.615423 0.139592 +v -0.354786 -0.614851 0.0904298 +v -0.12704 -0.448099 -0.0735785 +v -0.182701 -0.527846 -0.109937 +v -0.243518 -0.430642 -0.121062 +v -0.179139 -0.436248 -0.106528 +v -0.241923 -0.609859 -0.117359 +v -0.141316 -0.607217 -0.0730372 +v -0.186967 -0.607615 -0.104287 +v -0.304443 -0.521287 -0.117606 +v -0.296601 -0.602967 -0.109127 +v -0.305291 -0.427537 -0.115465 +v -0.25113 -0.502745 0.197094 +v -0.188536 -0.577394 0.174934 +v -0.148115 -0.512563 0.149929 +v -0.196177 -0.511769 0.183546 +v -0.293784 -0.559568 0.181063 +v -0.304357 -0.484216 0.189956 +v -0.233064 -0.638226 0.175543 +v -0.282371 -0.626877 0.167977 +v -0.145237 -0.635178 0.13052 +v -0.185474 -0.638484 0.162245 +v -0.0953701 -0.405611 -0.0214782 +v -0.0997946 -0.492468 0.0352712 +v -0.105712 -0.548895 -0.0268432 +v -0.102107 -0.469936 -0.0239275 +v -0.113288 -0.573273 0.0910993 +v -0.112515 -0.451919 0.0935688 +v -0.115559 -0.506404 0.0968639 +v -0.106751 -0.633108 0.0275567 +v -0.117988 -0.635837 0.0828 +v -0.114552 -0.619641 -0.0267392 +v -0.308658 0.43336 -0.368305 +v -0.285353 0.520853 -0.361551 +v -0.271184 0.525759 -0.460079 +v -0.291391 0.478507 -0.418527 +v -0.298509 0.427522 -0.236282 +v -0.317802 0.38717 -0.32759 +v -0.235335 0.485531 -0.0647615 +v -0.271214 0.498067 -0.167977 +v -0.272045 0.45855 -0.143225 +v -0.277875 0.55689 -0.190965 +v -0.282577 0.535883 -0.259681 +v -0.247008 0.54474 -0.114114 +v -0.271665 0.531425 -0.180446 +v -0.267 0.601931 -0.388185 +v -0.278055 0.600765 -0.320108 +v -0.278645 0.563976 -0.33172 +v -0.252363 0.682167 -0.15033 +v -0.326452 0.645309 -0.138504 +v -0.267679 0.610284 -0.129549 +v -0.192626 0.647576 -0.125774 +v -0.258116 0.645451 -0.13607 +v -0.430349 0.658277 -0.154382 +v -0.380321 0.61857 -0.152413 +v -0.388682 0.680406 -0.144893 +v -0.384792 0.647908 -0.143704 +v -0.35448 0.589213 -0.202564 +v -0.324346 0.587714 -0.15672 +v -0.401583 0.612716 -0.19176 +v -0.367842 0.597467 -0.17194 +v -0.239082 0.578957 -0.111996 +v -0.289471 0.569074 -0.162469 +v -0.279361 0.583208 -0.137022 +v -0.318359 0.584666 -0.230094 +v -0.294439 0.591849 -0.266039 +v -0.294318 0.572729 -0.209871 +v -0.380591 0.614582 -0.245535 +v -0.343967 0.620068 -0.286887 +v -0.347363 0.598425 -0.244565 +v -0.345079 0.681327 -0.333156 +v -0.312606 0.638668 -0.319124 +v -0.375881 0.662505 -0.310821 +v -0.34177 0.649107 -0.318477 +v -0.28588 0.662049 -0.349089 +v -0.290372 0.624108 -0.317788 +v -0.419572 0.658706 -0.261892 +v -0.444197 0.711394 -0.263256 +v -0.393743 0.706765 -0.3123 +v -0.412958 0.685943 -0.291128 +v -0.447289 0.655956 -0.196803 +v -0.417303 0.633713 -0.225256 +v -0.447397 0.702392 -0.15815 +v -0.471552 0.708579 -0.199184 +v -0.460337 0.681448 -0.17325 +v -0.43241 0.746455 -0.258303 +v -0.452589 0.744444 -0.206816 +v -0.460792 0.730831 -0.231063 +v -0.0467382 0.325284 0.136739 +v -0.0925539 0.320139 0.170699 +v -0.0462436 0.320164 0.221337 +v -0.0468991 0.323707 0.17766 +v -0.132936 0.312061 0.210485 +v -0.135299 0.30832 0.112598 +v -0.13572 0.310986 0.159838 +v -0.125628 0.296564 0.306829 +v -0.0886491 0.312396 0.263435 +v -0.129481 0.307575 0.259519 +v -0.0434892 0.30185 0.311934 +v -0.0450231 0.313323 0.266515 +v -0.0377827 0.232065 0.495188 +v -0.0735327 0.221293 0.545706 +v -0.0364517 0.2252 0.601479 +v -0.0369868 0.226526 0.54726 +v -0.107651 0.210086 0.597079 +v -0.111325 0.219111 0.491389 +v -0.109197 0.212143 0.543201 +v -0.105384 0.203917 0.704755 +v -0.0717153 0.218255 0.65442 +v -0.106456 0.208743 0.651454 +v -0.0357781 0.218679 0.710249 +v -0.0360809 0.22396 0.656319 +v -0.0703592 0.199987 0.759265 +v -0.035033 0.18494 0.809623 +v -0.0354469 0.205232 0.761742 +v -0.10286 0.172311 0.802347 +v -0.104202 0.191409 0.755412 +v -0.0994805 0.118705 0.880737 +v -0.0684286 0.154761 0.849486 +v -0.101303 0.147713 0.844481 +v -0.0337403 0.129119 0.889852 +v -0.0344822 0.159128 0.852718 +v -0.032544 -0.433336 0.0684456 +v -0.0619855 -0.419454 0.0516405 +v -0.0290027 -0.401336 0.00260959 +v -0.0312142 -0.420036 0.03584 +v -0.0804386 -0.407577 0.025012 +v -0.101981 -0.43742 0.118873 +v -0.0918712 -0.426509 0.0746889 +v -0.0781392 -0.343402 -0.0680291 +v -0.0524989 -0.374486 -0.0268658 +v -0.0771327 -0.378765 -0.022981 +v -0.024587 -0.350255 -0.0669927 +v -0.0265726 -0.377866 -0.0315624 +v -0.0173499 -0.340897 0.891348 +v -0.032518 -0.377955 0.851217 +v -0.0162142 -0.396858 0.808469 +v -0.0161103 -0.370733 0.852319 +v -0.0473693 -0.423079 0.799815 +v -0.0576974 -0.360469 0.893822 +v -0.0495204 -0.395304 0.851292 +v -0.0641499 -0.454693 0.696538 +v -0.0352263 -0.426311 0.757202 +v -0.0543417 -0.44245 0.745122 +v -0.0190571 -0.436735 0.723869 +v -0.0173127 -0.418962 0.764189 +v -0.08278 0.283223 0.354838 +v -0.0403407 0.264584 0.4009 +v -0.0418935 0.284411 0.356338 +v -0.117787 0.25622 0.397308 +v -0.121652 0.278062 0.352302 +v -0.0772361 0.242537 0.445498 +v -0.114267 0.235186 0.443214 +v -0.0389355 0.245943 0.446792 +v -0.0448664 0.351036 0.0368917 +v -0.084777 0.331134 0.0392602 +v -0.0441574 0.329119 0.0693112 +v -0.0436281 0.336529 0.047541 +v -0.122579 0.311429 0.0436831 +v -0.125569 0.33518 0.0110101 +v -0.120968 0.319807 0.0225689 +v -0.0891709 0.320583 0.0906503 +v -0.129137 0.308034 0.0737864 +v -0.0455092 0.326229 0.0998335 +v -0.0632284 0.496693 0.0522852 +v -0.116503 0.442256 0.0399308 +v -0.0541098 0.40816 0.0483714 +v -0.0593708 0.448955 0.0551193 +v -0.153438 0.391277 0.0121446 +v -0.18104 0.470039 0.00485434 +v -0.169159 0.42866 0.0126096 +v -0.0954346 0.370179 0.029827 +v -0.13765 0.35956 0.0095734 +v -0.0488177 0.375217 0.039732 +v -0.0692761 0.505582 -0.562042 +v -0.130136 0.568004 -0.528764 +v -0.0626485 0.640189 -0.506046 +v -0.0664738 0.570216 -0.533525 +v -0.232047 0.565216 -0.501918 +v -0.174025 0.632377 -0.495223 +v -0.199187 0.49892 -0.545668 +v -0.188173 0.564066 -0.51907 +v -0.150533 0.744043 -0.44196 +v -0.113201 0.701726 -0.474505 +v -0.199905 0.685497 -0.462496 +v -0.161614 0.694175 -0.469576 +v -0.0536794 0.762368 -0.447664 +v -0.0582379 0.707055 -0.477971 +v -0.0726958 0.340957 -0.664799 +v -0.138282 0.375681 -0.645424 +v -0.0711811 0.413275 -0.623292 +v -0.0716465 0.376815 -0.648416 +v -0.199873 0.404748 -0.612935 +v -0.193634 0.339499 -0.652866 +v -0.194895 0.370921 -0.637938 +v -0.138821 0.452917 -0.589054 +v -0.202195 0.446614 -0.579567 +v -0.0706181 0.454733 -0.593233 +v -0.0306399 -0.195728 0.970285 +v -0.057123 -0.235922 0.956621 +v -0.0240468 -0.271835 0.943264 +v -0.0277858 -0.234252 0.959139 +v -0.0802769 -0.277764 0.939515 +v -0.0956803 -0.199455 0.960676 +v -0.0895627 -0.238122 0.952018 +v -0.0425527 -0.311463 0.921053 +v -0.0688023 -0.319918 0.921674 +v -0.0202817 -0.307657 0.921165 +v -0.049547 -0.311956 -0.105817 +v -0.0238367 -0.283103 -0.139843 +v -0.023709 -0.319134 -0.103998 +v -0.0816243 -0.264189 -0.144485 +v -0.0796433 -0.304819 -0.108871 +v -0.0878074 -0.176513 -0.193941 +v -0.0521008 -0.23408 -0.173683 +v -0.0840611 -0.222685 -0.173847 +v -0.0267024 -0.190718 -0.197111 +v -0.0248684 -0.240765 -0.171792 +v -0.0599751 -0.128388 -0.209467 +v -0.0321871 -0.0691596 -0.222731 +v -0.0292367 -0.131565 -0.213064 +v -0.101087 -0.0620719 -0.200364 +v -0.0937169 -0.121882 -0.201748 +v -0.115674 0.055105 -0.187883 +v -0.0713902 -0.00682142 -0.215572 +v -0.109216 -0.00036684 -0.192884 +v -0.0381981 0.0419961 -0.235526 +v -0.035269 -0.00935459 -0.229192 +v -0.0803711 0.0844567 -0.225271 +v -0.0428926 0.103386 -0.257977 +v -0.0406901 0.0790388 -0.244814 +v -0.120922 0.124855 -0.209363 +v -0.118034 0.096215 -0.193935 +v -0.138478 0.148595 -0.265069 +v -0.0884331 0.12573 -0.258533 +v -0.128964 0.142918 -0.232488 +v -0.0470212 0.120443 -0.299626 +v -0.0449537 0.11665 -0.27594 +v -0.097999 0.124878 -0.319976 +v -0.0518947 0.108853 -0.365753 +v -0.0492429 0.116377 -0.329956 +v -0.150911 0.126322 -0.356271 +v -0.145782 0.140078 -0.308863 +v -0.16045 0.112915 -0.441079 +v -0.107541 0.107031 -0.401861 +v -0.153901 0.116281 -0.399697 +v -0.0595919 0.101024 -0.449026 +v -0.0552525 0.102268 -0.405836 +v -0.125551 0.112279 -0.490196 +v -0.0709982 0.126709 -0.538642 +v -0.065189 0.10952 -0.494143 +v -0.194944 0.134806 -0.523346 +v -0.176258 0.119186 -0.482359 +v -0.219301 0.191387 -0.600189 +v -0.1475 0.153854 -0.575332 +v -0.210129 0.15949 -0.56385 +v -0.0790718 0.182988 -0.615599 +v -0.0759743 0.151547 -0.579976 +v -0.154044 0.222564 -0.638941 +v -0.0775425 0.260206 -0.661002 +v -0.0792455 0.219987 -0.642965 +v -0.213772 0.26767 -0.647803 +v -0.21995 0.228648 -0.628685 +v -0.144378 0.302534 -0.665208 +v -0.202463 0.304851 -0.656009 +v -0.0750102 0.301309 -0.668637 +v -0.0606884 0.60785 0.00104436 +v -0.126715 0.537337 0.0111468 +v -0.0643107 0.550463 0.0321785 +v -0.0403517 0.7183 -0.0719016 +v -0.0987466 0.656786 -0.062447 +v -0.0504326 0.666442 -0.034872 +v -0.171165 0.605799 -0.0764289 +v -0.126096 0.69557 -0.127071 +v -0.142824 0.650926 -0.0969906 +v -0.191637 0.550233 -0.0477524 +v -0.209701 0.569968 -0.0807895 +v -0.185308 0.513743 -0.0172354 +v -0.258514 0.602197 -0.445199 +v -0.237614 0.630468 -0.469873 +v -0.253217 0.578269 -0.474783 +v -0.246529 0.67248 -0.397952 +v -0.240943 0.662224 -0.43894 +v -0.254771 0.635976 -0.4207 +v -0.212896 0.714905 -0.428435 +v -0.224501 0.676789 -0.452578 +v -0.214224 0.916672 -0.246046 +v -0.201014 0.943338 -0.25145 +v -0.21544 0.938681 -0.279423 +v -0.226436 0.912723 -0.26973 +v -0.216965 0.931825 -0.261167 +v -0.159856 0.939686 -0.239651 +v -0.17745 0.953646 -0.260405 +v -0.179801 0.930945 -0.23207 +v -0.180783 0.946411 -0.244635 +v -0.165912 0.939303 -0.292739 +v -0.191876 0.948989 -0.288378 +v -0.1537 0.943252 -0.269054 +v -0.173109 0.951035 -0.277835 +v -0.216862 0.918936 -0.303965 +v -0.196917 0.927676 -0.311546 +v -0.207634 0.937732 -0.29671 +v -0.209996 0.761876 -0.268358 +v -0.199084 0.77337 -0.281405 +v -0.191438 0.774734 -0.312022 +v -0.207814 0.759869 -0.30299 +v -0.201734 0.767127 -0.28955 +v -0.203233 0.797472 -0.273932 +v -0.192387 0.789092 -0.301842 +v -0.202175 0.775482 -0.251997 +v -0.199221 0.78193 -0.2764 +v -0.165819 0.804418 -0.335288 +v -0.178221 0.788374 -0.325575 +v -0.18742 0.811743 -0.321532 +v -0.181068 0.796668 -0.322844 +v -0.180956 0.7796 -0.34144 +v -0.161743 0.793141 -0.342758 +v -0.178357 0.783728 -0.331262 +v -0.192516 0.777938 -0.227759 +v -0.168503 0.781447 -0.210541 +v -0.151415 0.801648 -0.215482 +v -0.181336 0.804317 -0.228606 +v -0.174268 0.789156 -0.220565 +v -0.153638 0.772539 -0.191376 +v -0.137434 0.789176 -0.20042 +v -0.186175 0.766882 -0.204739 +v -0.162292 0.776737 -0.200861 +v -0.0963023 0.812563 -0.21585 +v -0.12229 0.805309 -0.211386 +v -0.103071 0.800257 -0.198013 +v -0.114773 0.801816 -0.205592 +v -0.135327 0.828572 -0.217894 +v -0.108345 0.822919 -0.221075 +v -0.128262 0.813355 -0.215464 +v -0.143329 0.804627 -0.337252 +v -0.119159 0.809804 -0.331351 +v -0.13845 0.801677 -0.350685 +v -0.140844 0.802002 -0.341998 +v -0.153713 0.826966 -0.334024 +v -0.127696 0.819206 -0.325202 +v -0.147191 0.8121 -0.335056 +v -0.0961567 0.829666 -0.288835 +v -0.10501 0.817882 -0.310157 +v -0.116614 0.840248 -0.308051 +v -0.109848 0.825231 -0.308777 +v -0.0934554 0.817549 -0.318853 +v -0.086003 0.820458 -0.291304 +v -0.100185 0.816042 -0.313185 +v -0.084054 0.824638 -0.268864 +v -0.0780919 0.822576 -0.248928 +v -0.0710179 0.824335 -0.270682 +v -0.0786961 0.822795 -0.269513 +v -0.0959818 0.847028 -0.267898 +v -0.0888081 0.831892 -0.249223 +v -0.0891348 0.832003 -0.268429 +v -0.0899479 0.821575 -0.232115 +v -0.102029 0.843892 -0.232989 +v -0.095203 0.828981 -0.232883 +v -0.0751675 0.819879 -0.228529 +v -0.084018 0.819324 -0.230668 +v -0.231902 0.754223 -0.26947 +v -0.226075 0.759994 -0.240858 +v -0.208076 0.764415 -0.241789 +v -0.216972 0.759952 -0.252956 +v -0.265103 0.760852 -0.220189 +v -0.223444 0.760451 -0.217689 +v -0.264144 0.760816 -0.243923 +v -0.240714 0.760641 -0.229576 +v -0.20189 0.765574 -0.22074 +v -0.215759 0.757673 -0.200462 +v -0.205912 0.761992 -0.209879 +v -0.201854 0.770051 -0.234112 +v -0.234872 0.742799 -0.306286 +v -0.277858 0.727498 -0.319523 +v -0.278995 0.751255 -0.279238 +v -0.256224 0.744786 -0.293184 +v -0.317986 0.708047 -0.333577 +v -0.258236 0.693552 -0.356883 +v -0.284726 0.698216 -0.343913 +v -0.37536 0.738148 -0.30116 +v -0.358205 0.712515 -0.324745 +v -0.402685 0.758643 -0.236201 +v -0.343965 0.756617 -0.269721 +v -0.390758 0.753705 -0.27032 +v -0.311167 0.763685 -0.236173 +v -0.300161 0.759231 -0.259113 +v -0.277376 0.753251 -0.197126 +v -0.248651 0.737773 -0.18066 +v -0.183529 0.754714 -0.188935 +v -0.23327 0.750984 -0.191422 +v -0.352617 0.756796 -0.208565 +v -0.303456 0.759588 -0.213776 +v -0.409003 0.736167 -0.174314 +v -0.409429 0.752424 -0.202781 +v -0.329845 0.712932 -0.159268 +v -0.39942 0.710994 -0.155057 +v -0.178779 0.718135 -0.16643 +v -0.252112 0.713887 -0.166078 +v -0.106741 0.782082 -0.178969 +v -0.0602661 0.797425 -0.177797 +v -0.0705006 0.811753 -0.205807 +v -0.0845451 0.798015 -0.188581 +v -0.128352 0.75368 -0.16956 +v -0.140544 0.766364 -0.181936 +v -0.0771688 0.744134 -0.128582 +v -0.122404 0.729951 -0.151266 +v -0.0359638 0.781745 -0.13792 +v -0.0372542 0.755486 -0.106376 +v -0.0258744 0.814456 -0.19275 +v -0.0313039 0.800824 -0.16616 +v -0.0438017 0.818098 -0.377412 +v -0.0647564 0.824008 -0.337021 +v -0.0269807 0.832763 -0.306956 +v -0.0352238 0.828719 -0.341387 +v -0.0968568 0.789376 -0.411772 +v -0.0494105 0.797681 -0.413491 +v -0.176513 0.760515 -0.410655 +v -0.134148 0.794627 -0.38492 +v -0.140375 0.776566 -0.412207 +v -0.105446 0.812324 -0.352131 +v -0.163948 0.787613 -0.366372 +v -0.134862 0.801108 -0.364702 +v -0.0673729 0.8251 -0.299446 +v -0.0829065 0.820245 -0.328154 +v -0.0209585 0.83068 -0.246717 +v -0.0431316 0.822381 -0.222498 +v -0.0222752 0.824379 -0.219341 +v -0.0427143 0.830406 -0.274631 +v -0.0223763 0.833445 -0.275661 +v -0.0571055 0.825864 -0.248034 +v -0.0589761 0.827121 -0.27268 +v -0.0611506 0.820889 -0.225684 +v -0.220893 0.723503 -0.390265 +v -0.192333 0.761236 -0.378584 +v -0.20182 0.742487 -0.402976 +v -0.229147 0.73046 -0.348619 +v -0.238328 0.704586 -0.373617 +v -0.202503 0.759013 -0.342238 +v -0.217964 0.748268 -0.323878 +v -0.185497 0.772855 -0.357643 +v -0.208154 0.830042 -0.298948 +v -0.20855 0.866089 -0.317157 +v -0.182638 0.844163 -0.332751 +v -0.197796 0.836731 -0.320106 +v -0.207473 0.823979 -0.249259 +v -0.22169 0.856724 -0.273536 +v -0.212209 0.824662 -0.273398 +v -0.225435 0.891324 -0.293612 +v -0.221713 0.885753 -0.253374 +v -0.227222 0.886884 -0.273083 +v -0.202088 0.898609 -0.32219 +v -0.216036 0.894273 -0.311279 +v -0.144889 0.85895 -0.323167 +v -0.140188 0.893495 -0.304854 +v -0.113654 0.869597 -0.287244 +v -0.127225 0.865094 -0.306986 +v -0.17602 0.88052 -0.329499 +v -0.164181 0.851772 -0.332764 +v -0.170407 0.915574 -0.314537 +v -0.186655 0.907214 -0.322451 +v -0.141278 0.921251 -0.283964 +v -0.154011 0.919177 -0.300925 +v -0.106278 0.87162 -0.248059 +v -0.126235 0.896792 -0.232757 +v -0.125921 0.862724 -0.222037 +v -0.112672 0.868658 -0.232446 +v -0.120264 0.900007 -0.266157 +v -0.106638 0.871852 -0.266963 +v -0.136706 0.926532 -0.249134 +v -0.136018 0.925025 -0.266007 +v -0.152825 0.914652 -0.226568 +v -0.141818 0.921807 -0.235425 +v -0.169297 0.842653 -0.222278 +v -0.201725 0.863227 -0.234578 +v -0.191458 0.831381 -0.232334 +v -0.158724 0.882351 -0.220155 +v -0.146124 0.853579 -0.218747 +v -0.191735 0.902282 -0.228209 +v -0.171199 0.908866 -0.224253 +v -0.209229 0.892731 -0.238166 +v -0.228365 -0.446181 0.420977 +v -0.20511 -0.461837 0.475502 +v -0.183641 -0.455489 0.534379 +v -0.21326 -0.450303 0.478539 +v -0.176881 -0.48852 0.469991 +v -0.17086 -0.474631 0.521789 +v -0.206663 -0.472505 0.418626 +v -0.194975 -0.474631 0.472428 +v -0.109552 -0.472057 0.595485 +v -0.142559 -0.466669 0.57469 +v -0.132033 -0.481167 0.556781 +v -0.140849 -0.473458 0.563316 +v -0.102981 -0.465723 0.632974 +v -0.143787 -0.462243 0.587914 +v -0.0755892 -0.465387 0.639018 +v -0.0439995 -0.453929 0.682063 +v -0.0705061 -0.461083 0.663389 +v -0.0917758 -0.479034 0.591505 +v -0.0549351 -0.471091 0.629642 +v -0.0815781 -0.471375 0.616771 +v -0.0238268 -0.46053 0.664171 +v -0.0329053 -0.483094 0.604968 +v -0.0276324 -0.470883 0.636565 +v -0.0210984 -0.44987 0.691901 +v -0.0317646 -0.445352 0.134276 +v -0.065741 -0.440111 0.119726 +v -0.0323291 -0.440606 0.100743 +v -0.034368 -0.461296 0.211229 +v -0.0636123 -0.450028 0.182161 +v -0.0320458 -0.45108 0.17059 +v -0.124102 -0.450719 0.228684 +v -0.0965198 -0.444834 0.175662 +v -0.0981278 -0.457279 0.230677 +v -0.0942201 -0.449501 0.201118 +v -0.138015 -0.443895 0.192281 +v -0.101319 -0.442167 0.150389 +v -0.163536 -0.447685 0.255959 +v -0.205661 -0.440923 0.30331 +v -0.174785 -0.442414 0.24495 +v -0.138385 -0.462583 0.271465 +v -0.179537 -0.460826 0.31166 +v -0.153491 -0.454897 0.266081 +v -0.213095 -0.454425 0.36305 +v -0.178344 -0.481123 0.364052 +v -0.199389 -0.4673 0.363772 +v -0.224677 -0.442616 0.362277 +v -0.0774159 -0.49456 0.56248 +v -0.0472884 -0.515301 0.519274 +v -0.0400356 -0.499329 0.565268 +v -0.12906 -0.497175 0.517019 +v -0.109485 -0.488354 0.558077 +v -0.151776 -0.503865 0.416665 +v -0.102374 -0.516827 0.468605 +v -0.144853 -0.503338 0.468859 +v -0.0552219 -0.529321 0.415644 +v -0.0529288 -0.526727 0.468796 +v -0.101727 -0.509066 0.362546 +v -0.046641 -0.500432 0.308431 +v -0.0524328 -0.518796 0.361628 +v -0.12954 -0.482953 0.312862 +v -0.144743 -0.495777 0.363499 +v -0.0778956 -0.474931 0.261875 +v -0.111951 -0.469275 0.268257 +v -0.0399262 -0.479506 0.257737 +v -0.164631 -0.0504489 0.951176 +v -0.139042 -0.0451633 0.963659 +v -0.137897 -0.0298265 0.961061 +v -0.16267 -0.0297463 0.947597 +v -0.150007 -0.038161 0.957034 +v -0.109851 -0.0516794 0.976283 +v -0.122462 -0.037914 0.969963 +v -0.133714 -0.0642499 0.965416 +v -0.125245 -0.0487781 0.969619 +v -0.130968 -0.0135459 0.956851 +v -0.109331 -0.0304408 0.974293 +v -0.124172 -0.0273895 0.966259 +v -0.18873 -0.0434748 0.935764 +v -0.213918 -0.078022 0.922841 +v -0.172782 -0.0812671 0.947651 +v -0.185903 -0.064746 0.940486 +v -0.24743 -0.125194 0.898745 +v -0.247517 -0.0516572 0.891815 +v -0.248772 -0.0872467 0.896118 +v -0.209867 -0.161573 0.925244 +v -0.2493 -0.167014 0.898651 +v -0.133001 -0.161124 0.956956 +v -0.163882 -0.120989 0.949271 +v -0.170754 -0.160591 0.943861 +v -0.119758 -0.0911109 0.968067 +v -0.149065 -0.0885975 0.957545 +v -0.165953 -0.00373407 0.934179 +v -0.206641 -0.0168625 0.913183 +v -0.181563 -0.0218941 0.9332 +v -0.116698 0.0146029 0.948102 +v -0.155037 0.0342159 0.918365 +v -0.143447 0.00727528 0.940085 +v -0.188508 0.055577 0.881861 +v -0.128713 0.0776757 0.9026 +v -0.159167 0.0664178 0.894094 +v -0.225597 0.0165132 0.878354 +v -0.216542 0.0481267 0.863247 +v -0.237857 -0.0169093 0.886885 +v -0.0314129 0.062618 0.944549 +v -0.0591053 0.0273947 0.96148 +v -0.0272441 0.00174637 0.985368 +v -0.0296124 0.0304081 0.965777 +v -0.0652762 0.0925539 0.91594 +v -0.032753 0.0962353 0.919852 +v -0.0939443 0.0532189 0.93429 +v -0.0973395 0.0863776 0.910036 +v -0.0802969 -0.0053962 0.974961 +v -0.0883591 0.0217178 0.955411 +v -0.0313918 -0.121887 0.983992 +v -0.0640997 -0.158632 0.974036 +v -0.0317497 -0.157085 0.978196 +v -0.0273784 -0.0760818 0.993721 +v -0.05977 -0.0942344 0.98419 +v -0.0298425 -0.0936976 0.988793 +v -0.0956523 -0.123707 0.972085 +v -0.0810019 -0.0733797 0.982855 +v -0.0898671 -0.0931811 0.977114 +v -0.0976501 -0.160225 0.966985 +v -0.0864529 -0.0640166 0.98579 +v -0.0789269 -0.06284 0.994959 +v -0.0955999 -0.0476973 0.985969 +v -0.0940951 -0.0565412 0.98502 +v -0.0525276 -0.0775374 1.01483 +v -0.0666347 -0.0644079 1.00864 +v -0.0598989 -0.0753391 1.00401 +v -0.0652946 -0.0700523 1.00523 +v -0.0598411 -0.0536198 1.01768 +v -0.0788425 -0.0488271 1.00064 +v -0.0525009 -0.0662129 1.0231 +v -0.0652608 -0.0582549 1.01251 +v -0.0861068 -0.0306433 0.989153 +v -0.0938769 -0.0385712 0.986828 +v -0.0582598 -0.0403976 1.0119 +v -0.0476184 -0.0223971 1.0006 +v -0.0694706 -0.025394 0.994502 +v -0.0426567 -0.0627588 1.03251 +v -0.0344846 -0.0534302 1.03232 +v -0.0490439 -0.0525287 1.02501 +v -0.0209047 -0.039677 1.02317 +v -0.0152462 -0.0676801 1.04602 +v -0.0177789 -0.0547726 1.03745 +v -0.0242006 -0.0212264 1.00515 +v -0.0209476 -0.0779737 1.00716 +v -0.0477856 -0.0718253 0.995571 +v -0.0242757 -0.0726037 0.999895 +v -0.0152667 -0.0940994 1.02438 +v -0.0345351 -0.0845283 1.01121 +v -0.0178069 -0.0869021 1.01538 +v -0.0583871 -0.073576 0.998233 +v -0.0427012 -0.0854758 1.01505 +v -0.0491057 -0.0804193 1.00671 +v -0.0697639 -0.0690371 0.990088 +v -0.0394909 -0.0796254 1.02906 +v -0.0271444 -0.0763309 1.04139 +v -0.0399318 -0.0720589 1.03309 +v -0.0271637 -0.0905263 1.02914 +v -0.0399551 -0.0846544 1.02277 +v -0.0132272 -0.0889316 1.04223 +v -0.01374 -0.0942759 1.03402 +v -0.0137291 -0.0795664 1.04692 +vt 0.800375 0.667457 +vt 0.789584 0.668215 +vt 0.799923 0.663933 +vt 0.789057 0.664897 +vt 0.811842 0.670848 +vt 0.80103 0.671718 +vt 0.811217 0.666381 +vt 0.810346 0.655189 +vt 0.810548 0.658683 +vt 0.799442 0.658809 +vt 0.799641 0.661178 +vt 0.788653 0.662549 +vt 0.821717 0.660492 +vt 0.821466 0.655998 +vt 0.832622 0.658487 +vt 0.832389 0.653218 +vt 0.821251 0.651569 +vt 0.822539 0.669852 +vt 0.822041 0.665116 +vt 0.832855 0.663756 +vt 0.768389 0.668485 +vt 0.778915 0.668524 +vt 0.769427 0.673433 +vt 0.779732 0.673035 +vt 0.778165 0.664791 +vt 0.74577 0.661865 +vt 0.756532 0.663039 +vt 0.747747 0.667793 +vt 0.758027 0.6682 +vt 0.759367 0.673605 +vt 0.753496 0.653114 +vt 0.765177 0.656219 +vt 0.755019 0.658037 +vt 0.76625 0.660042 +vt 0.743793 0.655937 +vt 0.777492 0.661858 +vt 0.776857 0.659324 +vt 0.860743 0.66105 +vt 0.85437 0.658994 +vt 0.861885 0.655612 +vt 0.85471 0.654338 +vt 0.858253 0.665619 +vt 0.86356 0.668573 +vt 0.867109 0.663417 +vt 0.870052 0.650753 +vt 0.862482 0.650015 +vt 0.870421 0.644717 +vt 0.862589 0.644612 +vt 0.85505 0.649682 +vt 0.883125 0.662497 +vt 0.876218 0.659429 +vt 0.885992 0.655087 +vt 0.877897 0.652301 +vt 0.878895 0.645534 +vt 0.869196 0.672347 +vt 0.87346 0.666407 +vt 0.879453 0.669777 +vt 0.889305 0.677736 +vt 0.893116 0.683944 +vt 0.881403 0.682863 +vt 0.884277 0.688027 +vt 0.896144 0.692562 +vt 0.90593 0.689794 +vt 0.901798 0.679591 +vt 0.889995 0.666526 +vt 0.884742 0.673283 +vt 0.878268 0.679148 +vt 0.902596 0.665971 +vt 0.89431 0.659538 +vt 0.908133 0.659549 +vt 0.89794 0.652608 +vt 0.916609 0.686107 +vt 0.910596 0.674701 +vt 0.918591 0.668435 +vt 0.713434 0.678889 +vt 0.718232 0.673865 +vt 0.719971 0.68226 +vt 0.723135 0.677582 +vt 0.720227 0.663887 +vt 0.722594 0.669482 +vt 0.714094 0.668877 +vt 0.690854 0.689174 +vt 0.699881 0.681004 +vt 0.701094 0.693026 +vt 0.707762 0.685198 +vt 0.716169 0.688193 +vt 0.697269 0.662673 +vt 0.702107 0.668949 +vt 0.686646 0.668347 +vt 0.692886 0.67536 +vt 0.6822 0.683174 +vt 0.710252 0.663404 +vt 0.717861 0.658291 +vt 0.706788 0.657767 +vt 0.858365 0.672357 +vt 0.853611 0.668611 +vt 0.843559 0.666338 +vt 0.848795 0.664994 +vt 0.847566 0.670615 +vt 0.855227 0.679121 +vt 0.862995 0.676364 +vt 0.858343 0.683022 +vt 0.867102 0.680206 +vt 0.834415 0.678265 +vt 0.843484 0.67676 +vt 0.836434 0.683129 +vt 0.846261 0.68128 +vt 0.848914 0.685681 +vt 0.840865 0.672225 +vt 0.838324 0.667682 +vt 0.832962 0.673545 +vt 0.812703 0.675707 +vt 0.801925 0.676679 +vt 0.791163 0.677558 +vt 0.792268 0.683394 +vt 0.803066 0.682261 +vt 0.82446 0.679693 +vt 0.823312 0.674685 +vt 0.815369 0.686723 +vt 0.826081 0.684957 +vt 0.817113 0.692704 +vt 0.827981 0.690382 +vt 0.79352 0.689825 +vt 0.804461 0.688386 +vt 0.806115 0.694921 +vt 0.798864 0.71184 +vt 0.810186 0.708981 +vt 0.801046 0.72017 +vt 0.812549 0.716812 +vt 0.823667 0.712859 +vt 0.826337 0.721153 +vt 0.81509 0.725328 +vt 0.819076 0.698906 +vt 0.808032 0.701735 +vt 0.796857 0.704106 +vt 0.829963 0.69587 +vt 0.840668 0.692798 +vt 0.832092 0.701818 +vt 0.842717 0.698135 +vt 0.834432 0.708622 +vt 0.837107 0.716573 +vt 0.844937 0.704332 +vt 0.867471 0.703655 +vt 0.86533 0.696176 +vt 0.877095 0.699305 +vt 0.875007 0.692109 +vt 0.872828 0.687102 +vt 0.853212 0.694487 +vt 0.855272 0.700217 +vt 0.857607 0.707609 +vt 0.851162 0.689863 +vt 0.861137 0.686828 +vt 0.870286 0.68346 +vt 0.737342 0.674399 +vt 0.736161 0.679693 +vt 0.731151 0.674738 +vt 0.729268 0.679242 +vt 0.727195 0.684244 +vt 0.743049 0.685744 +vt 0.743345 0.679784 +vt 0.751789 0.685777 +vt 0.751276 0.679628 +vt 0.743533 0.67406 +vt 0.73204 0.698591 +vt 0.733516 0.691513 +vt 0.741945 0.699272 +vt 0.742539 0.692176 +vt 0.751932 0.692359 +vt 0.72474 0.690242 +vt 0.722029 0.697328 +vt 0.716708 0.714828 +vt 0.715092 0.72481 +vt 0.702617 0.714132 +vt 0.700538 0.724407 +vt 0.728191 0.725265 +vt 0.727285 0.735883 +vt 0.713954 0.735509 +vt 0.730575 0.706575 +vt 0.719186 0.705595 +vt 0.70688 0.704276 +vt 0.740902 0.715992 +vt 0.741399 0.707225 +vt 0.75229 0.716217 +vt 0.752093 0.707508 +vt 0.740453 0.725533 +vt 0.740092 0.735897 +vt 0.752425 0.725529 +vt 0.789126 0.722623 +vt 0.790991 0.731868 +vt 0.776943 0.72426 +vt 0.778298 0.733889 +vt 0.787299 0.713921 +vt 0.76386 0.71596 +vt 0.764649 0.725167 +vt 0.765442 0.735096 +vt 0.773153 0.698992 +vt 0.774288 0.706826 +vt 0.762394 0.699466 +vt 0.763091 0.707391 +vt 0.785576 0.705767 +vt 0.784024 0.698116 +vt 0.781583 0.684283 +vt 0.780606 0.678305 +vt 0.77033 0.678903 +vt 0.772112 0.691699 +vt 0.782707 0.69092 +vt 0.761214 0.685501 +vt 0.761821 0.692189 +vt 0.760412 0.679339 +vt 0.899727 0.753469 +vt 0.893091 0.747999 +vt 0.905106 0.743418 +vt 0.897762 0.739947 +vt 0.887783 0.741206 +vt 0.880731 0.745814 +vt 0.886161 0.754214 +vt 0.904716 0.775474 +vt 0.898651 0.768079 +vt 0.914323 0.765617 +vt 0.907202 0.758849 +vt 0.913707 0.74723 +vt 0.877978 0.781668 +vt 0.872582 0.772759 +vt 0.888929 0.775502 +vt 0.883177 0.767576 +vt 0.894526 0.783756 +vt 0.872228 0.750111 +vt 0.877492 0.759308 +vt 0.867387 0.763696 +vt 0.843778 0.771729 +vt 0.83028 0.775596 +vt 0.839713 0.76143 +vt 0.826842 0.765165 +vt 0.83386 0.786091 +vt 0.815809 0.779609 +vt 0.818643 0.790465 +vt 0.860927 0.77752 +vt 0.856148 0.767799 +vt 0.851602 0.757722 +vt 0.852231 0.792074 +vt 0.865736 0.787127 +vt 0.856409 0.802551 +vt 0.870501 0.796949 +vt 0.837491 0.796705 +vt 0.821654 0.801351 +vt 0.841215 0.807639 +vt 0.724356 0.780932 +vt 0.721897 0.791331 +vt 0.712133 0.77893 +vt 0.708432 0.787628 +vt 0.688991 0.788336 +vt 0.696924 0.781352 +vt 0.7032 0.796344 +vt 0.734947 0.804179 +vt 0.736823 0.793158 +vt 0.751835 0.804371 +vt 0.752608 0.793134 +vt 0.738282 0.782037 +vt 0.732844 0.815397 +vt 0.730608 0.827229 +vt 0.715066 0.812163 +vt 0.711339 0.823597 +vt 0.751007 0.816099 +vt 0.681689 0.797702 +vt 0.697958 0.806263 +vt 0.692594 0.817566 +vt 0.802671 0.795049 +vt 0.800517 0.783977 +vt 0.798447 0.773092 +vt 0.783398 0.776846 +vt 0.784699 0.788076 +vt 0.788691 0.822864 +vt 0.787323 0.810943 +vt 0.807157 0.818048 +vt 0.804858 0.806345 +vt 0.768947 0.80275 +vt 0.769269 0.814405 +vt 0.769629 0.82649 +vt 0.768262 0.779889 +vt 0.768648 0.791284 +vt 0.829319 0.730383 +vt 0.817782 0.734631 +vt 0.807922 0.748352 +vt 0.80562 0.738467 +vt 0.820629 0.744508 +vt 0.843731 0.736281 +vt 0.840238 0.725959 +vt 0.854152 0.732184 +vt 0.850604 0.721518 +vt 0.847491 0.747042 +vt 0.836031 0.750919 +vt 0.858049 0.743181 +vt 0.823637 0.754744 +vt 0.810425 0.758547 +vt 0.739591 0.758816 +vt 0.739858 0.747133 +vt 0.753132 0.758368 +vt 0.752889 0.746823 +vt 0.726681 0.747058 +vt 0.739135 0.77052 +vt 0.725558 0.770057 +vt 0.753262 0.7701 +vt 0.69786 0.758579 +vt 0.712375 0.758296 +vt 0.700367 0.76912 +vt 0.712782 0.769064 +vt 0.712907 0.746891 +vt 0.698005 0.747078 +vt 0.929639 0.699595 +vt 0.928443 0.716654 +vt 0.918934 0.700571 +vt 0.918764 0.716584 +vt 0.908376 0.702434 +vt 0.917291 0.732639 +vt 0.908091 0.730817 +vt 0.926839 0.733706 +vt 0.899583 0.717133 +vt 0.899655 0.729345 +vt 0.890467 0.718513 +vt 0.891789 0.729325 +vt 0.898356 0.704249 +vt 0.888732 0.70646 +vt 0.766981 0.757058 +vt 0.767683 0.768445 +vt 0.782175 0.765786 +vt 0.779622 0.744124 +vt 0.766227 0.745834 +vt 0.794659 0.751851 +vt 0.792827 0.741649 +vt 0.796513 0.762357 +vt 0.870023 0.713177 +vt 0.860485 0.717218 +vt 0.863872 0.728122 +vt 0.881776 0.720957 +vt 0.879363 0.709514 +vt 0.876505 0.735646 +vt 0.884297 0.731857 +vt 0.867737 0.739401 +vt 0.942885 0.685053 +vt 0.953367 0.687709 +vt 0.940102 0.70044 +vt 0.950147 0.702062 +vt 0.938165 0.716742 +vt 0.968754 0.704629 +vt 0.964644 0.717556 +vt 0.959599 0.703413 +vt 0.956139 0.717201 +vt 0.963128 0.689798 +vt 0.953145 0.730828 +vt 0.951463 0.743182 +vt 0.945243 0.731521 +vt 0.944286 0.744982 +vt 0.960533 0.730482 +vt 0.936315 0.732906 +vt 0.935707 0.747908 +vt 0.168776 0.186925 +vt 0.153188 0.186399 +vt 0.169355 0.173108 +vt 0.15372 0.172537 +vt 0.137511 0.174005 +vt 0.154886 0.15836 +vt 0.139434 0.160894 +vt 0.135878 0.200202 +vt 0.153921 0.199631 +vt 0.13741 0.213278 +vt 0.156324 0.212569 +vt 0.169774 0.199674 +vt 0.115769 0.200908 +vt 0.0946273 0.201684 +vt 0.11798 0.188318 +vt 0.0992616 0.189776 +vt 0.115489 0.212947 +vt 0.120823 0.175844 +vt 0.123982 0.163427 +vt 0.103896 0.177868 +vt 0.197705 0.18287 +vt 0.184318 0.177386 +vt 0.204286 0.174321 +vt 0.191177 0.166862 +vt 0.182759 0.189357 +vt 0.218051 0.196712 +vt 0.206672 0.195261 +vt 0.218754 0.189245 +vt 0.208611 0.187062 +vt 0.213838 0.179979 +vt 0.195322 0.2024 +vt 0.206572 0.20383 +vt 0.197221 0.212029 +vt 0.207879 0.212331 +vt 0.217851 0.204542 +vt 0.183316 0.200806 +vt 0.185616 0.211745 +vt 0.200177 0.221191 +vt 0.189289 0.222187 +vt 0.176497 0.223558 +vt 0.183072 0.235218 +vt 0.194814 0.232099 +vt 0.222696 0.225794 +vt 0.213531 0.227462 +vt 0.220244 0.219432 +vt 0.210159 0.220329 +vt 0.219048 0.242324 +vt 0.210793 0.236729 +vt 0.224444 0.237674 +vt 0.218111 0.23337 +vt 0.225701 0.231231 +vt 0.192704 0.246651 +vt 0.20267 0.241446 +vt 0.21291 0.248905 +vt 0.147552 0.942756 +vt 0.13896 0.937482 +vt 0.15442 0.936036 +vt 0.145004 0.930904 +vt 0.131991 0.943023 +vt 0.122815 0.936756 +vt 0.130641 0.931218 +vt 0.148962 0.952945 +vt 0.155644 0.947301 +vt 0.157149 0.955791 +vt 0.164222 0.950166 +vt 0.162965 0.941085 +vt 0.125551 0.956525 +vt 0.133402 0.953212 +vt 0.134656 0.9604 +vt 0.141677 0.957166 +vt 0.14902 0.960085 +vt 0.115375 0.942445 +vt 0.124894 0.947972 +vt 0.116632 0.951525 +vt 0.871579 0.942636 +vt 0.878596 0.946725 +vt 0.86416 0.948207 +vt 0.872055 0.95214 +vt 0.886187 0.942108 +vt 0.885478 0.951547 +vt 0.893652 0.946846 +vt 0.872605 0.934139 +vt 0.865133 0.939046 +vt 0.865671 0.931509 +vt 0.858017 0.93669 +vt 0.857275 0.944342 +vt 0.895145 0.930139 +vt 0.887213 0.93361 +vt 0.887365 0.926738 +vt 0.880339 0.930202 +vt 0.873942 0.927331 +vt 0.901581 0.942011 +vt 0.893918 0.937827 +vt 0.902324 0.934359 +vt 0.937778 0.969427 +vt 0.924742 0.963135 +vt 0.963417 0.953814 +vt 0.94277 0.951002 +vt 0.929636 0.938971 +vt 0.950985 0.939207 +vt 0.924587 0.948175 +vt 0.897606 0.964725 +vt 0.904637 0.974329 +vt 0.880983 0.968761 +vt 0.883219 0.980673 +vt 0.91214 0.985041 +vt 0.902437 0.951808 +vt 0.891517 0.95734 +vt 0.87954 0.960235 +vt 0.911331 0.94532 +vt 0.915423 0.938551 +vt 0.837802 0.927994 +vt 0.819804 0.940196 +vt 0.826204 0.927352 +vt 0.800609 0.943494 +vt 0.811605 0.952025 +vt 0.831685 0.94681 +vt 0.836697 0.937574 +vt 0.857877 0.916732 +vt 0.87928 0.910354 +vt 0.863614 0.921492 +vt 0.880267 0.917735 +vt 0.851798 0.911211 +vt 0.857703 0.929735 +vt 0.868668 0.924726 +vt 0.880724 0.922242 +vt 0.845039 0.94326 +vt 0.848987 0.936302 +vt 0.924475 0.930625 +vt 0.941648 0.929031 +vt 0.96114 0.927417 +vt 0.933224 0.916635 +vt 0.922496 0.92029 +vt 0.903495 0.926861 +vt 0.911938 0.93218 +vt 0.897103 0.91889 +vt 0.892712 0.923251 +vt 0.905308 0.905852 +vt 0.901263 0.912802 +vt 0.820926 0.962167 +vt 0.836809 0.955124 +vt 0.840048 0.970839 +vt 0.802886 0.96989 +vt 0.830758 0.980145 +vt 0.856645 0.954682 +vt 0.848379 0.949442 +vt 0.864116 0.967327 +vt 0.867473 0.958814 +vt 0.86125 0.978259 +vt 0.85863 0.990399 +vt 0.191842 0.938528 +vt 0.18483 0.928669 +vt 0.214023 0.932819 +vt 0.202519 0.920832 +vt 0.190621 0.899112 +vt 0.222723 0.912315 +vt 0.180131 0.909732 +vt 0.161958 0.928403 +vt 0.17217 0.935147 +vt 0.177196 0.942628 +vt 0.133862 0.910183 +vt 0.152639 0.912726 +vt 0.135915 0.920575 +vt 0.149326 0.922843 +vt 0.155653 0.899975 +vt 0.158518 0.885909 +vt 0.131 0.896051 +vt 0.0727151 0.905945 +vt 0.0872616 0.914579 +vt 0.045865 0.922565 +vt 0.0688679 0.927864 +vt 0.0891699 0.932953 +vt 0.0611106 0.940896 +vt 0.0850445 0.943365 +vt 0.116168 0.914322 +vt 0.108088 0.902447 +vt 0.0995652 0.889326 +vt 0.112481 0.9301 +vt 0.123364 0.923705 +vt 0.10407 0.937626 +vt 0.101008 0.945485 +vt 0.141749 0.967835 +vt 0.159735 0.964585 +vt 0.141615 0.973986 +vt 0.164947 0.968203 +vt 0.198452 0.956803 +vt 0.170264 0.972446 +vt 0.186612 0.957297 +vt 0.165935 0.957311 +vt 0.154732 0.962219 +vt 0.141924 0.964387 +vt 0.187555 0.948567 +vt 0.17427 0.950399 +vt 0.205846 0.945238 +vt 0.226639 0.94116 +vt 0.0918948 0.952851 +vt 0.072194 0.95227 +vt 0.0497805 0.951411 +vt 0.080546 0.963637 +vt 0.0937428 0.962144 +vt 0.116457 0.959008 +vt 0.10617 0.952878 +vt 0.123264 0.966181 +vt 0.12877 0.963081 +vt 0.111312 0.975863 +vt 0.117382 0.970674 +vt 0.168188 0.257701 +vt 0.179853 0.251475 +vt 0.181861 0.270696 +vt 0.19145 0.264485 +vt 0.168322 0.238524 +vt 0.157989 0.278114 +vt 0.139623 0.26474 +vt 0.161775 0.267111 +vt 0.143271 0.254169 +vt 0.176773 0.279775 +vt 0.122129 0.24267 +vt 0.0996677 0.231893 +vt 0.121641 0.233595 +vt 0.0964428 0.225792 +vt 0.121258 0.251367 +vt 0.141637 0.226246 +vt 0.118437 0.223765 +vt 0.0932179 0.219692 +vt 0.160802 0.225544 +vt 0.0419152 0.53618 +vt 0.0472563 0.523503 +vt 0.0332681 0.539408 +vt 0.038828 0.522754 +vt 0.0547796 0.5128 +vt 0.0629257 0.517019 +vt 0.0550589 0.52441 +vt 0.0478604 0.554178 +vt 0.0476885 0.543737 +vt 0.0376346 0.561691 +vt 0.0380519 0.549348 +vt 0.0277081 0.556063 +vt 0.0662616 0.533766 +vt 0.0581 0.532485 +vt 0.0632249 0.540131 +vt 0.0559107 0.540335 +vt 0.055828 0.548702 +vt 0.0616102 0.525629 +vt 0.0679204 0.520553 +vt 0.0687181 0.527585 +vt 0.0509533 0.580146 +vt 0.0426311 0.57189 +vt 0.0442882 0.588789 +vt 0.0332182 0.580753 +vt 0.0513392 0.563763 +vt 0.0757862 0.577556 +vt 0.0655669 0.57722 +vt 0.0718228 0.588438 +vt 0.060513 0.586655 +vt 0.0553583 0.596825 +vt 0.0637107 0.564356 +vt 0.0704192 0.569255 +vt 0.070071 0.55722 +vt 0.0760258 0.562179 +vt 0.0789464 0.569999 +vt 0.0586375 0.557107 +vt 0.0648092 0.550898 +vt 0.0904211 0.548013 +vt 0.0833422 0.555408 +vt 0.0957205 0.55254 +vt 0.0881221 0.560358 +vt 0.0767944 0.549978 +vt 0.090315 0.526886 +vt 0.0877993 0.53464 +vt 0.0982366 0.53011 +vt 0.0953147 0.539062 +vt 0.100791 0.542278 +vt 0.0746039 0.537227 +vt 0.0781908 0.530701 +vt 0.0798442 0.524364 +vt 0.0701373 0.544116 +vt 0.925171 0.815649 +vt 0.920243 0.805051 +vt 0.934775 0.80669 +vt 0.929739 0.796503 +vt 0.93322 0.778201 +vt 0.938087 0.788562 +vt 0.924761 0.786096 +vt 0.904862 0.803051 +vt 0.910168 0.813683 +vt 0.893079 0.810992 +vt 0.898686 0.821929 +vt 0.915568 0.824608 +vt 0.910263 0.784583 +vt 0.899742 0.793007 +vt 0.888113 0.80057 +vt 0.919899 0.77525 +vt 0.928896 0.766724 +vt 0.815787 0.855921 +vt 0.819336 0.868912 +vt 0.793818 0.862058 +vt 0.795798 0.875795 +vt 0.831679 0.83698 +vt 0.836161 0.849417 +vt 0.812478 0.843031 +vt 0.770591 0.852857 +vt 0.771369 0.867508 +vt 0.748599 0.854921 +vt 0.748212 0.870509 +vt 0.772261 0.882678 +vt 0.790259 0.835472 +vt 0.77004 0.839246 +vt 0.749297 0.841006 +vt 0.80965 0.830342 +vt 0.827993 0.824626 +vt 0.724119 0.869298 +vt 0.722193 0.885121 +vt 0.69961 0.865356 +vt 0.695663 0.88068 +vt 0.726136 0.854086 +vt 0.681189 0.844692 +vt 0.675206 0.860163 +vt 0.659402 0.836491 +vt 0.651382 0.852648 +vt 0.669133 0.87624 +vt 0.686995 0.830434 +vt 0.707465 0.836555 +vt 0.667117 0.821916 +vt 0.728335 0.840094 +vt 0.844791 0.630193 +vt 0.844724 0.634228 +vt 0.843982 0.630547 +vt 0.842478 0.634715 +vt 0.837664 0.639425 +vt 0.840419 0.635163 +vt 0.840973 0.638882 +vt 0.848717 0.637567 +vt 0.847346 0.633664 +vt 0.854083 0.636646 +vt 0.851791 0.632782 +vt 0.845599 0.629839 +vt 0.849337 0.641623 +vt 0.849581 0.645756 +vt 0.844215 0.642375 +vt 0.843773 0.646487 +vt 0.855223 0.640762 +vt 0.839469 0.64305 +vt 0.83491 0.643687 +vt 0.837964 0.647218 +vt 0.725656 0.643083 +vt 0.719643 0.64232 +vt 0.724939 0.640251 +vt 0.71996 0.638782 +vt 0.711679 0.641543 +vt 0.711659 0.645946 +vt 0.719749 0.645744 +vt 0.738356 0.646598 +vt 0.732577 0.6462 +vt 0.736627 0.644893 +vt 0.731247 0.643959 +vt 0.729918 0.641719 +vt 0.727515 0.648634 +vt 0.733906 0.64844 +vt 0.728655 0.651352 +vt 0.735235 0.65068 +vt 0.740086 0.648303 +vt 0.712958 0.649959 +vt 0.7207 0.648941 +vt 0.722074 0.652024 +vt 0.884966 0.82932 +vt 0.890192 0.840682 +vt 0.86976 0.836188 +vt 0.87442 0.847798 +vt 0.879899 0.818138 +vt 0.849222 0.830896 +vt 0.853822 0.842863 +vt 0.858647 0.854913 +vt 0.860816 0.813432 +vt 0.845073 0.819095 +vt 0.87515 0.807317 +vt 0.953522 0.784398 +vt 0.950371 0.775653 +vt 0.958094 0.777732 +vt 0.955796 0.769832 +vt 0.959544 0.757237 +vt 0.961105 0.764151 +vt 0.953683 0.761713 +vt 0.940794 0.771842 +vt 0.944716 0.781755 +vt 0.94895 0.791065 +vt 0.945308 0.756461 +vt 0.937496 0.760723 +vt 0.957984 0.750323 +vt 0.951941 0.753153 +vt 0.237985 0.738297 +vt 0.268705 0.737229 +vt 0.241633 0.762787 +vt 0.268705 0.761697 +vt 0.200475 0.715676 +vt 0.234693 0.711537 +vt 0.207029 0.741466 +vt 0.222333 0.788147 +vt 0.245519 0.78554 +vt 0.230341 0.810102 +vt 0.249523 0.807426 +vt 0.268705 0.784364 +vt 0.159946 0.773803 +vt 0.187254 0.769363 +vt 0.175961 0.794629 +vt 0.199147 0.791261 +vt 0.211159 0.812779 +vt 0.165843 0.72393 +vt 0.175598 0.746705 +vt 0.14393 0.752977 +vt 0.253345 0.280308 +vt 0.268706 0.280765 +vt 0.253464 0.295744 +vt 0.268576 0.296249 +vt 0.238317 0.265747 +vt 0.253558 0.266767 +vt 0.238168 0.279086 +vt 0.239577 0.31028 +vt 0.253859 0.311911 +vt 0.240382 0.325349 +vt 0.254334 0.327593 +vt 0.268615 0.312525 +vt 0.21323 0.291052 +vt 0.225134 0.292637 +vt 0.214544 0.305067 +vt 0.22632 0.307825 +vt 0.227134 0.322083 +vt 0.223441 0.277203 +vt 0.223004 0.263413 +vt 0.210121 0.276206 +vt 0.268934 0.241592 +vt 0.268768 0.248379 +vt 0.255927 0.241503 +vt 0.254998 0.248112 +vt 0.243677 0.241038 +vt 0.256594 0.23557 +vt 0.244966 0.235422 +vt 0.239676 0.25526 +vt 0.254158 0.256284 +vt 0.268799 0.256538 +vt 0.225586 0.253155 +vt 0.229504 0.24562 +vt 0.233074 0.239996 +vt 0.235164 0.235206 +vt 0.672084 0.639787 +vt 0.66845 0.628475 +vt 0.686608 0.639919 +vt 0.68396 0.631421 +vt 0.660815 0.654442 +vt 0.655577 0.64149 +vt 0.676137 0.650509 +vt 0.700237 0.640623 +vt 0.701506 0.646666 +vt 0.69947 0.634368 +vt 0.693146 0.655714 +vt 0.703781 0.652284 +vt 0.681027 0.660046 +vt 0.66725 0.665722 +vt 0.869213 0.629853 +vt 0.859507 0.631337 +vt 0.868187 0.625508 +vt 0.857298 0.627496 +vt 0.861301 0.635363 +vt 0.891113 0.635857 +vt 0.879896 0.634217 +vt 0.89156 0.629458 +vt 0.879626 0.628853 +vt 0.879077 0.62352 +vt 0.870406 0.639191 +vt 0.879607 0.639641 +vt 0.889853 0.641715 +vt 0.862262 0.639758 +vt 0.92121 0.637592 +vt 0.905828 0.63279 +vt 0.925118 0.630408 +vt 0.907542 0.62597 +vt 0.903798 0.639508 +vt 0.942567 0.656273 +vt 0.930472 0.650822 +vt 0.949711 0.646823 +vt 0.936482 0.642606 +vt 0.942694 0.634846 +vt 0.912967 0.652217 +vt 0.924862 0.659954 +vt 0.936428 0.667127 +vt 0.901136 0.646022 +vt 0.966001 0.650564 +vt 0.958961 0.649232 +vt 0.970644 0.639264 +vt 0.965457 0.639274 +vt 0.952791 0.65981 +vt 0.969418 0.663982 +vt 0.972601 0.651548 +vt 0.976942 0.665473 +vt 0.97898 0.652359 +vt 0.975831 0.639254 +vt 0.957281 0.67448 +vt 0.966331 0.676693 +vt 0.974903 0.678588 +vt 0.947274 0.67163 +vt 0.269766 0.158525 +vt 0.250658 0.159766 +vt 0.270029 0.149052 +vt 0.248065 0.150831 +vt 0.220307 0.146351 +vt 0.245291 0.141613 +vt 0.226699 0.154829 +vt 0.24059 0.178843 +vt 0.237237 0.170956 +vt 0.254532 0.176342 +vt 0.25289 0.168134 +vt 0.269586 0.166899 +vt 0.216438 0.167843 +vt 0.223799 0.174757 +vt 0.228354 0.181409 +vt 0.20652 0.159758 +vt 0.195322 0.151089 +vt 0.255674 0.193252 +vt 0.255353 0.184799 +vt 0.26904 0.192481 +vt 0.269203 0.183716 +vt 0.242017 0.186776 +vt 0.242969 0.210229 +vt 0.242663 0.202753 +vt 0.255922 0.209205 +vt 0.255817 0.201447 +vt 0.269103 0.200716 +vt 0.229862 0.196333 +vt 0.229944 0.203984 +vt 0.230377 0.211402 +vt 0.229853 0.188704 +vt 0.256133 0.216346 +vt 0.269011 0.215922 +vt 0.256393 0.223033 +vt 0.26887 0.222737 +vt 0.243486 0.217235 +vt 0.244951 0.229727 +vt 0.256648 0.229427 +vt 0.268973 0.2293 +vt 0.232926 0.224635 +vt 0.234642 0.230172 +vt 0.231438 0.218332 +vt 0.231875 0.681974 +vt 0.195405 0.687835 +vt 0.268705 0.681041 +vt 0.268707 0.649795 +vt 0.231298 0.650222 +vt 0.159651 0.701684 +vt 0.124255 0.719528 +vt 0.152896 0.681504 +vt 0.120595 0.706905 +vt 0.162996 0.634435 +vt 0.141452 0.664926 +vt 0.142052 0.61864 +vt 0.127664 0.650149 +vt 0.116935 0.694282 +vt 0.211524 0.580428 +vt 0.203702 0.612749 +vt 0.187831 0.570739 +vt 0.178593 0.601672 +vt 0.15644 0.58713 +vt 0.268705 0.617234 +vt 0.234725 0.616894 +vt 0.239135 0.585332 +vt 0.199167 0.27764 +vt 0.203439 0.290476 +vt 0.191338 0.282164 +vt 0.195938 0.298294 +vt 0.204702 0.30253 +vt 0.194745 0.309006 +vt 0.204397 0.314025 +vt 0.187394 0.290439 +vt 0.185378 0.30188 +vt 0.158413 0.418134 +vt 0.159054 0.422514 +vt 0.151701 0.418126 +vt 0.153357 0.422511 +vt 0.148767 0.427196 +vt 0.147324 0.422254 +vt 0.154331 0.42702 +vt 0.164378 0.426932 +vt 0.164461 0.422716 +vt 0.169254 0.42687 +vt 0.169733 0.422548 +vt 0.164807 0.418553 +vt 0.159617 0.435925 +vt 0.159655 0.431437 +vt 0.163693 0.43525 +vt 0.1639 0.431123 +vt 0.16807 0.431122 +vt 0.15511 0.43158 +vt 0.150273 0.432153 +vt 0.155198 0.436148 +vt 0.137897 0.391939 +vt 0.139469 0.389504 +vt 0.17063 0.392906 +vt 0.177579 0.390684 +vt 0.108525 0.396264 +vt 0.10962 0.392167 +vt 0.136029 0.394644 +vt 0.189135 0.398093 +vt 0.201386 0.395105 +vt 0.205359 0.404085 +vt 0.221392 0.400547 +vt 0.215689 0.391863 +vt 0.159402 0.397834 +vt 0.180988 0.400577 +vt 0.156251 0.401361 +vt 0.175531 0.40322 +vt 0.1956 0.40625 +vt 0.133566 0.39789 +vt 0.106177 0.400376 +vt 0.13333 0.401583 +vt 0.105778 0.419582 +vt 0.112909 0.431692 +vt 0.0857539 0.42372 +vt 0.0978159 0.435407 +vt 0.0792543 0.412786 +vt 0.0493589 0.420043 +vt 0.0604704 0.429958 +vt 0.113824 0.445537 +vt 0.130697 0.452864 +vt 0.104492 0.449389 +vt 0.127195 0.455721 +vt 0.123421 0.442151 +vt 0.0620736 0.445754 +vt 0.0967788 0.453971 +vt 0.042503 0.451596 +vt 0.0898755 0.458919 +vt 0.12693 0.459685 +vt 0.0109524 0.427572 +vt 0.0292777 0.436932 +vt -0.00486957 0.444274 +vt 0.218498 0.42425 +vt 0.211205 0.424626 +vt 0.236149 0.408646 +vt 0.221871 0.411246 +vt 0.209393 0.413479 +vt 0.194343 0.436667 +vt 0.197771 0.438115 +vt 0.182271 0.446693 +vt 0.18375 0.449328 +vt 0.200848 0.439853 +vt 0.190212 0.435797 +vt 0.185733 0.435099 +vt 0.197971 0.425316 +vt 0.191608 0.425692 +vt 0.179819 0.445093 +vt 0.200514 0.414982 +vt 0.193566 0.416303 +vt 0.160223 0.460849 +vt 0.159192 0.459271 +vt 0.17171 0.458153 +vt 0.171322 0.455881 +vt 0.17064 0.453743 +vt 0.14455 0.458507 +vt 0.146064 0.460995 +vt 0.148735 0.463545 +vt 0.158128 0.455703 +vt 0.14535 0.456142 +vt 0.158194 0.452773 +vt 0.147456 0.453335 +vt 0.169371 0.451874 +vt 0.167924 0.449711 +vt 0.0851413 0.39891 +vt 0.0922294 0.393554 +vt 0.0991561 0.388722 +vt 0.100257 0.388524 +vt 0.0806903 0.395723 +vt 0.0520286 0.41091 +vt 0.0799332 0.404918 +vt 0.0223556 0.413036 +vt 0.0433475 0.407848 +vt -0.0149432 0.424994 +vt 0.019659 0.417742 +vt 0.0699681 0.398298 +vt 0.0980548 0.388921 +vt 0.0596545 0.401078 +vt 0.112325 0.545469 +vt 0.112227 0.562147 +vt 0.121292 0.533311 +vt 0.124355 0.551553 +vt 0.0994555 0.572536 +vt 0.0969232 0.587328 +vt 0.112171 0.578561 +vt 0.106779 0.524557 +vt 0.107589 0.538443 +vt 0.110423 0.513527 +vt 0.112506 0.528264 +vt 0.118228 0.515069 +vt 0.0989423 0.555133 +vt 0.104283 0.542593 +vt 0.104701 0.530629 +vt 0.0882754 0.571292 +vt 0.0894754 0.56478 +vt 0.0853955 0.582515 +vt 0.0816758 0.596094 +vt 0.0753139 0.485928 +vt 0.0650052 0.492652 +vt 0.0850253 0.491819 +vt 0.076075 0.499356 +vt 0.0930081 0.48361 +vt 0.100394 0.488016 +vt 0.0945577 0.497873 +vt 0.0651895 0.505551 +vt 0.073766 0.51176 +vt 0.0546966 0.499376 +vt 0.0900973 0.518593 +vt 0.0785101 0.518041 +vt 0.0994002 0.522709 +vt 0.100625 0.514782 +vt 0.107779 0.492421 +vt 0.103732 0.504253 +vt 0.23946 0.508287 +vt 0.230571 0.517622 +vt 0.228964 0.503271 +vt 0.217261 0.507781 +vt 0.188396 0.491269 +vt 0.206255 0.496224 +vt 0.200655 0.50824 +vt 0.268702 0.540749 +vt 0.243925 0.538213 +vt 0.268704 0.526377 +vt 0.248486 0.524031 +vt 0.253257 0.51249 +vt 0.215104 0.553361 +vt 0.241505 0.558876 +vt 0.268704 0.561105 +vt 0.190298 0.545736 +vt 0.166291 0.537055 +vt 0.187254 0.524533 +vt 0.161754 0.51849 +vt 0.170538 0.486314 +vt 0.179959 0.505005 +vt 0.157216 0.499924 +vt 0.24946 0.367438 +vt 0.258636 0.367175 +vt 0.255765 0.379731 +vt 0.262283 0.37965 +vt 0.255826 0.354536 +vt 0.268674 0.354878 +vt 0.268728 0.367451 +vt 0.234227 0.359499 +vt 0.242109 0.369275 +vt 0.228611 0.363909 +vt 0.23567 0.3719 +vt 0.249247 0.379811 +vt 0.215158 0.338968 +vt 0.227222 0.344776 +vt 0.214279 0.345817 +vt 0.224857 0.351242 +vt 0.221552 0.355917 +vt 0.240937 0.339238 +vt 0.227708 0.334728 +vt 0.215289 0.329543 +vt 0.268674 0.342201 +vt 0.254691 0.341571 +vt 0.244771 0.497304 +vt 0.256308 0.499747 +vt 0.268704 0.500841 +vt 0.268703 0.486337 +vt 0.258069 0.48605 +vt 0.225998 0.491141 +vt 0.227882 0.481103 +vt 0.234955 0.49435 +vt 0.237658 0.483058 +vt 0.249236 0.471672 +vt 0.239501 0.471434 +vt 0.250178 0.458265 +vt 0.240915 0.459645 +vt 0.229767 0.471064 +vt 0.25897 0.471644 +vt 0.268704 0.471564 +vt 0.259441 0.456884 +vt 0.203423 0.33552 +vt 0.203968 0.325186 +vt 0.193422 0.320894 +vt 0.18965 0.357864 +vt 0.190908 0.345555 +vt 0.202072 0.352895 +vt 0.202774 0.344537 +vt 0.18128 0.331343 +vt 0.179249 0.347026 +vt 0.17058 0.329645 +vt 0.167693 0.348723 +vt 0.177228 0.362833 +vt 0.183331 0.315904 +vt 0.173467 0.310566 +vt 0.17135 0.406685 +vt 0.182441 0.411169 +vt 0.16826 0.410583 +vt 0.176559 0.414437 +vt 0.155839 0.404764 +vt 0.157521 0.413533 +vt 0.166076 0.414524 +vt 0.172571 0.417098 +vt 0.135724 0.413665 +vt 0.144491 0.409813 +vt 0.142544 0.416326 +vt 0.148879 0.413937 +vt 0.13814 0.405626 +vt 0.124506 0.410074 +vt 0.174252 0.441387 +vt 0.171559 0.438762 +vt 0.181259 0.434168 +vt 0.176807 0.433082 +vt 0.186036 0.426037 +vt 0.174588 0.426678 +vt 0.172391 0.431921 +vt 0.168862 0.436383 +vt 0.180644 0.419795 +vt 0.175028 0.421443 +vt 0.186883 0.417995 +vt 0.149859 0.449516 +vt 0.140851 0.446115 +vt 0.152195 0.445145 +vt 0.145413 0.441926 +vt 0.158597 0.449574 +vt 0.159394 0.440679 +vt 0.154101 0.440679 +vt 0.14915 0.438598 +vt 0.165593 0.443116 +vt 0.164422 0.439274 +vt 0.166713 0.446693 +vt 0.121193 0.418911 +vt 0.132677 0.420037 +vt 0.1248 0.429441 +vt 0.142327 0.427533 +vt 0.140909 0.42129 +vt 0.13921 0.436123 +vt 0.145149 0.43376 +vt 0.131925 0.438966 +vt 0.718331 0.590305 +vt 0.746935 0.609408 +vt 0.714187 0.592962 +vt 0.74538 0.618837 +vt 0.776045 0.619539 +vt 0.775836 0.606046 +vt 0.748316 0.600181 +vt 0.698297 0.570265 +vt 0.691016 0.56935 +vt 0.678793 0.553513 +vt 0.668258 0.550016 +vt 0.682993 0.567088 +vt 0.724973 0.581367 +vt 0.704095 0.568485 +vt 0.726629 0.571953 +vt 0.707052 0.562689 +vt 0.687534 0.554647 +vt 0.775571 0.595734 +vt 0.74935 0.591359 +vt 0.749786 0.580241 +vt 0.631527 0.521919 +vt 0.643349 0.524282 +vt 0.641663 0.531566 +vt 0.653323 0.535777 +vt 0.66485 0.539385 +vt 0.649849 0.514184 +vt 0.635476 0.513181 +vt 0.647883 0.501604 +vt 0.631937 0.501954 +vt 0.62139 0.512271 +vt 0.684619 0.531929 +vt 0.668859 0.529 +vt 0.681508 0.516892 +vt 0.664797 0.515372 +vt 0.663468 0.501153 +vt 0.676113 0.541788 +vt 0.689104 0.545131 +vt 0.919101 0.529512 +vt 0.932277 0.513107 +vt 0.933894 0.53169 +vt 0.952549 0.514234 +vt 0.938271 0.4968 +vt 0.915407 0.496828 +vt 0.912378 0.512315 +vt 0.874997 0.559455 +vt 0.89162 0.543518 +vt 0.884334 0.563198 +vt 0.903546 0.546094 +vt 0.915238 0.549145 +vt 0.888008 0.52727 +vt 0.879227 0.541892 +vt 0.86975 0.528566 +vt 0.864702 0.54298 +vt 0.866281 0.556104 +vt 0.894945 0.496872 +vt 0.893224 0.512192 +vt 0.87312 0.513029 +vt 0.860186 0.581167 +vt 0.86658 0.586129 +vt 0.833052 0.598471 +vt 0.836578 0.605656 +vt 0.854086 0.575883 +vt 0.804878 0.613577 +vt 0.803304 0.602321 +vt 0.806576 0.625184 +vt 0.801979 0.591764 +vt 0.80095 0.579355 +vt 0.826879 0.582241 +vt 0.824828 0.570521 +vt 0.848572 0.569954 +vt 0.845415 0.561476 +vt 0.723056 0.499144 +vt 0.723365 0.520768 +vt 0.700461 0.499917 +vt 0.701169 0.518891 +vt 0.702985 0.536491 +vt 0.773996 0.544472 +vt 0.748527 0.544271 +vt 0.773366 0.521907 +vt 0.747679 0.521923 +vt 0.747248 0.498271 +vt 0.725988 0.558685 +vt 0.74937 0.564127 +vt 0.774586 0.566031 +vt 0.705814 0.551558 +vt 0.799676 0.520274 +vt 0.799659 0.497042 +vt 0.825661 0.517765 +vt 0.825711 0.49681 +vt 0.799857 0.542467 +vt 0.848896 0.532613 +vt 0.850371 0.515118 +vt 0.850862 0.496842 +vt 0.824745 0.55595 +vt 0.846383 0.548548 +vt 0.800262 0.562542 +vt 0.622835 0.741898 +vt 0.629822 0.737341 +vt 0.630937 0.748106 +vt 0.637348 0.741916 +vt 0.638168 0.732456 +vt 0.632743 0.72671 +vt 0.623594 0.732979 +vt 0.601364 0.736825 +vt 0.612351 0.737387 +vt 0.601727 0.746549 +vt 0.614012 0.74515 +vt 0.621199 0.753622 +vt 0.623692 0.721651 +vt 0.615298 0.729693 +vt 0.603694 0.727299 +vt 0.64705 0.720202 +vt 0.651064 0.728223 +vt 0.666861 0.725286 +vt 0.666356 0.736499 +vt 0.651523 0.736804 +vt 0.655097 0.70327 +vt 0.638367 0.712843 +vt 0.644545 0.693632 +vt 0.627328 0.703786 +vt 0.680292 0.699272 +vt 0.669656 0.692929 +vt 0.66043 0.68407 +vt 0.686784 0.713263 +vt 0.693307 0.702612 +vt 0.683906 0.72429 +vt 0.682763 0.73584 +vt 0.664776 0.7482 +vt 0.649538 0.745843 +vt 0.644256 0.754878 +vt 0.68235 0.760278 +vt 0.681446 0.748063 +vt 0.67624 0.777475 +vt 0.68787 0.771805 +vt 0.657375 0.798004 +vt 0.64028 0.785894 +vt 0.666427 0.786487 +vt 0.651148 0.774455 +vt 0.634824 0.763445 +vt 0.622928 0.773335 +vt 0.597165 0.801047 +vt 0.584037 0.816073 +vt 0.575655 0.789046 +vt 0.561282 0.802854 +vt 0.606349 0.829025 +vt 0.594793 0.84477 +vt 0.570888 0.831255 +vt 0.629233 0.799056 +vt 0.610251 0.786335 +vt 0.590115 0.774943 +vt 0.648026 0.811186 +vt 0.638424 0.825833 +vt 0.628613 0.841743 +vt 0.618698 0.858285 +vt 0.643447 0.660513 +vt 0.635997 0.646287 +vt 0.6049 0.637043 +vt 0.628919 0.631286 +vt 0.614692 0.652678 +vt 0.634531 0.681735 +vt 0.651642 0.673186 +vt 0.584936 0.681759 +vt 0.604883 0.675219 +vt 0.597105 0.697898 +vt 0.616244 0.690669 +vt 0.593009 0.659162 +vt 0.58088 0.642801 +vt 0.571868 0.665802 +vt 0.586302 0.735665 +vt 0.587541 0.725613 +vt 0.566532 0.713946 +vt 0.585456 0.714475 +vt 0.569532 0.724249 +vt 0.584349 0.745549 +vt 0.579071 0.755761 +vt 0.565094 0.743135 +vt 0.557994 0.751956 +vt 0.550572 0.731836 +vt 0.547179 0.740294 +vt 0.532926 0.729581 +vt 0.530226 0.737883 +vt 0.540511 0.747664 +vt 0.550413 0.713789 +vt 0.552359 0.722818 +vt 0.536163 0.720718 +vt 0.553225 0.778158 +vt 0.567858 0.766798 +vt 0.546459 0.760192 +vt 0.496408 0.78312 +vt 0.5145 0.775693 +vt 0.521696 0.80043 +vt 0.537687 0.789339 +vt 0.512875 0.758052 +vt 0.492969 0.762083 +vt 0.500324 0.747435 +vt 0.478432 0.748437 +vt 0.471121 0.76581 +vt 0.5289 0.753414 +vt 0.51732 0.74582 +vt 0.55219 0.672662 +vt 0.56563 0.687095 +vt 0.519008 0.667707 +vt 0.537934 0.658133 +vt 0.533662 0.679776 +vt 0.558759 0.703094 +vt 0.577435 0.701334 +vt 0.516448 0.703502 +vt 0.530573 0.696655 +vt 0.529774 0.709521 +vt 0.542602 0.705297 +vt 0.515971 0.687177 +vt 0.500082 0.677282 +vt 0.500703 0.696106 +vt 0.496419 0.736002 +vt 0.513862 0.73676 +vt 0.515969 0.727011 +vt 0.476228 0.734685 +vt 0.454664 0.733089 +vt 0.481514 0.721061 +vt 0.463494 0.717678 +vt 0.505915 0.712954 +vt 0.489445 0.707801 +vt 0.472325 0.702267 +vt 0.521085 0.717345 +vt 0.817772 0.32972 +vt 0.817268 0.334177 +vt 0.807098 0.329266 +vt 0.806518 0.333516 +vt 0.806012 0.337004 +vt 0.795796 0.333142 +vt 0.795184 0.336418 +vt 0.838686 0.341177 +vt 0.827785 0.339607 +vt 0.838685 0.335915 +vt 0.827985 0.335004 +vt 0.82832 0.330282 +vt 0.827498 0.348469 +vt 0.816308 0.345239 +vt 0.82763 0.344073 +vt 0.816582 0.341797 +vt 0.838688 0.346438 +vt 0.805553 0.339703 +vt 0.794562 0.338721 +vt 0.805117 0.342008 +vt 0.784417 0.336886 +vt 0.785167 0.333173 +vt 0.774651 0.33352 +vt 0.775476 0.328538 +vt 0.785864 0.328653 +vt 0.771718 0.345756 +vt 0.772735 0.341953 +vt 0.782822 0.342267 +vt 0.783629 0.339781 +vt 0.763085 0.339283 +vt 0.761859 0.344306 +vt 0.752475 0.340764 +vt 0.750993 0.34675 +vt 0.760614 0.349246 +vt 0.765302 0.328633 +vt 0.764271 0.334092 +vt 0.753958 0.334778 +vt 0.872696 0.335583 +vt 0.866407 0.338084 +vt 0.86882 0.330441 +vt 0.863658 0.333516 +vt 0.867867 0.343569 +vt 0.860064 0.340257 +vt 0.860616 0.34494 +vt 0.882136 0.339457 +vt 0.878875 0.332422 +vt 0.888775 0.336165 +vt 0.88462 0.328842 +vt 0.874176 0.326498 +vt 0.876903 0.354499 +vt 0.876407 0.348394 +vt 0.885368 0.353577 +vt 0.88421 0.346688 +vt 0.892061 0.343631 +vt 0.868751 0.349227 +vt 0.861168 0.349623 +vt 0.869036 0.354668 +vt 0.905832 0.318045 +vt 0.897126 0.314006 +vt 0.909273 0.307792 +vt 0.899606 0.305356 +vt 0.888216 0.310241 +vt 0.885668 0.315488 +vt 0.89379 0.320385 +vt 0.912856 0.338167 +vt 0.907418 0.331814 +vt 0.922353 0.328655 +vt 0.914539 0.322618 +vt 0.91968 0.310994 +vt 0.895263 0.331765 +vt 0.899861 0.338745 +vt 0.903538 0.34573 +vt 0.882771 0.319356 +vt 0.889606 0.32508 +vt 0.726761 0.338632 +vt 0.720269 0.333665 +vt 0.728661 0.332789 +vt 0.724048 0.328479 +vt 0.728685 0.324646 +vt 0.725283 0.320091 +vt 0.718943 0.323554 +vt 0.708141 0.33392 +vt 0.716815 0.339387 +vt 0.703619 0.340611 +vt 0.713734 0.345346 +vt 0.724861 0.344474 +vt 0.705092 0.321759 +vt 0.698212 0.327693 +vt 0.695328 0.313899 +vt 0.68654 0.320218 +vt 0.692159 0.335172 +vt 0.721158 0.3143 +vt 0.712853 0.317398 +vt 0.705649 0.309794 +vt 0.849098 0.333114 +vt 0.852849 0.328742 +vt 0.854305 0.334344 +vt 0.858906 0.330607 +vt 0.863427 0.326736 +vt 0.848559 0.322731 +vt 0.846187 0.327308 +vt 0.839608 0.321509 +vt 0.838379 0.326237 +vt 0.84389 0.331884 +vt 0.862887 0.316059 +vt 0.859996 0.320044 +vt 0.853481 0.313684 +vt 0.851078 0.31815 +vt 0.841341 0.316617 +vt 0.867789 0.322599 +vt 0.871643 0.31863 +vt 0.808609 0.31864 +vt 0.807782 0.324278 +vt 0.797841 0.317858 +vt 0.797082 0.323766 +vt 0.818436 0.324849 +vt 0.821851 0.307693 +vt 0.820468 0.313742 +vt 0.810856 0.305827 +vt 0.809616 0.312441 +vt 0.79869 0.311344 +vt 0.829771 0.320444 +vt 0.831091 0.315141 +vt 0.832672 0.309663 +vt 0.828882 0.32546 +vt 0.827295 0.287378 +vt 0.81609 0.283741 +vt 0.829537 0.279056 +vt 0.81819 0.275174 +vt 0.802762 0.289081 +vt 0.80451 0.280694 +vt 0.814142 0.291631 +vt 0.836158 0.298133 +vt 0.838143 0.291297 +vt 0.84681 0.301473 +vt 0.848714 0.295264 +vt 0.84041 0.283327 +vt 0.823454 0.301435 +vt 0.834348 0.304125 +vt 0.84504 0.30685 +vt 0.801169 0.296892 +vt 0.812381 0.298942 +vt 0.876986 0.311536 +vt 0.878898 0.306488 +vt 0.870963 0.295312 +vt 0.88062 0.29932 +vt 0.869186 0.302754 +vt 0.865464 0.312169 +vt 0.874638 0.315263 +vt 0.855505 0.309448 +vt 0.857319 0.304788 +vt 0.859093 0.299048 +vt 0.861066 0.291675 +vt 0.732418 0.318062 +vt 0.734712 0.322982 +vt 0.743001 0.327869 +vt 0.736781 0.327408 +vt 0.741594 0.322579 +vt 0.738426 0.310793 +vt 0.729673 0.312154 +vt 0.736628 0.303749 +vt 0.726615 0.305165 +vt 0.757036 0.316401 +vt 0.748245 0.31651 +vt 0.75687 0.309754 +vt 0.747447 0.310045 +vt 0.746533 0.302937 +vt 0.748795 0.322531 +vt 0.749221 0.328331 +vt 0.756792 0.322664 +vt 0.731654 0.277237 +vt 0.718591 0.277987 +vt 0.730298 0.26671 +vt 0.717089 0.267402 +vt 0.704046 0.278768 +vt 0.706282 0.288897 +vt 0.720525 0.287868 +vt 0.756105 0.285792 +vt 0.744751 0.286232 +vt 0.755817 0.276484 +vt 0.743878 0.276719 +vt 0.743048 0.266393 +vt 0.734816 0.295809 +vt 0.745635 0.294985 +vt 0.756313 0.294527 +vt 0.710968 0.298566 +vt 0.723383 0.296998 +vt 0.792536 0.278545 +vt 0.791154 0.28731 +vt 0.780323 0.277204 +vt 0.793935 0.269245 +vt 0.781204 0.267531 +vt 0.78873 0.303265 +vt 0.777827 0.302657 +vt 0.789858 0.295534 +vt 0.778545 0.294752 +vt 0.767676 0.285819 +vt 0.767323 0.294432 +vt 0.767022 0.302415 +vt 0.768024 0.276581 +vt 0.768346 0.266629 +vt 0.776124 0.323009 +vt 0.786496 0.323337 +vt 0.787134 0.317284 +vt 0.766566 0.316536 +vt 0.766062 0.322804 +vt 0.777196 0.310038 +vt 0.766828 0.309761 +vt 0.78785 0.310554 +vt 0.887192 0.245173 +vt 0.894254 0.251226 +vt 0.882204 0.253513 +vt 0.889316 0.257984 +vt 0.899158 0.259059 +vt 0.906216 0.25556 +vt 0.900579 0.245749 +vt 0.873068 0.226854 +vt 0.883747 0.231913 +vt 0.868263 0.235954 +vt 0.878436 0.240212 +vt 0.873612 0.249405 +vt 0.899039 0.231269 +vt 0.889175 0.22393 +vt 0.904851 0.223823 +vt 0.894483 0.215603 +vt 0.878092 0.21784 +vt 0.907771 0.240362 +vt 0.914548 0.251706 +vt 0.914646 0.233613 +vt 0.83088 0.224634 +vt 0.816277 0.220886 +vt 0.83396 0.214024 +vt 0.818586 0.209908 +vt 0.827947 0.235154 +vt 0.840898 0.238644 +vt 0.844486 0.228275 +vt 0.855747 0.197071 +vt 0.852027 0.207701 +vt 0.840323 0.192176 +vt 0.837098 0.203273 +vt 0.821041 0.19888 +vt 0.861296 0.22221 +vt 0.8657 0.212494 +vt 0.870075 0.20254 +vt 0.852868 0.242144 +vt 0.856947 0.232012 +vt 0.689623 0.215775 +vt 0.70332 0.207275 +vt 0.697939 0.222493 +vt 0.709017 0.215819 +vt 0.725203 0.22199 +vt 0.713143 0.224363 +vt 0.722188 0.211648 +vt 0.691318 0.186238 +vt 0.709695 0.179461 +vt 0.697458 0.197483 +vt 0.714155 0.190926 +vt 0.68169 0.206684 +vt 0.751207 0.197567 +vt 0.734425 0.198302 +vt 0.74968 0.185753 +vt 0.731649 0.18705 +vt 0.728678 0.175143 +vt 0.738996 0.220423 +vt 0.736932 0.209325 +vt 0.752641 0.20886 +vt 0.784858 0.21308 +vt 0.800826 0.216826 +vt 0.784162 0.2244 +vt 0.799325 0.227809 +vt 0.802394 0.205632 +vt 0.768345 0.19871 +vt 0.768707 0.210268 +vt 0.768953 0.22173 +vt 0.786206 0.189958 +vt 0.767985 0.186934 +vt 0.786915 0.177877 +vt 0.767639 0.174701 +vt 0.803984 0.194191 +vt 0.805673 0.182317 +vt 0.809955 0.252364 +vt 0.822756 0.255918 +vt 0.80815 0.262293 +vt 0.820407 0.265831 +vt 0.832047 0.269793 +vt 0.837735 0.249207 +vt 0.825254 0.245637 +vt 0.811949 0.242115 +vt 0.856542 0.267463 +vt 0.846044 0.263615 +vt 0.859897 0.256492 +vt 0.849272 0.252848 +vt 0.843066 0.273938 +vt 0.853522 0.278101 +vt 0.742291 0.255201 +vt 0.729185 0.255607 +vt 0.755289 0.255203 +vt 0.754976 0.243665 +vt 0.741468 0.243564 +vt 0.715531 0.256156 +vt 0.700801 0.256437 +vt 0.714427 0.244869 +vt 0.700028 0.24508 +vt 0.72694 0.232765 +vt 0.714289 0.234159 +vt 0.701971 0.234531 +vt 0.754532 0.231935 +vt 0.740439 0.231904 +vt 0.911041 0.2953 +vt 0.921301 0.296781 +vt 0.93161 0.297423 +vt 0.929903 0.281016 +vt 0.920542 0.281282 +vt 0.901221 0.293843 +vt 0.891715 0.291968 +vt 0.901867 0.281252 +vt 0.892897 0.280142 +vt 0.909625 0.267746 +vt 0.901437 0.269362 +vt 0.893739 0.269552 +vt 0.927824 0.264632 +vt 0.918548 0.265802 +vt 0.783513 0.23552 +vt 0.768967 0.233217 +vt 0.768829 0.24463 +vt 0.796609 0.249173 +vt 0.797938 0.238614 +vt 0.782032 0.257262 +vt 0.795284 0.259419 +vt 0.768618 0.255873 +vt 0.866329 0.271283 +vt 0.863474 0.282119 +vt 0.873054 0.28587 +vt 0.878455 0.263629 +vt 0.869642 0.26007 +vt 0.884271 0.277953 +vt 0.886283 0.267215 +vt 0.882397 0.289232 +vt 0.941581 0.296368 +vt 0.939264 0.280761 +vt 0.944658 0.31122 +vt 0.954503 0.308374 +vt 0.951091 0.294591 +vt 0.945764 0.266671 +vt 0.937066 0.26534 +vt 0.944666 0.253926 +vt 0.936188 0.251002 +vt 0.964594 0.279716 +vt 0.956479 0.280128 +vt 0.960523 0.267756 +vt 0.953407 0.267371 +vt 0.951694 0.255808 +vt 0.963661 0.306017 +vt 0.960023 0.293069 +vt 0.968665 0.291676 +vt 0.386764 0.173365 +vt 0.386251 0.159166 +vt 0.403134 0.175347 +vt 0.40173 0.162164 +vt 0.370756 0.187276 +vt 0.370795 0.173446 +vt 0.38669 0.187253 +vt 0.422389 0.190328 +vt 0.419955 0.177717 +vt 0.441316 0.192402 +vt 0.437002 0.180281 +vt 0.417209 0.165162 +vt 0.401826 0.214817 +vt 0.403793 0.201683 +vt 0.424104 0.215186 +vt 0.424198 0.203052 +vt 0.44563 0.204522 +vt 0.385442 0.200518 +vt 0.36925 0.200049 +vt 0.382596 0.213492 +vt 0.356262 0.189263 +vt 0.355175 0.177265 +vt 0.348714 0.166736 +vt 0.334762 0.173858 +vt 0.341079 0.182428 +vt 0.340863 0.211835 +vt 0.342946 0.202073 +vt 0.352708 0.211778 +vt 0.355322 0.200767 +vt 0.331414 0.194664 +vt 0.331412 0.203371 +vt 0.319782 0.196009 +vt 0.319946 0.204047 +vt 0.330031 0.212063 +vt 0.324674 0.179566 +vt 0.32968 0.18654 +vt 0.319256 0.188731 +vt 0.34302 0.232291 +vt 0.34877 0.222299 +vt 0.354926 0.235741 +vt 0.361782 0.224028 +vt 0.337711 0.221083 +vt 0.32682 0.236795 +vt 0.334971 0.241716 +vt 0.31849 0.242434 +vt 0.324587 0.249202 +vt 0.345001 0.247217 +vt 0.32414 0.227342 +vt 0.319507 0.233375 +vt 0.314915 0.225618 +vt 0.311922 0.231227 +vt 0.313143 0.237776 +vt 0.327627 0.220146 +vt 0.317481 0.219239 +vt 0.63785 0.953205 +vt 0.630881 0.947663 +vt 0.647016 0.946972 +vt 0.6392 0.9414 +vt 0.622289 0.952938 +vt 0.615431 0.946184 +vt 0.624837 0.941085 +vt 0.636439 0.963394 +vt 0.644947 0.958154 +vt 0.644288 0.966733 +vt 0.653209 0.961707 +vt 0.654465 0.952626 +vt 0.612697 0.965958 +vt 0.620878 0.963127 +vt 0.620821 0.970267 +vt 0.628164 0.967348 +vt 0.635184 0.970582 +vt 0.606875 0.951267 +vt 0.614197 0.957483 +vt 0.605619 0.960347 +vt 0.367121 0.917394 +vt 0.374142 0.923099 +vt 0.360165 0.922438 +vt 0.367724 0.92812 +vt 0.381201 0.91911 +vt 0.388569 0.925813 +vt 0.380653 0.929651 +vt 0.367048 0.90811 +vt 0.360477 0.912329 +vt 0.360243 0.904335 +vt 0.353385 0.908573 +vt 0.353375 0.916883 +vt 0.388646 0.907697 +vt 0.381128 0.909826 +vt 0.380927 0.902848 +vt 0.374115 0.905116 +vt 0.367999 0.901318 +vt 0.396044 0.921905 +vt 0.388216 0.915684 +vt 0.396055 0.913595 +vt 0.328818 0.915038 +vt 0.333156 0.924854 +vt 0.309844 0.916921 +vt 0.317341 0.929308 +vt 0.32345 0.950038 +vt 0.299401 0.934005 +vt 0.334074 0.942122 +vt 0.352513 0.92816 +vt 0.344718 0.920885 +vt 0.341477 0.913527 +vt 0.373801 0.947808 +vt 0.357974 0.943112 +vt 0.374058 0.938334 +vt 0.362633 0.93464 +vt 0.352852 0.95399 +vt 0.347499 0.966072 +vt 0.373169 0.960769 +vt 0.418321 0.915362 +vt 0.435775 0.918439 +vt 0.422947 0.925132 +vt 0.443681 0.930756 +vt 0.455589 0.922184 +vt 0.430406 0.905691 +vt 0.418226 0.905767 +vt 0.397194 0.906411 +vt 0.405585 0.913617 +vt 0.409188 0.921144 +vt 0.376316 0.893935 +vt 0.392361 0.898152 +vt 0.375205 0.897753 +vt 0.386735 0.900808 +vt 0.405223 0.889198 +vt 0.398631 0.894039 +vt 0.377906 0.887331 +vt 0.336894 0.897334 +vt 0.318775 0.906333 +vt 0.327696 0.895339 +vt 0.301524 0.906655 +vt 0.333962 0.906288 +vt 0.360174 0.89468 +vt 0.356966 0.889714 +vt 0.353868 0.884022 +vt 0.353137 0.901438 +vt 0.363602 0.898194 +vt 0.345023 0.906797 +vt 0.434342 0.941415 +vt 0.453466 0.949534 +vt 0.415406 0.950555 +vt 0.42616 0.960391 +vt 0.417515 0.933928 +vt 0.390161 0.946583 +vt 0.394517 0.958315 +vt 0.398853 0.971248 +vt 0.39657 0.933133 +vt 0.385766 0.937253 +vt 0.40528 0.927706 +vt 0.57922 0.909293 +vt 0.58971 0.919914 +vt 0.547117 0.922496 +vt 0.567321 0.931013 +vt 0.577999 0.948709 +vt 0.555818 0.943001 +vt 0.585011 0.938851 +vt 0.617202 0.922908 +vt 0.614188 0.910157 +vt 0.635979 0.920365 +vt 0.638841 0.906233 +vt 0.611323 0.89609 +vt 0.607883 0.938585 +vt 0.620514 0.933025 +vt 0.633926 0.930757 +vt 0.597671 0.945329 +vt 0.592645 0.95281 +vt 0.700973 0.938045 +vt 0.70873 0.951078 +vt 0.680671 0.943135 +vt 0.684796 0.953548 +vt 0.697126 0.916127 +vt 0.723976 0.932747 +vt 0.682579 0.924761 +vt 0.65736 0.940282 +vt 0.665771 0.947808 +vt 0.668833 0.955667 +vt 0.653673 0.924504 +vt 0.646476 0.933887 +vt 0.670275 0.899507 +vt 0.661753 0.912628 +vt 0.571389 0.966985 +vt 0.583228 0.967478 +vt 0.599576 0.982628 +vt 0.604894 0.978385 +vt 0.628092 0.978017 +vt 0.628226 0.984167 +vt 0.610106 0.974767 +vt 0.582286 0.958749 +vt 0.563995 0.95542 +vt 0.543202 0.951342 +vt 0.603906 0.967493 +vt 0.595571 0.96058 +vt 0.615108 0.972401 +vt 0.627917 0.974569 +vt 0.676098 0.972325 +vt 0.697647 0.962452 +vt 0.689295 0.973819 +vt 0.72006 0.961593 +vt 0.677946 0.963033 +vt 0.646577 0.976363 +vt 0.652459 0.980856 +vt 0.658529 0.986044 +vt 0.653384 0.96919 +vt 0.64107 0.973262 +vt 0.663671 0.963059 +vt 0.36984 0.23949 +vt 0.357948 0.252377 +vt 0.346028 0.26526 +vt 0.355607 0.271672 +vt 0.369662 0.258935 +vt 0.397205 0.227812 +vt 0.377725 0.226506 +vt 0.417354 0.23588 +vt 0.420828 0.226027 +vt 0.4431 0.22875 +vt 0.446522 0.222697 +vt 0.398497 0.266882 +vt 0.394993 0.256063 +vt 0.417376 0.253869 +vt 0.416668 0.245046 +vt 0.439677 0.234803 +vt 0.375987 0.26863 +vt 0.360587 0.280948 +vt 0.379618 0.279895 +vt 0.470993 0.595329 +vt 0.466212 0.581429 +vt 0.482679 0.589544 +vt 0.476881 0.579741 +vt 0.489311 0.600458 +vt 0.499356 0.579702 +vt 0.49224 0.574945 +vt 0.479771 0.564752 +vt 0.472749 0.572159 +vt 0.474256 0.558067 +vt 0.468458 0.56471 +vt 0.46434 0.573191 +vt 0.492648 0.557082 +vt 0.486003 0.554296 +vt 0.497062 0.544746 +vt 0.490231 0.543792 +vt 0.480758 0.549772 +vt 0.509401 0.558946 +vt 0.500678 0.558385 +vt 0.505852 0.543851 +vt 0.497996 0.536049 +vt 0.505621 0.535332 +vt 0.501948 0.53012 +vt 0.507915 0.530515 +vt 0.51368 0.534353 +vt 0.482316 0.532549 +vt 0.489579 0.530568 +vt 0.484501 0.537962 +vt 0.491239 0.536243 +vt 0.491373 0.524968 +vt 0.485801 0.52569 +vt 0.484285 0.519868 +vt 0.479547 0.521219 +vt 0.479193 0.527051 +vt 0.496798 0.525508 +vt 0.50215 0.526678 +vt 0.490005 0.520085 +vt 0.473801 0.535793 +vt 0.470659 0.528429 +vt 0.469034 0.521857 +vt 0.460157 0.521751 +vt 0.461514 0.530505 +vt 0.469248 0.549809 +vt 0.476929 0.543255 +vt 0.456268 0.544777 +vt 0.462181 0.555305 +vt 0.449568 0.548141 +vt 0.456741 0.560093 +vt 0.451562 0.524114 +vt 0.453071 0.533958 +vt 0.446261 0.536501 +vt 0.933404 0.221309 +vt 0.924739 0.213284 +vt 0.938258 0.211078 +vt 0.929637 0.202912 +vt 0.924585 0.183534 +vt 0.934625 0.192739 +vt 0.919804 0.19418 +vt 0.910176 0.214711 +vt 0.920022 0.224053 +vt 0.929173 0.232598 +vt 0.892208 0.188152 +vt 0.904301 0.196133 +vt 0.88756 0.198715 +vt 0.899431 0.206272 +vt 0.909372 0.185384 +vt 0.914544 0.174329 +vt 0.89751 0.177035 +vt 0.829357 0.162643 +vt 0.809729 0.156901 +vt 0.833272 0.14992 +vt 0.812406 0.143745 +vt 0.789947 0.13803 +vt 0.815325 0.130471 +vt 0.791208 0.124039 +vt 0.787797 0.165074 +vt 0.807536 0.169823 +vt 0.826253 0.175235 +vt 0.767318 0.161769 +vt 0.746459 0.160576 +vt 0.767097 0.147949 +vt 0.744921 0.146466 +vt 0.767051 0.133048 +vt 0.767091 0.117607 +vt 0.743596 0.130619 +vt 0.722473 0.147996 +vt 0.719464 0.132562 +vt 0.695065 0.137329 +vt 0.716504 0.116494 +vt 0.690034 0.121812 +vt 0.725582 0.162157 +vt 0.70494 0.166437 +vt 0.656395 0.167991 +vt 0.677929 0.158979 +vt 0.665245 0.182639 +vt 0.684786 0.173336 +vt 0.670811 0.143368 +vt 0.663563 0.127131 +vt 0.647183 0.151721 +vt 0.844502 0.359871 +vt 0.847714 0.360296 +vt 0.847408 0.363957 +vt 0.849348 0.364269 +vt 0.851648 0.36844 +vt 0.850981 0.368241 +vt 0.851475 0.364632 +vt 0.850753 0.356913 +vt 0.846081 0.356324 +vt 0.850205 0.353003 +vt 0.844447 0.352351 +vt 0.841595 0.355786 +vt 0.855799 0.357604 +vt 0.861641 0.358449 +vt 0.855262 0.361451 +vt 0.860512 0.36239 +vt 0.855963 0.353655 +vt 0.853976 0.365096 +vt 0.852315 0.368639 +vt 0.858224 0.366005 +vt 0.720036 0.362311 +vt 0.71959 0.357661 +vt 0.728015 0.361123 +vt 0.727779 0.35756 +vt 0.73391 0.360061 +vt 0.73344 0.362971 +vt 0.728708 0.364784 +vt 0.736235 0.351526 +vt 0.735307 0.354339 +vt 0.729598 0.350921 +vt 0.728459 0.354192 +vt 0.720575 0.353357 +vt 0.740522 0.356645 +vt 0.741697 0.354388 +vt 0.746207 0.356041 +vt 0.747858 0.354388 +vt 0.742872 0.352131 +vt 0.739347 0.358902 +vt 0.738172 0.361159 +vt 0.744555 0.357694 +vt 0.878699 0.181029 +vt 0.883387 0.169647 +vt 0.867761 0.162851 +vt 0.888238 0.158069 +vt 0.871973 0.151014 +vt 0.874335 0.192023 +vt 0.859716 0.186019 +vt 0.843668 0.180528 +vt 0.847301 0.168505 +vt 0.85139 0.156282 +vt 0.855707 0.143958 +vt 0.959959 0.243101 +vt 0.954077 0.238396 +vt 0.961713 0.236753 +vt 0.956323 0.230743 +vt 0.954067 0.216174 +vt 0.958767 0.22329 +vt 0.950811 0.224595 +vt 0.952226 0.24645 +vt 0.945638 0.243001 +vt 0.958206 0.249448 +vt 0.941091 0.227849 +vt 0.937833 0.238648 +vt 0.949366 0.209059 +vt 0.945053 0.218173 +vt 0.336934 0.71568 +vt 0.33038 0.741466 +vt 0.302716 0.711537 +vt 0.299424 0.738297 +vt 0.295776 0.762787 +vt 0.393479 0.752977 +vt 0.377463 0.773803 +vt 0.361811 0.746705 +vt 0.350155 0.769363 +vt 0.371566 0.72393 +vt 0.338262 0.791261 +vt 0.32625 0.812779 +vt 0.315076 0.788147 +vt 0.307068 0.810102 +vt 0.361448 0.794629 +vt 0.29189 0.78554 +vt 0.287886 0.807426 +vt 0.299023 0.2659 +vt 0.299047 0.279209 +vt 0.283956 0.266822 +vt 0.283986 0.280354 +vt 0.283688 0.295775 +vt 0.327087 0.27663 +vt 0.323816 0.291325 +vt 0.313749 0.277461 +vt 0.311916 0.292761 +vt 0.31433 0.263721 +vt 0.296663 0.325331 +vt 0.297456 0.310292 +vt 0.309865 0.321929 +vt 0.31066 0.307783 +vt 0.322425 0.305028 +vt 0.283294 0.311929 +vt 0.282898 0.327607 +vt 0.281812 0.241506 +vt 0.281311 0.235544 +vt 0.29388 0.241063 +vt 0.292617 0.235389 +vt 0.282538 0.248141 +vt 0.307969 0.245729 +vt 0.304463 0.240079 +vt 0.302421 0.235265 +vt 0.297743 0.255375 +vt 0.311831 0.253377 +vt 0.283363 0.256332 +vt 0.665914 0.351378 +vt 0.682493 0.354562 +vt 0.661557 0.365446 +vt 0.679123 0.366239 +vt 0.694271 0.365301 +vt 0.676262 0.378559 +vt 0.692167 0.374571 +vt 0.699871 0.348099 +vt 0.686879 0.344167 +vt 0.6718 0.339046 +vt 0.709168 0.357329 +vt 0.711074 0.351244 +vt 0.708348 0.363848 +vt 0.708071 0.370584 +vt 0.867597 0.363815 +vt 0.865591 0.367703 +vt 0.874845 0.369526 +vt 0.873284 0.373919 +vt 0.863133 0.371378 +vt 0.876827 0.360099 +vt 0.868698 0.3595 +vt 0.885694 0.365176 +vt 0.885881 0.359586 +vt 0.896427 0.363349 +vt 0.895778 0.357262 +vt 0.884753 0.370807 +vt 0.883435 0.376459 +vt 0.896131 0.370165 +vt 0.908527 0.359153 +vt 0.909799 0.366215 +vt 0.924545 0.360491 +vt 0.927731 0.367892 +vt 0.910658 0.373446 +vt 0.917439 0.345549 +vt 0.906434 0.352429 +vt 0.933647 0.34626 +vt 0.928384 0.337086 +vt 0.944982 0.340124 +vt 0.93903 0.329282 +vt 0.939163 0.354526 +vt 0.944804 0.362339 +vt 0.951802 0.349505 +vt 0.954599 0.336095 +vt 0.960613 0.346611 +vt 0.967306 0.344981 +vt 0.971931 0.35627 +vt 0.966904 0.356527 +vt 0.949139 0.32438 +vt 0.958528 0.321259 +vt 0.967014 0.318797 +vt 0.975048 0.316665 +vt 0.970264 0.331384 +vt 0.97736 0.329695 +vt 0.976958 0.356012 +vt 0.973591 0.343753 +vt 0.979672 0.342725 +vt 0.320524 0.146521 +vt 0.313373 0.154734 +vt 0.2954 0.141698 +vt 0.292003 0.150779 +vt 0.28884 0.159589 +vt 0.322801 0.167455 +vt 0.333528 0.159639 +vt 0.345648 0.151344 +vt 0.301572 0.170503 +vt 0.31486 0.174313 +vt 0.297761 0.178302 +vt 0.309891 0.180957 +vt 0.286147 0.16786 +vt 0.284108 0.176013 +vt 0.296019 0.186221 +vt 0.282908 0.18447 +vt 0.282346 0.192959 +vt 0.307895 0.195694 +vt 0.308085 0.188134 +vt 0.295125 0.202337 +vt 0.307775 0.203492 +vt 0.294766 0.209933 +vt 0.307347 0.211107 +vt 0.28222 0.201212 +vt 0.28215 0.209032 +vt 0.294211 0.217025 +vt 0.281754 0.216221 +vt 0.281328 0.222946 +vt 0.304681 0.22447 +vt 0.306231 0.218115 +vt 0.292675 0.229646 +vt 0.302952 0.230124 +vt 0.281165 0.229372 +vt 0.305534 0.681974 +vt 0.306111 0.650222 +vt 0.342004 0.687835 +vt 0.333707 0.612749 +vt 0.302684 0.616894 +vt 0.325885 0.580428 +vt 0.298274 0.585332 +vt 0.395357 0.618639 +vt 0.374414 0.634434 +vt 0.380969 0.58713 +vt 0.358816 0.601672 +vt 0.349578 0.570739 +vt 0.384513 0.681504 +vt 0.395957 0.664926 +vt 0.416814 0.706905 +vt 0.420474 0.694282 +vt 0.409745 0.650149 +vt 0.377758 0.701684 +vt 0.413154 0.719528 +vt 0.338053 0.278233 +vt 0.345863 0.28289 +vt 0.333606 0.290848 +vt 0.34226 0.309133 +vt 0.341074 0.298701 +vt 0.351677 0.302345 +vt 0.349731 0.291219 +vt 0.332267 0.302652 +vt 0.332584 0.313884 +vt 0.387723 0.422423 +vt 0.382162 0.422373 +vt 0.388869 0.417427 +vt 0.382859 0.417822 +vt 0.377549 0.413541 +vt 0.384244 0.41338 +vt 0.377169 0.417955 +vt 0.377116 0.426931 +vt 0.381664 0.426972 +vt 0.377432 0.431442 +vt 0.381856 0.431562 +vt 0.386531 0.427438 +vt 0.367249 0.422554 +vt 0.372123 0.422513 +vt 0.368692 0.426806 +vt 0.372857 0.426712 +vt 0.373317 0.430853 +vt 0.371782 0.41828 +vt 0.37118 0.414106 +vt 0.366505 0.41823 +vt 0.426004 0.390403 +vt 0.398456 0.389437 +vt 0.424679 0.386349 +vt 0.396424 0.386762 +vt 0.363793 0.388475 +vt 0.394705 0.384351 +vt 0.356716 0.386401 +vt 0.378598 0.396645 +vt 0.375308 0.393171 +vt 0.401577 0.396345 +vt 0.401115 0.392641 +vt 0.428621 0.394516 +vt 0.353918 0.396416 +vt 0.339672 0.402446 +vt 0.345629 0.394106 +vt 0.329812 0.40053 +vt 0.35953 0.398947 +vt 0.33321 0.391382 +vt 0.318726 0.38845 +vt 0.313563 0.397303 +vt 0.476084 0.423195 +vt 0.45045 0.417502 +vt 0.486588 0.412986 +vt 0.456271 0.406372 +vt 0.430198 0.413801 +vt 0.423791 0.426121 +vt 0.43912 0.429517 +vt 0.507665 0.429493 +vt 0.542219 0.436093 +vt 0.475452 0.439099 +vt 0.495356 0.444524 +vt 0.525393 0.419675 +vt 0.43331 0.443713 +vt 0.441295 0.448141 +vt 0.411039 0.45059 +vt 0.411532 0.454564 +vt 0.448493 0.452954 +vt 0.423753 0.440055 +vt 0.413961 0.436871 +vt 0.407352 0.447798 +vt 0.31374 0.40806 +vt 0.32634 0.410021 +vt 0.317907 0.421046 +vt 0.299322 0.405773 +vt 0.325214 0.421259 +vt 0.338474 0.421652 +vt 0.3353 0.411329 +vt 0.344846 0.421904 +vt 0.34232 0.412499 +vt 0.355509 0.44277 +vt 0.342793 0.432971 +vt 0.357815 0.441106 +vt 0.346865 0.432004 +vt 0.351296 0.431202 +vt 0.336492 0.43632 +vt 0.339458 0.434504 +vt 0.354149 0.44545 +vt 0.366963 0.45175 +vt 0.367513 0.449587 +vt 0.378353 0.456489 +vt 0.366715 0.454041 +vt 0.379286 0.45488 +vt 0.368666 0.447681 +vt 0.369978 0.445476 +vt 0.38013 0.451272 +vt 0.379885 0.448331 +vt 0.392918 0.451424 +vt 0.393862 0.45378 +vt 0.390643 0.448651 +vt 0.392502 0.456314 +vt 0.389991 0.458936 +vt 0.434919 0.382651 +vt 0.453791 0.389264 +vt 0.433807 0.382477 +vt 0.442133 0.387347 +vt 0.449541 0.392567 +vt 0.49183 0.400597 +vt 0.464657 0.391608 +vt 0.513113 0.405332 +vt 0.475128 0.394166 +vt 0.436031 0.382826 +vt 0.516095 0.409998 +vt 0.483347 0.40387 +vt 0.551098 0.416497 +vt 0.455111 0.398484 +vt 0.472738 0.503366 +vt 0.465757 0.493643 +vt 0.482409 0.502085 +vt 0.475421 0.491708 +vt 0.456009 0.49597 +vt 0.450804 0.485866 +vt 0.459618 0.483598 +vt 0.474669 0.513513 +vt 0.481402 0.512442 +vt 0.489397 0.512463 +vt 0.46027 0.514483 +vt 0.470459 0.516768 +vt 0.449301 0.508912 +vt 0.450715 0.51651 +vt 0.441643 0.516565 +vt 0.44392 0.523436 +vt 0.44199 0.488134 +vt 0.446094 0.499081 +vt 0.437618 0.505763 +vt 0.409641 0.53125 +vt 0.417486 0.517634 +vt 0.424725 0.549489 +vt 0.428372 0.534587 +vt 0.421164 0.563953 +vt 0.440531 0.58304 +vt 0.440131 0.567599 +vt 0.438076 0.530458 +vt 0.43219 0.518805 +vt 0.42533 0.504018 +vt 0.445266 0.55059 +vt 0.442015 0.535846 +vt 0.453943 0.564519 +vt 0.453765 0.571874 +vt 0.456182 0.585446 +vt 0.459898 0.602127 +vt 0.349013 0.491269 +vt 0.336754 0.508239 +vt 0.331154 0.496224 +vt 0.320148 0.507781 +vt 0.297949 0.508264 +vt 0.308444 0.503271 +vt 0.306838 0.517622 +vt 0.350155 0.524533 +vt 0.35745 0.505005 +vt 0.375656 0.518489 +vt 0.380193 0.499924 +vt 0.366871 0.486313 +vt 0.322305 0.553361 +vt 0.347111 0.545735 +vt 0.371118 0.537055 +vt 0.293484 0.538213 +vt 0.295904 0.558876 +vt 0.288923 0.524031 +vt 0.284152 0.512489 +vt 0.281519 0.354585 +vt 0.27883 0.367232 +vt 0.275331 0.37971 +vt 0.281861 0.37985 +vt 0.288051 0.367559 +vt 0.296239 0.339242 +vt 0.282591 0.341601 +vt 0.310112 0.344766 +vt 0.309416 0.334597 +vt 0.322149 0.338741 +vt 0.321809 0.329248 +vt 0.30337 0.359703 +vt 0.312751 0.351414 +vt 0.309216 0.364244 +vt 0.316363 0.356301 +vt 0.323307 0.345678 +vt 0.295502 0.369475 +vt 0.288392 0.37999 +vt 0.302069 0.372187 +vt 0.281101 0.499747 +vt 0.27934 0.48605 +vt 0.292638 0.497304 +vt 0.28723 0.458265 +vt 0.288173 0.471672 +vt 0.277967 0.456884 +vt 0.278439 0.471644 +vt 0.299751 0.483057 +vt 0.297907 0.471434 +vt 0.309526 0.481102 +vt 0.307642 0.471064 +vt 0.296494 0.459645 +vt 0.302454 0.49435 +vt 0.311411 0.491141 +vt 0.343632 0.320416 +vt 0.333105 0.324778 +vt 0.333814 0.334838 +vt 0.363585 0.310039 +vt 0.366431 0.327171 +vt 0.353718 0.315393 +vt 0.355806 0.329495 +vt 0.346397 0.343469 +vt 0.357889 0.343783 +vt 0.347817 0.354895 +vt 0.35997 0.358164 +vt 0.369277 0.344302 +vt 0.334695 0.343565 +vt 0.335664 0.351626 +vt 0.379291 0.400052 +vt 0.363918 0.402333 +vt 0.367243 0.406178 +vt 0.353116 0.407088 +vt 0.35919 0.410239 +vt 0.41091 0.404675 +vt 0.399926 0.408536 +vt 0.397021 0.400516 +vt 0.390935 0.404866 +vt 0.37815 0.408898 +vt 0.386805 0.409108 +vt 0.393279 0.411364 +vt 0.363338 0.412821 +vt 0.369666 0.410088 +vt 0.350438 0.422105 +vt 0.355707 0.430165 +vt 0.363148 0.437257 +vt 0.365676 0.434559 +vt 0.360087 0.428972 +vt 0.349098 0.414046 +vt 0.35544 0.415713 +vt 0.361911 0.422489 +vt 0.36115 0.417241 +vt 0.368224 0.432108 +vt 0.364426 0.427706 +vt 0.379285 0.445126 +vt 0.388009 0.44487 +vt 0.385408 0.440532 +vt 0.396797 0.441249 +vt 0.391983 0.437144 +vt 0.371003 0.442416 +vt 0.371902 0.438797 +vt 0.377944 0.436209 +vt 0.372836 0.434912 +vt 0.388047 0.433887 +vt 0.38323 0.436089 +vt 0.411804 0.424136 +vt 0.414761 0.413476 +vt 0.40336 0.414868 +vt 0.405273 0.433865 +vt 0.397822 0.431174 +vt 0.394183 0.422617 +vt 0.391746 0.428935 +vt 0.395216 0.416313 +vt 0.775924 0.375151 +vt 0.775728 0.388743 +vt 0.746453 0.386032 +vt 0.747928 0.395308 +vt 0.717395 0.406114 +vt 0.713072 0.403611 +vt 0.744823 0.376573 +vt 0.749092 0.40422 +vt 0.749645 0.415483 +vt 0.72449 0.414957 +vt 0.72621 0.424666 +vt 0.7756 0.399248 +vt 0.70368 0.428763 +vt 0.687208 0.443737 +vt 0.697322 0.42707 +vt 0.677635 0.445158 +vt 0.707038 0.434775 +vt 0.68965 0.428163 +vt 0.681322 0.43065 +vt 0.666675 0.448773 +vt 0.663815 0.460707 +vt 0.651924 0.464538 +vt 0.630412 0.480156 +vt 0.639991 0.468922 +vt 0.642366 0.477595 +vt 0.66825 0.472074 +vt 0.675624 0.457981 +vt 0.68415 0.468328 +vt 0.689031 0.45406 +vt 0.649396 0.488552 +vt 0.664408 0.486592 +vt 0.681197 0.484039 +vt 0.634969 0.490079 +vt 0.620833 0.49139 +vt 0.912385 0.481335 +vt 0.932278 0.480511 +vt 0.952544 0.479369 +vt 0.933883 0.461959 +vt 0.919103 0.464149 +vt 0.869741 0.465154 +vt 0.887953 0.466437 +vt 0.873151 0.480724 +vt 0.893241 0.481526 +vt 0.865824 0.437779 +vt 0.874945 0.43437 +vt 0.878921 0.451884 +vt 0.891561 0.450226 +vt 0.864248 0.450831 +vt 0.915223 0.44455 +vt 0.903554 0.447624 +vt 0.884353 0.430602 +vt 0.854087 0.418075 +vt 0.860227 0.412749 +vt 0.833101 0.395604 +vt 0.866565 0.407739 +vt 0.836568 0.388337 +vt 0.826949 0.411924 +vt 0.848341 0.424031 +vt 0.824944 0.4236 +vt 0.84502 0.432484 +vt 0.803376 0.3921 +vt 0.802127 0.402739 +vt 0.801153 0.415145 +vt 0.804904 0.380706 +vt 0.806571 0.368936 +vt 0.702688 0.462561 +vt 0.700952 0.48073 +vt 0.723247 0.47733 +vt 0.725766 0.438352 +vt 0.705712 0.446642 +vt 0.74847 0.451919 +vt 0.749286 0.431814 +vt 0.774044 0.450536 +vt 0.774704 0.42899 +vt 0.747651 0.474504 +vt 0.773403 0.473071 +vt 0.799984 0.45176 +vt 0.799741 0.47385 +vt 0.825727 0.475971 +vt 0.824826 0.438046 +vt 0.800446 0.431839 +vt 0.848903 0.461112 +vt 0.846154 0.445298 +vt 0.850422 0.478567 +vt 0.62364 0.273336 +vt 0.631303 0.268742 +vt 0.633284 0.279074 +vt 0.640023 0.273125 +vt 0.639784 0.263935 +vt 0.632769 0.258173 +vt 0.623739 0.264647 +vt 0.600029 0.280268 +vt 0.598688 0.270903 +vt 0.613376 0.277111 +vt 0.610984 0.269667 +vt 0.621969 0.284647 +vt 0.621719 0.253201 +vt 0.613611 0.261924 +vt 0.599928 0.261159 +vt 0.670072 0.278979 +vt 0.653616 0.276716 +vt 0.669832 0.267969 +vt 0.654614 0.268283 +vt 0.648422 0.284838 +vt 0.690213 0.290189 +vt 0.687377 0.279381 +vt 0.68627 0.268024 +vt 0.683842 0.304224 +vt 0.697203 0.300525 +vt 0.645124 0.311795 +vt 0.656458 0.301386 +vt 0.663002 0.320505 +vt 0.672639 0.311009 +vt 0.637949 0.292669 +vt 0.625515 0.302527 +vt 0.64648 0.25088 +vt 0.652498 0.259521 +vt 0.667905 0.256541 +vt 0.65209 0.231125 +vt 0.635774 0.242815 +vt 0.639961 0.22002 +vt 0.62248 0.233347 +vt 0.677556 0.227123 +vt 0.666981 0.218489 +vt 0.656893 0.207226 +vt 0.684642 0.243963 +vt 0.689474 0.232327 +vt 0.684466 0.25604 +vt 0.602642 0.176918 +vt 0.580529 0.190632 +vt 0.589953 0.161017 +vt 0.566382 0.1753 +vt 0.557833 0.204588 +vt 0.573039 0.21849 +vt 0.594645 0.205765 +vt 0.635672 0.179448 +vt 0.62466 0.163426 +vt 0.613523 0.146733 +vt 0.646437 0.19413 +vt 0.627782 0.207015 +vt 0.588272 0.232651 +vt 0.608699 0.2205 +vt 0.608211 0.373618 +vt 0.616832 0.356454 +vt 0.634284 0.378082 +vt 0.640225 0.361705 +vt 0.646724 0.346174 +vt 0.603899 0.333518 +vt 0.593087 0.35113 +vt 0.582299 0.32801 +vt 0.570201 0.34546 +vt 0.582138 0.369154 +vt 0.635039 0.324678 +vt 0.614437 0.31673 +vt 0.593411 0.310569 +vt 0.65434 0.332333 +vt 0.561644 0.296106 +vt 0.564966 0.285457 +vt 0.580542 0.294418 +vt 0.583116 0.283009 +vt 0.582766 0.272899 +vt 0.546607 0.278466 +vt 0.547908 0.287734 +vt 0.528899 0.281331 +vt 0.53186 0.290461 +vt 0.545646 0.297066 +vt 0.561955 0.266155 +vt 0.543727 0.269714 +vt 0.555322 0.257166 +vt 0.537387 0.262094 +vt 0.526554 0.27266 +vt 0.581699 0.262937 +vt 0.576957 0.252641 +vt 0.565582 0.241532 +vt 0.543702 0.248829 +vt 0.550357 0.230094 +vt 0.496387 0.262785 +vt 0.509284 0.25153 +vt 0.513745 0.264403 +vt 0.525705 0.256225 +vt 0.51058 0.233141 +vt 0.488727 0.247432 +vt 0.491672 0.225616 +vt 0.466102 0.243633 +vt 0.473932 0.261753 +vt 0.534066 0.218808 +vt 0.517242 0.2076 +vt 0.516335 0.345283 +vt 0.530115 0.332372 +vt 0.5362 0.354987 +vt 0.549386 0.339171 +vt 0.561842 0.32354 +vt 0.526052 0.315178 +vt 0.511862 0.325172 +vt 0.511906 0.308506 +vt 0.496234 0.31623 +vt 0.49647 0.33558 +vt 0.537837 0.306011 +vt 0.553916 0.307529 +vt 0.525234 0.302122 +vt 0.572839 0.308275 +vt 0.511827 0.28428 +vt 0.509974 0.274041 +vt 0.492244 0.274874 +vt 0.501435 0.298913 +vt 0.516739 0.294259 +vt 0.458569 0.293763 +vt 0.476889 0.290416 +vt 0.467587 0.30982 +vt 0.484835 0.304206 +vt 0.471621 0.276173 +vt 0.449551 0.277706 +vt 0.79029 0.672484 +vt 0.810842 0.6624 +vt 0.788538 0.66243 +vt 0.832155 0.647948 +vt 0.833088 0.669026 +vt 0.767347 0.664111 +vt 0.749725 0.673721 +vt 0.741816 0.650008 +vt 0.85403 0.66365 +vt 0.868881 0.657298 +vt 0.85539 0.645025 +vt 0.888074 0.648027 +vt 0.874212 0.676013 +vt 0.886607 0.695639 +vt 0.89598 0.672443 +vt 0.929571 0.681021 +vt 0.72496 0.675077 +vt 0.707382 0.674426 +vt 0.711754 0.695525 +vt 0.674442 0.675309 +vt 0.715494 0.652696 +vt 0.851241 0.674754 +vt 0.83861 0.688008 +vt 0.813905 0.681083 +vt 0.795054 0.69679 +vt 0.803314 0.729031 +vt 0.821237 0.705648 +vt 0.847489 0.712022 +vt 0.863108 0.691149 +vt 0.734908 0.685353 +vt 0.751974 0.699565 +vt 0.699285 0.735409 +vt 0.729177 0.71566 +vt 0.752628 0.735708 +vt 0.775609 0.715256 +vt 0.771295 0.685081 +vt 0.892477 0.736968 +vt 0.891992 0.760942 +vt 0.924257 0.752441 +vt 0.883161 0.790753 +vt 0.862406 0.753942 +vt 0.813012 0.768991 +vt 0.847704 0.781855 +vt 0.824711 0.812689 +vt 0.703179 0.776568 +vt 0.71878 0.801121 +vt 0.75314 0.781706 +vt 0.750148 0.828139 +vt 0.674567 0.808938 +vt 0.785894 0.799205 +vt 0.832437 0.740517 +vt 0.726143 0.758511 +vt 0.908808 0.716733 +vt 0.780855 0.754707 +vt 0.872961 0.724451 +vt 0.947275 0.716911 +vt 0.972864 0.691703 +vt 0.956423 0.743409 +vt 0.170337 0.155827 +vt 0.136076 0.187112 +vt 0.172299 0.21177 +vt 0.0899929 0.213591 +vt 0.10853 0.16596 +vt 0.195445 0.192426 +vt 0.220169 0.183556 +vt 0.218642 0.212212 +vt 0.204829 0.229447 +vt 0.228379 0.234767 +vt 0.205687 0.259413 +vt 0.137176 0.927417 +vt 0.140528 0.948093 +vt 0.168383 0.944741 +vt 0.141913 0.961891 +vt 0.11077 0.946594 +vt 0.878967 0.954757 +vt 0.879367 0.938048 +vt 0.853203 0.941375 +vt 0.880712 0.92523 +vt 0.906681 0.938262 +vt 0.989055 0.9382 +vt 0.912651 0.957127 +vt 0.886501 1.00065 +vt 0.775015 0.959635 +vt 0.84864 0.929044 +vt 0.877392 0.895069 +vt 0.91222 0.923978 +vt 0.849069 0.962192 +vt 0.254826 0.925518 +vt 0.170213 0.919654 +vt 0.126415 0.872706 +vt 0.0190149 0.939185 +vt 0.100899 0.922774 +vt 0.142077 0.988088 +vt 0.17534 0.957124 +vt 0.106027 0.960245 +vt 0.148988 0.242126 +vt 0.176354 0.291487 +vt 0.102893 0.237993 +vt 0.044388 0.5061 +vt 0.0504472 0.534124 +vt 0.0221481 0.572717 +vt 0.0611958 0.546374 +vt 0.0719578 0.52396 +vt 0.0576334 0.571748 +vt 0.0664284 0.60486 +vt 0.0810156 0.564522 +vt 0.0825732 0.542567 +vt 0.101769 0.534189 +vt 0.944378 0.797731 +vt 0.915109 0.794589 +vt 0.905965 0.833567 +vt 0.842874 0.862029 +vt 0.791851 0.848437 +vt 0.748723 0.889561 +vt 0.703598 0.850293 +vt 0.642603 0.8718 +vt 0.843173 0.630902 +vt 0.84458 0.638283 +vt 0.846408 0.629484 +vt 0.71498 0.637314 +vt 0.726461 0.64589 +vt 0.734897 0.643187 +vt 0.865004 0.824698 +vt 0.962666 0.771065 +vt 0.94749 0.766441 +vt 0.268705 0.710477 +vt 0.214528 0.765549 +vt 0.268705 0.80475 +vt 0.191977 0.815455 +vt 0.127915 0.732152 +vt 0.268814 0.267129 +vt 0.238957 0.294344 +vt 0.268669 0.328244 +vt 0.215045 0.317962 +vt 0.269051 0.235581 +vt 0.241893 0.247542 +vt 0.652939 0.625528 +vt 0.689461 0.648127 +vt 0.870091 0.634597 +vt 0.889967 0.621532 +vt 0.917129 0.645104 +vt 0.960269 0.639284 +vt 0.9614 0.662237 +vt 0.981019 0.639244 +vt 0.270276 0.136874 +vt 0.232631 0.163206 +vt 0.269409 0.175133 +vt 0.242681 0.194855 +vt 0.269141 0.208639 +vt 0.244466 0.223601 +vt 0.189521 0.653078 +vt 0.113276 0.681659 +vt 0.170828 0.555621 +vt 0.268705 0.586687 +vt 0.197069 0.290309 +vt 0.147015 0.418787 +vt 0.159401 0.426978 +vt 0.169209 0.419346 +vt 0.166865 0.4343 +vt 0.151569 0.435731 +vt 0.101359 0.388325 +vt 0.164076 0.395797 +vt 0.253799 0.393043 +vt 0.188648 0.408382 +vt 0.10719 0.406598 +vt 0.0810976 0.440196 +vt 0.135792 0.449792 +vt 0.137248 0.466241 +vt -0.0522421 0.436952 +vt 0.203585 0.425014 +vt 0.183198 0.455456 +vt 0.176955 0.4435 +vt 0.158284 0.457002 +vt 0.0646922 0.403325 +vt 0.0969534 0.389119 +vt 0.127418 0.569795 +vt 0.101838 0.557019 +vt 0.115165 0.496827 +vt 0.0856225 0.479205 +vt 0.0876161 0.508163 +vt 0.224113 0.501179 +vt 0.216094 0.528531 +vt 0.268704 0.514179 +vt 0.152679 0.481359 +vt 0.268801 0.37957 +vt 0.241478 0.353126 +vt 0.242729 0.379892 +vt 0.214493 0.347926 +vt 0.247642 0.484503 +vt 0.231652 0.461026 +vt 0.268704 0.455503 +vt 0.192219 0.333104 +vt 0.164806 0.367802 +vt 0.156354 0.409665 +vt 0.179537 0.42641 +vt 0.158914 0.444672 +vt 0.1348 0.428233 +vt 0.776574 0.644712 +vt 0.722394 0.585817 +vt 0.651799 0.541213 +vt 0.694305 0.554226 +vt 0.775203 0.583316 +vt 0.656336 0.526524 +vt 0.611254 0.502624 +vt 0.680604 0.50058 +vt 0.971205 0.496778 +vt 0.903217 0.52798 +vt 0.896582 0.566601 +vt 0.859045 0.553539 +vt 0.874064 0.496896 +vt 0.829393 0.590056 +vt 0.725299 0.540094 +vt 0.773136 0.497495 +vt 0.8247 0.537119 +vt 0.64197 0.737033 +vt 0.61964 0.737363 +vt 0.604328 0.759732 +vt 0.608299 0.714718 +vt 0.667128 0.712276 +vt 0.663413 0.762979 +vt 0.546984 0.81774 +vt 0.617742 0.813781 +vt 0.624356 0.66752 +vt 0.55686 0.648558 +vt 0.568421 0.733816 +vt 0.529143 0.743889 +vt 0.538817 0.714517 +vt 0.531598 0.768055 +vt 0.445833 0.7485 +vt 0.547123 0.691597 +vt 0.481156 0.686856 +vt 0.499408 0.724217 +vt 0.796428 0.328877 +vt 0.8169 0.338119 +vt 0.838683 0.330654 +vt 0.838689 0.3517 +vt 0.793926 0.338777 +vt 0.773732 0.337889 +vt 0.74951 0.352736 +vt 0.755441 0.328792 +vt 0.859512 0.335574 +vt 0.874845 0.341757 +vt 0.878929 0.322664 +vt 0.894264 0.350808 +vt 0.86172 0.354306 +vt 0.890121 0.302638 +vt 0.900633 0.325513 +vt 0.932192 0.315548 +vt 0.730562 0.326947 +vt 0.713106 0.328223 +vt 0.72296 0.350316 +vt 0.678736 0.328632 +vt 0.716325 0.307131 +vt 0.856285 0.324517 +vt 0.84324 0.311687 +vt 0.81933 0.31943 +vt 0.799782 0.304286 +vt 0.806322 0.271776 +vt 0.825244 0.294637 +vt 0.850879 0.287575 +vt 0.86722 0.30781 +vt 0.740091 0.316932 +vt 0.756566 0.302501 +vt 0.702583 0.267919 +vt 0.73303 0.286789 +vt 0.75555 0.26631 +vt 0.779434 0.286256 +vt 0.776741 0.316735 +vt 0.894098 0.262064 +vt 0.892695 0.238422 +vt 0.863735 0.245736 +vt 0.882937 0.208649 +vt 0.924796 0.246563 +vt 0.814013 0.231601 +vt 0.847948 0.218052 +vt 0.823544 0.187373 +vt 0.704382 0.227027 +vt 0.718515 0.201921 +vt 0.673705 0.195595 +vt 0.748091 0.173595 +vt 0.753811 0.220319 +vt 0.785435 0.201844 +vt 0.834654 0.259639 +vt 0.728096 0.244245 +vt 0.910872 0.281409 +vt 0.782742 0.246644 +vt 0.87545 0.274707 +vt 0.948004 0.28051 +vt 0.956452 0.255796 +vt 0.972736 0.303635 +vt 0.370772 0.156168 +vt 0.404072 0.188535 +vt 0.432688 0.16816 +vt 0.449944 0.216643 +vt 0.366322 0.212187 +vt 0.343097 0.19204 +vt 0.319164 0.211948 +vt 0.318073 0.183115 +vt 0.332918 0.229442 +vt 0.33175 0.259955 +vt 0.309225 0.234833 +vt 0.632664 0.937599 +vt 0.629313 0.958275 +vt 0.659071 0.956775 +vt 0.627927 0.972073 +vt 0.601457 0.954923 +vt 0.374133 0.932158 +vt 0.374091 0.913509 +vt 0.349193 0.91288 +vt 0.374675 0.900396 +vt 0.400674 0.918841 +vt 0.275352 0.917971 +vt 0.344112 0.934726 +vt 0.371547 0.982105 +vt 0.480772 0.938676 +vt 0.406833 0.906276 +vt 0.38004 0.872706 +vt 0.345731 0.899719 +vt 0.405214 0.941284 +vt 0.515015 0.935699 +vt 0.599629 0.929832 +vt 0.643425 0.882887 +vt 0.750826 0.949367 +vt 0.668941 0.932959 +vt 0.627764 0.99827 +vt 0.594501 0.967304 +vt 0.663814 0.97043 +vt 0.389421 0.243699 +vt 0.436255 0.240856 +vt 0.360739 0.292908 +vt 0.479266 0.621214 +vt 0.485524 0.569542 +vt 0.463254 0.566666 +vt 0.48531 0.54359 +vt 0.519446 0.53819 +vt 0.495549 0.530351 +vt 0.47602 0.523291 +vt 0.496385 0.522841 +vt 0.465093 0.54022 +vt 0.446797 0.527765 +vt 0.944666 0.201943 +vt 0.914837 0.204675 +vt 0.904503 0.165124 +vt 0.839442 0.136903 +vt 0.788702 0.151899 +vt 0.742974 0.111175 +vt 0.700099 0.152559 +vt 0.637093 0.13245 +vt 0.850315 0.368043 +vt 0.851223 0.360798 +vt 0.852982 0.368837 +vt 0.723976 0.366596 +vt 0.734474 0.357174 +vt 0.742904 0.359347 +vt 0.863449 0.174562 +vt 0.963467 0.230405 +vt 0.947856 0.233441 +vt 0.322881 0.76555 +vt 0.409494 0.732152 +vt 0.345432 0.815455 +vt 0.298143 0.294421 +vt 0.321942 0.31772 +vt 0.295585 0.24761 +vt 0.660357 0.382546 +vt 0.69659 0.356392 +vt 0.876132 0.364721 +vt 0.893585 0.379 +vt 0.921054 0.3528 +vt 0.961877 0.356785 +vt 0.962698 0.33339 +vt 0.981984 0.355755 +vt 0.306768 0.162912 +vt 0.295194 0.194359 +vt 0.29317 0.223456 +vt 0.347888 0.653078 +vt 0.366581 0.55562 +vt 0.424133 0.681659 +vt 0.340033 0.290817 +vt 0.388965 0.413938 +vt 0.377097 0.422446 +vt 0.385455 0.431061 +vt 0.370091 0.429971 +vt 0.366833 0.415002 +vt 0.432694 0.382302 +vt 0.370508 0.391231 +vt 0.427991 0.40079 +vt 0.346746 0.40443 +vt 0.280737 0.3905 +vt 0.456111 0.433947 +vt 0.589083 0.427663 +vt 0.401629 0.461384 +vt 0.402075 0.444828 +vt 0.332854 0.421481 +vt 0.360577 0.439441 +vt 0.355077 0.451593 +vt 0.380059 0.45258 +vt 0.470234 0.396534 +vt 0.437143 0.383 +vt 0.468433 0.48133 +vt 0.462264 0.506664 +vt 0.433175 0.490402 +vt 0.401796 0.544866 +vt 0.440576 0.55139 +vt 0.313296 0.501179 +vt 0.321314 0.528529 +vt 0.38473 0.481358 +vt 0.295899 0.353213 +vt 0.32351 0.348357 +vt 0.294922 0.38013 +vt 0.289767 0.484501 +vt 0.305757 0.461026 +vt 0.344952 0.331857 +vt 0.372123 0.361433 +vt 0.379071 0.404986 +vt 0.356951 0.422334 +vt 0.378668 0.44021 +vt 0.40174 0.423148 +vt 0.776574 0.349534 +vt 0.721657 0.410555 +vt 0.77532 0.411729 +vt 0.694232 0.4441 +vt 0.649571 0.457689 +vt 0.655529 0.474973 +vt 0.903209 0.465704 +vt 0.85855 0.440351 +vt 0.896562 0.42714 +vt 0.829462 0.404087 +vt 0.725094 0.457517 +vt 0.824792 0.456782 +vt 0.644474 0.268488 +vt 0.619495 0.269287 +vt 0.604207 0.292645 +vt 0.603235 0.247789 +vt 0.669742 0.291872 +vt 0.665491 0.242026 +vt 0.542812 0.189584 +vt 0.615129 0.192251 +vt 0.625589 0.340224 +vt 0.556065 0.36469 +vt 0.56464 0.275636 +vt 0.534275 0.296732 +vt 0.525704 0.266294 +vt 0.528338 0.24086 +vt 0.440532 0.261649 +vt 0.542934 0.319725 +vt 0.476605 0.325877 +vt 0.495044 0.287182 +usemtl material_1 +f 739/1 735/2 736/3 +f 189/4 736/3 735/2 +f 192/5 738/6 737/7 +f 739/1 737/7 738/6 +f 190/8 741/9 740/10 +f 743/11 740/10 741/9 +f 736/3 189/4 743/11 +f 742/12 743/11 189/4 +f 745/13 747/14 191/15 +f 744/16 191/15 747/14 +f 746/17 747/14 190/8 +f 741/9 190/8 747/14 +f 748/18 192/5 750/19 +f 737/7 750/19 192/5 +f 191/15 749/20 745/13 +f 750/19 745/13 749/20 +f 752/21 754/22 194/23 +f 751/24 194/23 754/22 +f 753/25 189/4 754/22 +f 735/2 754/22 189/4 +f 195/26 756/27 755/28 +f 758/29 755/28 756/27 +f 194/23 757/30 752/21 +f 758/29 752/21 757/30 +f 759/31 196/32 762/33 +f 760/34 762/33 196/32 +f 761/35 762/33 195/26 +f 756/27 195/26 762/33 +f 764/36 742/12 753/25 +f 189/4 753/25 742/12 +f 196/32 763/37 760/34 +f 764/36 760/34 763/37 +f 769/38 765/39 766/40 +f 198/41 766/40 765/39 +f 768/42 769/38 201/43 +f 767/44 201/43 769/38 +f 771/45 773/46 199/47 +f 770/48 199/47 773/46 +f 772/49 773/46 198/41 +f 766/40 198/41 773/46 +f 200/50 775/51 774/52 +f 777/53 774/52 775/51 +f 199/47 776/54 771/45 +f 777/53 771/45 776/54 +f 201/43 767/44 778/55 +f 780/56 778/55 767/44 +f 779/57 780/56 200/50 +f 775/51 200/50 780/56 +f 782/58 785/59 203/60 +f 781/61 203/60 785/59 +f 784/62 785/59 205/63 +f 783/64 205/63 785/59 +f 200/50 786/65 779/57 +f 788/66 779/57 786/65 +f 203/60 787/67 782/58 +f 788/66 782/58 787/67 +f 790/68 791/69 204/70 +f 789/71 204/70 791/69 +f 774/52 791/69 200/50 +f 786/65 200/50 791/69 +f 205/63 783/64 792/72 +f 794/73 792/72 783/64 +f 204/70 793/74 790/68 +f 794/73 790/68 793/74 +f 796/75 799/76 207/77 +f 795/78 207/77 799/76 +f 210/79 798/80 797/81 +f 799/76 797/81 798/80 +f 208/82 801/83 800/84 +f 803/85 800/84 801/83 +f 207/77 802/86 796/75 +f 803/85 796/75 802/86 +f 209/87 805/88 804/89 +f 807/90 804/89 805/88 +f 806/91 807/90 208/82 +f 801/83 208/82 807/90 +f 797/81 810/92 210/79 +f 808/93 210/79 810/92 +f 809/94 810/92 209/87 +f 805/88 209/87 810/92 +f 201/43 811/95 768/42 +f 814/96 768/42 811/95 +f 214/97 813/98 812/99 +f 814/96 812/99 813/98 +f 816/100 817/101 212/102 +f 815/103 212/102 817/101 +f 778/55 817/101 201/43 +f 811/95 201/43 817/101 +f 213/104 819/105 818/106 +f 821/107 818/106 819/105 +f 212/102 820/108 816/100 +f 821/107 816/100 820/108 +f 812/99 824/109 214/97 +f 822/110 214/97 824/109 +f 823/111 824/109 213/104 +f 819/105 213/104 824/109 +f 825/112 828/113 192/5 +f 738/6 192/5 828/113 +f 827/114 828/113 217/115 +f 826/116 217/115 828/113 +f 213/104 829/117 823/111 +f 830/118 823/111 829/117 +f 830/118 825/112 748/18 +f 192/5 748/18 825/112 +f 832/119 833/120 216/121 +f 831/122 216/121 833/120 +f 818/106 833/120 213/104 +f 829/117 213/104 833/120 +f 217/115 826/116 834/123 +f 836/124 834/123 826/116 +f 216/121 835/125 832/119 +f 836/124 832/119 835/125 +f 219/126 838/127 837/128 +f 841/129 837/128 838/127 +f 839/130 221/131 841/129 +f 840/132 841/129 221/131 +f 842/133 844/134 216/121 +f 835/125 216/121 844/134 +f 843/135 844/134 219/126 +f 838/127 219/126 844/134 +f 847/136 845/137 846/138 +f 220/139 846/138 845/137 +f 216/121 831/122 842/133 +f 847/136 842/133 831/122 +f 850/140 848/141 839/130 +f 221/131 839/130 848/141 +f 846/138 220/139 850/140 +f 849/142 850/140 220/139 +f 223/143 852/144 851/145 +f 854/146 851/145 852/144 +f 203/60 781/61 853/147 +f 854/146 853/147 781/61 +f 220/139 855/148 849/142 +f 857/149 849/142 855/148 +f 852/144 223/143 857/149 +f 856/150 857/149 223/143 +f 820/108 212/102 859/151 +f 858/152 859/151 212/102 +f 845/137 859/151 220/139 +f 855/148 220/139 859/151 +f 787/67 203/60 860/153 +f 853/147 860/153 203/60 +f 212/102 815/103 858/152 +f 860/153 858/152 815/103 +f 225/154 862/155 861/156 +f 864/157 861/156 862/155 +f 207/77 795/78 863/158 +f 864/157 863/158 795/78 +f 866/159 868/160 226/161 +f 865/162 226/161 868/160 +f 867/163 868/160 225/154 +f 862/155 225/154 868/160 +f 227/164 870/165 869/166 +f 872/167 869/166 870/165 +f 226/161 871/168 866/159 +f 872/167 866/159 871/168 +f 863/158 874/169 207/77 +f 802/86 207/77 874/169 +f 873/170 874/169 227/164 +f 870/165 227/164 874/169 +f 876/171 879/172 229/173 +f 875/174 229/173 879/172 +f 877/175 231/176 879/172 +f 878/177 879/172 231/176 +f 227/164 880/178 873/170 +f 882/179 873/170 880/178 +f 229/173 881/180 876/171 +f 882/179 876/171 881/180 +f 884/181 885/182 230/183 +f 883/184 230/183 885/182 +f 869/166 885/182 227/164 +f 880/178 227/164 885/182 +f 888/185 886/186 877/175 +f 231/176 877/175 886/186 +f 230/183 887/187 884/181 +f 888/185 884/181 887/187 +f 892/188 889/189 890/190 +f 233/191 890/190 889/189 +f 892/188 891/192 837/128 +f 219/126 837/128 891/192 +f 893/193 895/194 230/183 +f 887/187 230/183 895/194 +f 894/195 895/194 233/191 +f 890/190 233/191 895/194 +f 234/196 897/197 896/198 +f 898/199 896/198 897/197 +f 230/183 883/184 893/193 +f 898/199 893/193 883/184 +f 900/200 843/135 891/192 +f 219/126 891/192 843/135 +f 899/201 900/200 234/196 +f 897/197 234/196 900/200 +f 217/115 901/202 827/114 +f 903/203 827/114 901/202 +f 194/23 751/24 902/204 +f 903/203 902/204 751/24 +f 234/196 904/205 899/201 +f 905/206 899/201 904/205 +f 834/123 905/206 217/115 +f 901/202 217/115 905/206 +f 906/207 907/208 226/161 +f 871/168 226/161 907/208 +f 896/198 907/208 234/196 +f 904/205 234/196 907/208 +f 908/209 757/30 902/204 +f 194/23 902/204 757/30 +f 226/161 865/162 906/207 +f 908/209 906/207 865/162 +f 910/210 913/211 237/212 +f 909/213 237/212 913/211 +f 912/214 913/211 240/215 +f 911/216 240/215 913/211 +f 238/217 915/218 914/219 +f 917/220 914/219 915/218 +f 917/220 910/210 916/221 +f 237/212 916/221 910/210 +f 918/222 239/223 921/224 +f 919/225 921/224 239/223 +f 920/226 921/224 238/217 +f 915/218 238/217 921/224 +f 240/215 911/216 922/227 +f 924/228 922/227 911/216 +f 239/223 923/229 919/225 +f 924/228 919/225 923/229 +f 926/230 929/231 242/232 +f 925/233 242/232 929/231 +f 929/231 927/234 928/235 +f 244/236 928/235 927/234 +f 239/223 930/237 923/229 +f 932/238 923/229 930/237 +f 242/232 931/239 926/230 +f 932/238 926/230 931/239 +f 934/240 935/241 243/242 +f 933/243 243/242 935/241 +f 918/222 935/241 239/223 +f 930/237 239/223 935/241 +f 938/244 936/245 927/234 +f 244/236 927/234 936/245 +f 243/242 937/246 934/240 +f 938/244 934/240 937/246 +f 246/247 940/248 939/249 +f 943/250 939/249 940/248 +f 249/251 942/252 941/253 +f 943/250 941/253 942/252 +f 945/254 947/255 247/256 +f 944/257 247/256 947/255 +f 946/258 947/255 246/247 +f 940/248 246/247 947/255 +f 951/259 948/260 949/261 +f 248/262 949/261 948/260 +f 247/256 950/263 945/254 +f 951/259 945/254 950/263 +f 952/264 249/251 954/265 +f 941/253 954/265 249/251 +f 953/266 954/265 248/262 +f 949/261 248/262 954/265 +f 955/267 958/268 244/236 +f 928/235 244/236 958/268 +f 957/269 958/268 252/270 +f 956/271 252/270 958/268 +f 251/272 960/273 959/274 +f 961/275 959/274 960/273 +f 244/236 936/245 955/267 +f 961/275 955/267 936/245 +f 962/276 964/277 247/256 +f 950/263 247/256 964/277 +f 963/278 964/277 251/272 +f 960/273 251/272 964/277 +f 252/270 956/271 965/279 +f 966/280 965/279 956/271 +f 247/256 944/257 962/276 +f 966/280 962/276 944/257 +f 221/131 967/281 840/132 +f 970/282 840/132 967/281 +f 255/283 969/284 968/285 +f 970/282 968/285 969/284 +f 972/286 973/287 254/288 +f 971/289 254/288 973/287 +f 848/141 973/287 221/131 +f 967/281 221/131 973/287 +f 976/290 931/239 974/291 +f 242/232 974/291 931/239 +f 254/288 975/292 972/286 +f 976/290 972/286 975/292 +f 968/285 978/293 255/283 +f 977/294 255/283 978/293 +f 974/291 242/232 978/293 +f 925/233 978/293 242/232 +f 980/295 982/296 257/297 +f 979/298 257/297 982/296 +f 886/186 982/296 231/176 +f 981/299 231/176 982/296 +f 985/300 946/258 983/301 +f 246/247 983/301 946/258 +f 257/297 984/302 980/295 +f 985/300 980/295 984/302 +f 258/303 987/304 986/305 +f 988/306 986/305 987/304 +f 246/247 939/249 983/301 +f 988/306 983/301 939/249 +f 231/176 981/299 878/177 +f 990/307 878/177 981/299 +f 990/307 987/304 989/308 +f 258/303 989/308 987/304 +f 991/309 260/310 994/311 +f 992/312 994/311 260/310 +f 792/72 994/311 205/63 +f 993/313 205/63 994/311 +f 916/221 237/212 997/314 +f 995/315 997/314 237/212 +f 260/310 996/316 992/312 +f 997/314 992/312 996/316 +f 999/317 1000/318 261/319 +f 998/320 261/319 1000/318 +f 237/212 909/213 995/315 +f 1000/318 995/315 909/213 +f 205/63 993/313 784/62 +f 1002/321 784/62 993/313 +f 1002/321 999/317 1001/322 +f 261/319 1001/322 999/317 +f 1003/323 1005/324 257/297 +f 984/302 257/297 1005/324 +f 965/279 1005/324 252/270 +f 1004/325 252/270 1005/324 +f 233/191 1006/326 894/195 +f 1007/327 894/195 1006/326 +f 257/297 979/298 1003/323 +f 1007/327 1003/323 979/298 +f 1008/328 1009/329 255/283 +f 969/284 255/283 1009/329 +f 889/189 1009/329 233/191 +f 1006/326 233/191 1009/329 +f 252/270 1004/325 957/269 +f 1010/330 957/269 1004/325 +f 255/283 977/294 1008/328 +f 1010/330 1008/328 977/294 +f 223/143 1011/331 856/150 +f 1013/332 856/150 1011/331 +f 254/288 971/289 1012/333 +f 1013/332 1012/333 971/289 +f 1014/334 1015/335 261/319 +f 1001/322 261/319 1015/335 +f 851/145 1015/335 223/143 +f 1011/331 223/143 1015/335 +f 240/215 1016/336 912/214 +f 1017/337 912/214 1016/336 +f 261/319 998/320 1014/334 +f 1017/337 1014/334 998/320 +f 1012/333 1018/338 254/288 +f 975/292 254/288 1018/338 +f 922/227 1018/338 240/215 +f 1016/336 240/215 1018/338 +f 1019/339 265/340 1022/341 +f 1020/342 1022/341 265/340 +f 1022/341 1021/343 991/309 +f 260/310 991/309 1021/343 +f 1023/344 266/345 1026/346 +f 1024/347 1026/346 266/345 +f 1025/348 1026/346 265/340 +f 1020/342 265/340 1026/346 +f 1030/349 1027/350 1028/351 +f 267/352 1028/351 1027/350 +f 266/345 1029/353 1024/347 +f 1030/349 1024/347 1029/353 +f 1021/343 1032/354 260/310 +f 996/316 260/310 1032/354 +f 1028/351 267/352 1032/354 +f 1031/355 1032/354 267/352 +f 269/356 1034/357 1033/358 +f 1036/359 1033/358 1034/357 +f 1036/359 1035/360 1023/361 +f 266/362 1023/361 1035/360 +f 1038/363 1040/364 270/365 +f 1037/366 270/365 1040/364 +f 1039/367 1040/364 269/356 +f 1034/357 269/356 1040/364 +f 1044/368 1041/369 1042/370 +f 271/371 1042/370 1041/369 +f 270/365 1043/372 1038/363 +f 1044/368 1038/363 1043/372 +f 1035/360 1046/373 266/362 +f 1029/374 266/362 1046/373 +f 1042/370 271/371 1046/373 +f 1045/375 1046/373 271/371 +f 1048/376 1050/377 273/378 +f 1047/379 273/378 1050/377 +f 1033/358 1050/377 269/356 +f 1049/380 269/356 1050/377 +f 274/381 1052/382 1051/383 +f 1054/384 1051/383 1052/382 +f 273/378 1053/385 1048/376 +f 1054/384 1048/376 1053/385 +f 1056/386 1058/387 275/388 +f 1055/389 275/388 1058/387 +f 1057/390 1058/387 274/381 +f 1052/382 274/381 1058/387 +f 269/356 1049/380 1039/367 +f 1060/391 1039/367 1049/380 +f 275/388 1059/392 1056/386 +f 1060/391 1056/386 1059/392 +f 1061/393 1064/394 275/388 +f 1059/392 275/388 1064/394 +f 1063/395 1064/394 279/396 +f 1062/397 279/396 1064/394 +f 277/398 1066/399 1065/400 +f 1067/401 1065/400 1066/399 +f 275/388 1055/389 1061/393 +f 1067/401 1061/393 1055/389 +f 278/402 1069/403 1068/404 +f 1071/405 1068/404 1069/403 +f 1070/406 1071/405 277/398 +f 1066/399 277/398 1071/405 +f 279/396 1062/397 1072/407 +f 1074/408 1072/407 1062/397 +f 1073/409 1074/408 278/402 +f 1069/403 278/402 1074/408 +f 1076/410 1079/411 281/412 +f 1075/413 281/412 1079/411 +f 1077/414 284/415 1079/411 +f 1078/416 1079/411 284/415 +f 1081/417 1083/418 282/419 +f 1080/420 282/419 1083/418 +f 281/412 1082/421 1076/410 +f 1083/418 1076/410 1082/421 +f 283/422 1085/423 1084/424 +f 1087/425 1084/424 1085/423 +f 282/419 1086/426 1081/417 +f 1087/425 1081/417 1086/426 +f 284/415 1077/414 1088/427 +f 1090/428 1088/427 1077/414 +f 1090/428 1085/423 1089/429 +f 283/422 1089/429 1085/423 +f 1092/430 1095/431 286/432 +f 1091/433 286/432 1095/431 +f 1095/431 1093/434 1094/435 +f 289/436 1094/435 1093/434 +f 1097/437 1099/438 287/439 +f 1096/440 287/439 1099/438 +f 286/432 1098/441 1092/430 +f 1099/438 1092/430 1098/441 +f 288/442 1101/443 1100/444 +f 1103/445 1100/444 1101/443 +f 287/439 1102/446 1097/437 +f 1103/445 1097/437 1102/446 +f 289/436 1093/434 1104/447 +f 1106/448 1104/447 1093/434 +f 1101/443 288/442 1106/448 +f 1105/449 1106/448 288/442 +f 225/450 1107/451 867/452 +f 1110/453 867/452 1107/451 +f 292/454 1109/455 1108/456 +f 1110/453 1108/456 1109/455 +f 1112/457 1113/458 291/459 +f 1111/460 291/459 1113/458 +f 861/461 1113/458 225/450 +f 1107/451 225/450 1113/458 +f 289/436 1114/462 1094/435 +f 1116/463 1094/435 1114/462 +f 291/459 1115/464 1112/457 +f 1116/463 1112/457 1115/464 +f 1108/456 1118/465 292/454 +f 1117/466 292/454 1118/465 +f 289/436 1104/447 1114/462 +f 1118/465 1114/462 1104/447 +f 1120/467 1123/468 294/469 +f 1119/470 294/469 1123/468 +f 1122/471 1123/468 296/472 +f 1121/473 296/472 1123/468 +f 1127/474 1124/475 1125/476 +f 295/477 1125/476 1124/475 +f 294/469 1126/478 1120/467 +f 1127/474 1120/467 1126/478 +f 1128/479 1130/480 287/439 +f 1102/446 287/439 1130/480 +f 295/477 1129/481 1125/476 +f 1130/480 1125/476 1129/481 +f 296/472 1121/473 1131/482 +f 1132/483 1131/482 1121/473 +f 287/439 1096/440 1128/479 +f 1132/483 1128/479 1096/440 +f 1133/484 1135/485 292/454 +f 1109/455 292/454 1135/485 +f 755/486 1135/485 195/487 +f 1134/488 195/487 1135/485 +f 288/442 1136/489 1105/449 +f 1137/490 1105/449 1136/489 +f 292/454 1117/466 1133/484 +f 1137/490 1133/484 1117/466 +f 295/477 1138/491 1129/481 +f 1139/492 1129/481 1138/491 +f 1136/489 288/442 1139/492 +f 1100/444 1139/492 288/442 +f 195/487 1134/488 761/493 +f 1140/494 761/493 1134/488 +f 295/477 1124/475 1138/491 +f 1140/494 1138/491 1124/475 +f 1143/495 1122/471 1141/496 +f 296/472 1141/496 1122/471 +f 1143/495 1142/497 808/498 +f 210/499 808/498 1142/497 +f 1144/500 1145/501 286/432 +f 1098/441 286/432 1145/501 +f 1141/496 296/472 1145/501 +f 1131/482 1145/501 296/472 +f 291/459 1146/502 1115/464 +f 1147/503 1115/464 1146/502 +f 286/432 1091/433 1144/500 +f 1147/503 1144/500 1091/433 +f 1142/497 1148/504 210/499 +f 798/505 210/499 1148/504 +f 1146/502 291/459 1148/504 +f 1111/460 1148/504 291/459 +f 300/506 1150/507 1149/508 +f 1152/509 1149/508 1150/507 +f 214/510 822/511 1151/512 +f 1152/509 1151/512 822/511 +f 1153/513 1155/514 281/412 +f 1082/421 281/412 1155/514 +f 1150/507 300/506 1155/514 +f 1154/515 1155/514 300/506 +f 301/516 1157/517 1156/518 +f 1158/519 1156/518 1157/517 +f 281/412 1075/413 1153/513 +f 1158/519 1153/513 1075/413 +f 1151/512 1160/520 214/510 +f 813/521 214/510 1160/520 +f 1157/517 301/516 1160/520 +f 1159/522 1160/520 301/516 +f 198/523 1161/524 772/525 +f 1164/526 772/525 1161/524 +f 1164/526 1162/527 1163/528 +f 303/529 1163/528 1162/527 +f 1165/530 1166/531 301/516 +f 1159/522 301/516 1166/531 +f 765/532 1166/531 198/523 +f 1161/524 198/523 1166/531 +f 284/415 1167/533 1078/416 +f 1168/534 1078/416 1167/533 +f 301/516 1156/518 1165/530 +f 1168/534 1165/530 1156/518 +f 1162/527 1170/535 303/529 +f 1169/536 303/529 1170/535 +f 1167/533 284/415 1170/535 +f 1088/427 1170/535 284/415 +f 305/537 1172/538 1171/539 +f 1174/540 1171/539 1172/538 +f 191/541 744/542 1173/543 +f 1174/540 1173/543 744/542 +f 1175/544 1177/545 282/419 +f 1086/426 282/419 1177/545 +f 1176/546 1177/545 305/537 +f 1172/538 305/537 1177/545 +f 300/506 1178/547 1154/515 +f 1179/548 1154/515 1178/547 +f 282/419 1080/420 1175/544 +f 1179/548 1175/544 1080/420 +f 1173/543 1180/549 191/541 +f 749/550 191/541 1180/549 +f 1149/508 1180/549 300/506 +f 1178/547 300/506 1180/549 +f 1181/551 1184/552 303/529 +f 1163/528 303/529 1184/552 +f 1183/553 1184/552 307/554 +f 1182/555 307/554 1184/552 +f 283/422 1185/556 1089/429 +f 1186/557 1089/429 1185/556 +f 303/529 1169/536 1181/551 +f 1186/557 1181/551 1169/536 +f 305/537 1187/558 1176/546 +f 1188/559 1176/546 1187/558 +f 283/422 1084/424 1185/556 +f 1188/559 1185/556 1084/424 +f 307/554 1182/555 1189/560 +f 1190/561 1189/560 1182/555 +f 1171/539 1190/561 305/537 +f 1187/558 305/537 1190/561 +f 1192/562 1194/563 309/564 +f 1191/565 309/564 1194/563 +f 1072/407 1194/563 279/396 +f 1193/566 279/396 1194/563 +f 1195/567 310/568 1198/569 +f 1196/570 1198/569 310/568 +f 1192/562 309/564 1198/569 +f 1197/571 1198/569 309/564 +f 1202/572 1199/573 1200/574 +f 311/575 1200/574 1199/573 +f 310/568 1201/576 1196/570 +f 1202/572 1196/570 1201/576 +f 1203/577 1205/578 270/365 +f 1043/372 270/365 1205/578 +f 1200/574 311/575 1205/578 +f 1204/579 1205/578 311/575 +f 279/396 1193/566 1063/395 +f 1206/580 1063/395 1193/566 +f 270/365 1037/366 1203/577 +f 1206/580 1203/577 1037/366 +f 1208/581 1211/582 313/583 +f 1207/584 313/583 1211/582 +f 1210/585 1211/582 316/586 +f 1209/587 316/586 1211/582 +f 314/588 1213/589 1212/590 +f 1215/591 1212/590 1213/589 +f 313/583 1214/592 1208/581 +f 1215/591 1208/581 1214/592 +f 315/593 1217/594 1216/595 +f 1219/596 1216/595 1217/594 +f 1219/596 1213/589 1218/597 +f 314/588 1218/597 1213/589 +f 1209/587 1222/598 316/586 +f 1220/599 316/586 1222/598 +f 1221/600 1222/598 315/593 +f 1217/594 315/593 1222/598 +f 1223/601 1225/602 310/603 +f 1201/604 310/603 1225/602 +f 1212/590 1225/602 314/588 +f 1224/605 314/588 1225/602 +f 318/606 1227/607 1226/608 +f 1228/609 1226/608 1227/607 +f 1228/609 1223/601 1195/610 +f 310/603 1195/610 1223/601 +f 1230/611 1232/612 319/613 +f 1229/614 319/613 1232/612 +f 1231/615 1232/612 318/606 +f 1227/607 318/606 1232/612 +f 314/588 1224/605 1218/597 +f 1234/616 1218/597 1224/605 +f 319/613 1233/617 1230/611 +f 1234/616 1230/611 1233/617 +f 1236/618 1238/619 321/620 +f 1235/621 321/620 1238/619 +f 1237/622 319/613 1238/619 +f 1229/614 1238/619 319/613 +f 322/623 1240/624 1239/625 +f 1242/626 1239/625 1240/624 +f 321/620 1241/627 1236/618 +f 1242/626 1236/618 1241/627 +f 315/593 1243/628 1221/600 +f 1245/629 1221/600 1243/628 +f 1240/624 322/623 1245/629 +f 1244/630 1245/629 322/623 +f 319/613 1237/622 1233/617 +f 1246/631 1233/617 1237/622 +f 1246/631 1243/628 1216/595 +f 315/593 1216/595 1243/628 +f 324/632 1248/633 1247/634 +f 1251/635 1247/634 1248/633 +f 326/636 1250/637 1249/638 +f 1251/635 1249/638 1250/637 +f 1253/639 1255/640 325/641 +f 1252/642 325/641 1255/640 +f 1254/643 1255/640 324/632 +f 1248/633 324/632 1255/640 +f 238/217 1256/644 920/226 +f 1258/645 920/226 1256/644 +f 325/641 1257/646 1253/639 +f 1258/645 1253/639 1257/646 +f 1249/638 1260/647 326/636 +f 1259/648 326/636 1260/647 +f 914/219 1260/647 238/217 +f 1256/644 238/217 1260/647 +f 1265/649 1261/650 1262/651 +f 328/652 1262/651 1261/650 +f 330/653 1264/654 1263/655 +f 1265/649 1263/655 1264/654 +f 1267/656 1269/657 329/658 +f 1266/659 329/658 1269/657 +f 1262/651 328/652 1269/657 +f 1268/660 1269/657 328/652 +f 251/272 1270/661 963/278 +f 1272/662 963/278 1270/661 +f 1272/662 1267/656 1271/663 +f 329/658 1271/663 1267/656 +f 1263/655 1274/664 330/653 +f 1273/665 330/653 1274/664 +f 959/274 1274/664 251/272 +f 1270/661 251/272 1274/664 +f 1278/666 1275/667 1276/668 +f 332/669 1276/668 1275/667 +f 329/658 1266/659 1277/670 +f 1278/666 1277/670 1266/659 +f 1280/671 1282/672 333/673 +f 1279/674 333/673 1282/672 +f 1276/668 332/669 1282/672 +f 1281/675 1282/672 332/669 +f 1285/676 953/266 1283/677 +f 248/262 1283/677 953/266 +f 333/673 1284/678 1280/671 +f 1285/676 1280/671 1284/678 +f 1271/663 329/658 1286/679 +f 1277/670 1286/679 329/658 +f 948/260 1286/679 248/262 +f 1283/677 248/262 1286/679 +f 335/680 1288/681 1287/682 +f 1291/683 1287/682 1288/681 +f 337/684 1290/685 1289/686 +f 1291/683 1289/686 1290/685 +f 1293/687 1295/688 336/689 +f 1292/690 336/689 1295/688 +f 1288/681 335/680 1295/688 +f 1294/691 1295/688 335/680 +f 1298/692 1183/693 1296/694 +f 307/695 1296/694 1183/693 +f 1298/692 1293/687 1297/696 +f 336/689 1297/696 1293/687 +f 1289/686 1300/697 337/684 +f 1299/698 337/684 1300/697 +f 1296/694 307/695 1300/697 +f 1189/699 1300/697 307/695 +f 1302/700 1305/701 339/702 +f 1301/703 339/702 1305/701 +f 1304/704 1305/701 341/705 +f 1303/706 341/705 1305/701 +f 340/707 1307/708 1306/709 +f 1309/710 1306/709 1307/708 +f 1309/710 1302/700 1308/711 +f 339/702 1308/711 1302/700 +f 1310/712 1312/713 294/714 +f 1126/715 294/714 1312/713 +f 1307/708 340/707 1312/713 +f 1311/716 1312/713 340/707 +f 341/705 1303/706 1313/717 +f 1314/718 1313/717 1303/706 +f 294/714 1119/719 1310/712 +f 1314/718 1310/712 1119/719 +f 1318/720 1315/721 1316/722 +f 343/723 1316/722 1315/721 +f 325/641 1252/642 1317/724 +f 1318/720 1317/724 1252/642 +f 1319/725 1321/726 330/653 +f 1264/654 330/653 1321/726 +f 1316/722 343/723 1321/726 +f 1320/727 1321/726 343/723 +f 243/242 1322/728 937/246 +f 1323/729 937/246 1322/728 +f 1323/729 1319/725 1273/665 +f 330/653 1273/665 1319/725 +f 1317/724 1324/730 325/641 +f 1257/646 325/641 1324/730 +f 933/243 1324/730 243/242 +f 1322/728 243/242 1324/730 +f 345/731 1326/732 1325/733 +f 1329/734 1325/733 1326/732 +f 346/735 1328/736 1327/737 +f 1329/734 1327/737 1328/736 +f 1330/738 1332/739 326/636 +f 1250/637 326/636 1332/739 +f 1331/740 1332/739 345/731 +f 1326/732 345/731 1332/739 +f 267/352 1333/741 1031/355 +f 1334/742 1031/355 1333/741 +f 326/636 1259/648 1330/738 +f 1334/742 1330/738 1259/648 +f 1335/743 346/735 1336/744 +f 1327/737 1336/744 346/735 +f 1027/350 1336/744 267/352 +f 1333/741 267/352 1336/744 +f 1341/745 1337/746 1338/747 +f 348/748 1338/747 1337/746 +f 349/749 1340/750 1339/751 +f 1341/745 1339/751 1340/750 +f 1342/752 1344/753 346/754 +f 1328/755 346/754 1344/753 +f 1338/747 348/748 1344/753 +f 1343/756 1344/753 348/748 +f 271/757 1345/758 1045/759 +f 1346/760 1045/759 1345/758 +f 1346/760 1342/752 1335/761 +f 346/754 1335/761 1342/752 +f 349/749 1339/751 1347/762 +f 1348/763 1347/762 1339/751 +f 1041/764 1348/763 271/757 +f 1345/758 271/757 1348/763 +f 1353/765 1349/766 1350/767 +f 351/768 1350/767 1349/766 +f 354/769 1352/770 1351/771 +f 1353/765 1351/771 1352/770 +f 1355/772 1357/773 352/774 +f 1354/775 352/774 1357/773 +f 1350/767 351/768 1357/773 +f 1356/776 1357/773 351/768 +f 353/777 1359/778 1358/779 +f 1361/780 1358/779 1359/778 +f 352/774 1360/781 1355/772 +f 1361/780 1355/772 1360/781 +f 1351/771 1364/782 354/769 +f 1362/783 354/769 1364/782 +f 1363/784 1364/782 353/777 +f 1359/778 353/777 1364/782 +f 1365/785 356/786 1369/787 +f 1366/788 1369/787 356/786 +f 1369/787 1367/789 1368/790 +f 357/791 1368/790 1367/789 +f 1370/792 1372/793 354/769 +f 1352/770 354/769 1372/793 +f 356/786 1371/794 1366/788 +f 1372/793 1366/788 1371/794 +f 1374/795 1073/409 1373/796 +f 278/402 1373/796 1073/409 +f 354/769 1362/783 1370/792 +f 1374/795 1370/792 1362/783 +f 1367/789 1376/797 357/791 +f 1375/798 357/791 1376/797 +f 278/402 1068/404 1373/796 +f 1376/797 1373/796 1068/404 +f 1381/799 1377/800 1378/801 +f 359/802 1378/801 1377/800 +f 360/803 1380/804 1379/805 +f 1381/799 1379/805 1380/804 +f 1384/806 1304/704 1382/807 +f 341/705 1382/807 1304/704 +f 1378/801 359/802 1384/806 +f 1383/808 1384/806 359/802 +f 209/87 1385/809 809/94 +f 1386/810 809/94 1385/809 +f 1382/807 341/705 1386/810 +f 1313/717 1386/810 341/705 +f 1379/805 1388/811 360/803 +f 1387/812 360/803 1388/811 +f 804/89 1388/811 209/87 +f 1385/809 209/87 1388/811 +f 1390/813 1392/814 362/815 +f 1389/816 362/815 1392/814 +f 1391/817 336/689 1392/814 +f 1292/690 1392/814 336/689 +f 363/818 1394/819 1393/820 +f 1396/821 1393/820 1394/819 +f 1396/821 1390/813 1395/822 +f 362/815 1395/822 1390/813 +f 1397/823 1399/824 199/47 +f 776/54 199/47 1399/824 +f 1398/825 1399/824 363/818 +f 1394/819 363/818 1399/824 +f 1400/826 1297/696 1391/817 +f 336/689 1391/817 1297/696 +f 199/47 770/48 1397/823 +f 1400/826 1397/823 770/48 +f 1402/827 1404/828 365/829 +f 1401/830 365/829 1404/828 +f 1403/831 363/818 1404/828 +f 1393/820 1404/828 363/818 +f 366/832 1406/833 1405/834 +f 1408/835 1405/834 1406/833 +f 1408/835 1402/827 1407/836 +f 365/829 1407/836 1402/827 +f 1409/837 1411/838 204/70 +f 793/74 204/70 1411/838 +f 1410/839 1411/838 366/832 +f 1406/833 366/832 1411/838 +f 363/818 1403/831 1398/825 +f 1412/840 1398/825 1403/831 +f 204/70 789/71 1409/837 +f 1412/840 1409/837 789/71 +f 1414/841 1416/842 368/843 +f 1413/844 368/843 1416/842 +f 1405/834 1416/842 366/832 +f 1415/845 366/832 1416/842 +f 1418/846 1420/847 369/848 +f 1417/849 369/848 1420/847 +f 1419/850 1420/847 368/843 +f 1414/841 368/843 1420/847 +f 265/340 1421/851 1025/348 +f 1423/852 1025/348 1421/851 +f 1423/852 1418/846 1422/853 +f 369/848 1422/853 1418/846 +f 366/832 1415/845 1410/839 +f 1424/854 1410/839 1415/845 +f 1424/854 1421/851 1019/339 +f 265/340 1019/339 1421/851 +f 371/855 1426/856 1425/857 +f 1428/858 1425/857 1426/856 +f 369/859 1417/860 1427/861 +f 1428/858 1427/861 1417/860 +f 372/862 1430/863 1429/864 +f 1432/865 1429/864 1430/863 +f 1431/866 1432/865 371/855 +f 1426/856 371/855 1432/865 +f 1433/867 1435/868 273/378 +f 1053/385 273/378 1435/868 +f 1434/869 1435/868 372/862 +f 1430/863 372/862 1435/868 +f 1427/861 1436/870 369/859 +f 1422/871 369/859 1436/870 +f 273/378 1047/379 1433/867 +f 1436/870 1433/867 1047/379 +f 1438/872 1440/873 374/874 +f 1437/875 374/874 1440/873 +f 1429/864 1440/873 372/862 +f 1439/876 372/862 1440/873 +f 375/877 1442/878 1441/879 +f 1444/880 1441/879 1442/878 +f 1444/880 1438/872 1443/881 +f 374/874 1443/881 1438/872 +f 1445/882 1447/883 274/381 +f 1057/390 274/381 1447/883 +f 1446/884 1447/883 375/877 +f 1442/878 375/877 1447/883 +f 372/862 1439/876 1434/869 +f 1448/885 1434/869 1439/876 +f 274/381 1051/383 1445/882 +f 1448/885 1445/882 1051/383 +f 1452/886 1449/887 1450/888 +f 377/889 1450/888 1449/887 +f 1451/890 375/877 1452/886 +f 1441/879 1452/886 375/877 +f 1453/891 1455/892 357/791 +f 1368/790 357/791 1455/892 +f 1450/888 377/889 1455/892 +f 1454/893 1455/892 377/889 +f 277/398 1456/894 1070/406 +f 1457/895 1070/406 1456/894 +f 357/791 1375/798 1453/891 +f 1457/895 1453/891 1375/798 +f 1446/884 375/877 1458/896 +f 1451/890 1458/896 375/877 +f 1065/400 1458/896 277/398 +f 1456/894 277/398 1458/896 +f 1462/897 1340/750 1459/898 +f 349/749 1459/898 1340/750 +f 1461/899 1462/897 380/900 +f 1460/901 380/900 1462/897 +f 1464/902 1204/903 1463/904 +f 311/905 1463/904 1204/903 +f 1459/898 349/749 1464/902 +f 1347/762 1464/902 349/749 +f 1465/906 1466/907 313/908 +f 1214/909 313/908 1466/907 +f 1199/910 1466/907 311/905 +f 1463/904 311/905 1466/907 +f 379/911 1468/912 1467/913 +f 1469/914 1467/913 1468/912 +f 313/908 1207/915 1465/906 +f 1469/914 1465/906 1207/915 +f 380/900 1460/901 1470/916 +f 1472/917 1470/916 1460/901 +f 1472/917 1468/912 1471/918 +f 379/911 1471/918 1468/912 +f 1363/784 353/777 1475/919 +f 1473/920 1475/919 353/777 +f 1191/565 1475/919 309/564 +f 1474/921 309/564 1475/919 +f 1477/922 1478/923 382/924 +f 1476/925 382/924 1478/923 +f 1358/779 1478/923 353/777 +f 1473/920 353/777 1478/923 +f 309/564 1474/921 1197/571 +f 1480/926 1197/571 1474/921 +f 382/924 1479/927 1477/922 +f 1480/926 1477/922 1479/927 +f 384/928 1482/929 1481/930 +f 1485/931 1481/930 1482/929 +f 387/932 1484/933 1483/934 +f 1485/931 1483/934 1484/933 +f 1487/935 1489/936 385/937 +f 1486/938 385/937 1489/936 +f 1488/939 1489/936 384/928 +f 1482/929 384/928 1489/936 +f 386/940 1491/941 1490/942 +f 1493/943 1490/942 1491/941 +f 385/937 1492/944 1487/935 +f 1493/943 1487/935 1492/944 +f 1483/934 1496/945 387/932 +f 1494/946 387/932 1496/945 +f 1491/941 386/940 1496/945 +f 1495/947 1496/945 386/940 +f 1501/948 1497/949 1498/950 +f 389/951 1498/950 1497/949 +f 392/952 1500/953 1499/954 +f 1501/948 1499/954 1500/953 +f 1503/955 1505/956 390/957 +f 1502/958 390/957 1505/956 +f 1498/950 389/951 1505/956 +f 1504/959 1505/956 389/951 +f 1507/960 1509/961 391/962 +f 1506/963 391/962 1509/961 +f 1509/961 1503/955 1508/964 +f 390/957 1508/964 1503/955 +f 1499/954 1512/965 392/952 +f 1510/966 392/952 1512/965 +f 391/962 1511/967 1507/960 +f 1512/965 1507/960 1511/967 +f 1513/968 394/969 1517/970 +f 1514/971 1517/970 394/969 +f 1516/972 1517/970 397/973 +f 1515/974 397/973 1517/970 +f 1521/975 1518/976 1519/977 +f 395/978 1519/977 1518/976 +f 1514/971 394/969 1521/975 +f 1520/979 1521/975 394/969 +f 1523/980 1525/981 396/982 +f 1522/983 396/982 1525/981 +f 1519/977 395/978 1525/981 +f 1524/984 1525/981 395/978 +f 397/973 1515/974 1526/985 +f 1528/986 1526/985 1515/974 +f 1528/986 1523/980 1527/987 +f 396/982 1527/987 1523/980 +f 399/988 1530/989 1529/990 +f 1532/991 1529/990 1530/989 +f 1502/958 1532/991 390/957 +f 1531/992 390/957 1532/991 +f 1534/993 1536/994 400/995 +f 1533/996 400/995 1536/994 +f 399/988 1535/997 1530/989 +f 1536/994 1530/989 1535/997 +f 1540/998 1537/999 1538/1000 +f 401/1001 1538/1000 1537/999 +f 400/995 1539/1002 1534/993 +f 1540/998 1534/993 1539/1002 +f 1531/992 1542/1003 390/957 +f 1508/964 390/957 1542/1003 +f 1538/1000 401/1001 1542/1003 +f 1541/1004 1542/1003 401/1001 +f 403/1005 1544/1006 1543/1007 +f 1546/1008 1543/1007 1544/1006 +f 1546/1008 1545/1009 1533/996 +f 400/995 1533/996 1545/1009 +f 395/978 1547/1010 1524/984 +f 1549/1011 1524/984 1547/1010 +f 1549/1011 1544/1006 1548/1012 +f 403/1005 1548/1012 1544/1006 +f 1551/1013 1552/1014 404/1015 +f 1550/1016 404/1015 1552/1014 +f 1518/976 1552/1014 395/978 +f 1547/1010 395/978 1552/1014 +f 1545/1009 1554/1017 400/995 +f 1539/1002 400/995 1554/1017 +f 1554/1017 1551/1013 1553/1018 +f 404/1015 1553/1018 1551/1013 +f 1555/1019 1558/1020 392/952 +f 1500/953 392/952 1558/1020 +f 407/1021 1557/1022 1556/1023 +f 1558/1020 1556/1023 1557/1022 +f 397/973 1559/1024 1516/972 +f 1560/1025 1516/972 1559/1024 +f 392/952 1510/966 1555/1019 +f 1560/1025 1555/1019 1510/966 +f 406/1026 1562/1027 1561/1028 +f 1563/1029 1561/1028 1562/1027 +f 1526/985 1563/1029 397/973 +f 1559/1024 397/973 1563/1029 +f 1556/1023 1566/1030 407/1021 +f 1564/1031 407/1021 1566/1030 +f 1565/1032 1566/1030 406/1026 +f 1562/1027 406/1026 1566/1030 +f 1567/1033 1570/1034 407/1035 +f 1557/1036 407/1035 1570/1034 +f 1568/1037 410/1038 1570/1034 +f 1569/1039 1570/1034 410/1038 +f 409/1040 1572/1041 1571/1042 +f 1573/1043 1571/1042 1572/1041 +f 407/1035 1564/1044 1567/1033 +f 1573/1043 1567/1033 1564/1044 +f 1574/1045 1576/1046 321/620 +f 1241/627 321/620 1576/1046 +f 1575/1047 1576/1046 409/1040 +f 1572/1041 409/1040 1576/1046 +f 318/606 1577/1048 1231/615 +f 1578/1049 1231/615 1577/1048 +f 321/620 1235/621 1574/1045 +f 1578/1049 1574/1045 1235/621 +f 1568/1037 1580/1050 410/1038 +f 1579/1051 410/1038 1580/1050 +f 1226/608 1580/1050 318/606 +f 1577/1048 318/606 1580/1050 +f 1581/1052 412/1053 1584/1054 +f 1582/1055 1584/1054 412/1053 +f 1561/1056 1584/1054 406/1057 +f 1583/1058 406/1057 1584/1054 +f 1587/1059 1210/585 1585/1060 +f 316/586 1585/1060 1210/585 +f 1587/1059 1582/1055 1586/1061 +f 412/1053 1586/1061 1582/1055 +f 322/623 1588/1062 1244/630 +f 1589/1063 1244/630 1588/1062 +f 1589/1063 1585/1060 1220/599 +f 316/586 1220/599 1585/1060 +f 1591/1064 1575/1047 1590/1065 +f 409/1040 1590/1065 1575/1047 +f 322/623 1239/625 1588/1062 +f 1591/1064 1588/1062 1239/625 +f 406/1057 1583/1058 1565/1066 +f 1592/1067 1565/1066 1583/1058 +f 409/1040 1571/1042 1590/1065 +f 1592/1067 1590/1065 1571/1042 +f 414/1068 1594/1069 1593/1070 +f 1596/1071 1593/1070 1594/1069 +f 396/1072 1522/1073 1595/1074 +f 1596/1071 1595/1074 1522/1073 +f 415/1075 1598/1076 1597/1077 +f 1600/1078 1597/1077 1598/1076 +f 1600/1078 1594/1069 1599/1079 +f 414/1068 1599/1079 1594/1069 +f 1601/1080 1603/1081 379/911 +f 1471/918 379/911 1603/1081 +f 1602/1082 1603/1081 415/1075 +f 1598/1076 415/1075 1603/1081 +f 1605/1083 1586/1084 1604/1085 +f 412/1086 1604/1085 1586/1084 +f 379/911 1467/913 1601/1080 +f 1605/1083 1601/1080 1467/913 +f 1527/1087 396/1072 1606/1088 +f 1595/1074 1606/1088 396/1072 +f 1604/1085 412/1086 1606/1088 +f 1581/1089 1606/1088 412/1086 +f 1608/1090 1611/1091 417/1092 +f 1607/1093 417/1092 1611/1091 +f 1609/1094 419/1095 1611/1091 +f 1610/1096 1611/1091 419/1095 +f 1612/1097 1614/1098 399/1099 +f 1535/1100 399/1099 1614/1098 +f 1614/1098 1608/1090 1613/1101 +f 417/1092 1613/1101 1608/1090 +f 418/1102 1616/1103 1615/1104 +f 1617/1105 1615/1104 1616/1103 +f 1612/1097 399/1099 1617/1105 +f 1529/1106 1617/1105 399/1099 +f 1618/1107 1620/1108 352/774 +f 1360/781 352/774 1620/1108 +f 1619/1109 1620/1108 418/1102 +f 1616/1103 418/1102 1620/1108 +f 419/1095 1609/1094 1621/1110 +f 1622/1111 1621/1110 1609/1094 +f 352/774 1354/775 1618/1107 +f 1622/1111 1618/1107 1354/775 +f 414/1068 1623/1112 1599/1079 +f 1626/1113 1599/1079 1623/1112 +f 1625/1114 1626/1113 421/1115 +f 1624/1116 421/1115 1626/1113 +f 1548/1117 403/1118 1628/1119 +f 1627/1120 1628/1119 403/1118 +f 1593/1070 1628/1119 414/1068 +f 1623/1112 414/1068 1628/1119 +f 1629/1121 1630/1122 417/1123 +f 1613/1124 417/1123 1630/1122 +f 1627/1120 403/1118 1630/1122 +f 1543/1125 1630/1122 403/1118 +f 1632/1126 1631/1127 1624/1116 +f 421/1115 1624/1116 1631/1127 +f 417/1123 1607/1128 1629/1121 +f 1632/1126 1629/1121 1607/1128 +f 418/1102 1633/1129 1619/1109 +f 1635/1130 1619/1109 1633/1129 +f 382/924 1476/925 1634/1131 +f 1635/1130 1634/1131 1476/925 +f 389/1132 1636/1133 1504/1134 +f 1637/1135 1504/1134 1636/1133 +f 1615/1104 1637/1135 418/1102 +f 1633/1129 418/1102 1637/1135 +f 1638/1136 1639/1137 410/1138 +f 1569/1139 410/1138 1639/1137 +f 1497/1140 1639/1137 389/1132 +f 1636/1133 389/1132 1639/1137 +f 1634/1131 1640/1141 382/924 +f 1479/927 382/924 1640/1141 +f 1579/1142 1640/1141 410/1138 +f 1638/1136 410/1138 1640/1141 +f 1644/1143 1641/1144 1642/1145 +f 424/1146 1642/1145 1641/1144 +f 391/962 1506/963 1643/1147 +f 1644/1143 1643/1147 1506/963 +f 384/928 1645/1148 1488/939 +f 1647/1149 1488/939 1645/1148 +f 424/1146 1646/1150 1642/1145 +f 1647/1149 1642/1145 1646/1150 +f 425/1151 1649/1152 1648/1153 +f 1650/1154 1648/1153 1649/1152 +f 384/928 1481/930 1645/1148 +f 1650/1154 1645/1148 1481/930 +f 1643/1147 1652/1155 391/962 +f 1511/967 391/962 1652/1155 +f 1651/1156 1652/1155 425/1151 +f 1649/1152 425/1151 1652/1155 +f 1653/1157 427/1158 1656/1159 +f 1654/1160 1656/1159 427/1158 +f 1537/999 1656/1159 401/1001 +f 1655/1161 401/1001 1656/1159 +f 385/937 1657/1162 1492/944 +f 1659/1163 1492/944 1657/1162 +f 427/1158 1658/1164 1654/1160 +f 1659/1163 1654/1160 1658/1164 +f 424/1146 1660/1165 1646/1150 +f 1661/1166 1646/1150 1660/1165 +f 385/937 1486/938 1657/1162 +f 1661/1166 1657/1162 1486/938 +f 401/1001 1655/1161 1541/1004 +f 1662/1167 1541/1004 1655/1161 +f 1641/1144 1662/1167 424/1146 +f 1660/1165 424/1146 1662/1167 +f 1666/1168 1663/1169 1664/1170 +f 429/1171 1664/1170 1663/1169 +f 404/1015 1550/1016 1665/1172 +f 1666/1168 1665/1172 1550/1016 +f 386/940 1667/1173 1495/947 +f 1669/1174 1495/947 1667/1173 +f 429/1171 1668/1175 1664/1170 +f 1669/1174 1664/1170 1668/1175 +f 1670/1176 1671/1177 427/1158 +f 1658/1164 427/1158 1671/1177 +f 1667/1173 386/940 1671/1177 +f 1490/942 1671/1177 386/940 +f 1553/1018 404/1015 1672/1178 +f 1665/1172 1672/1178 404/1015 +f 1672/1178 1670/1176 1653/1157 +f 427/1158 1653/1157 1670/1176 +f 1651/1156 425/1151 1675/1179 +f 1673/1180 1675/1179 425/1151 +f 1513/968 1675/1179 394/969 +f 1674/1181 394/969 1675/1179 +f 387/932 1676/1182 1484/933 +f 1677/1183 1484/933 1676/1182 +f 425/1151 1648/1153 1673/1180 +f 1677/1183 1673/1180 1648/1153 +f 429/1171 1678/1184 1668/1175 +f 1679/1185 1668/1175 1678/1184 +f 387/932 1494/946 1676/1182 +f 1679/1185 1676/1182 1494/946 +f 394/969 1674/1181 1520/979 +f 1680/1186 1520/979 1674/1181 +f 1680/1186 1678/1184 1663/1169 +f 429/1171 1663/1169 1678/1184 +f 1681/1187 1684/1188 196/1189 +f 763/1190 196/1189 1684/1188 +f 1683/1191 1684/1188 434/1192 +f 1682/1193 434/1192 1684/1188 +f 1686/1194 1687/1195 432/1196 +f 1685/1197 432/1196 1687/1195 +f 1687/1195 1681/1187 759/1198 +f 196/1189 759/1198 1681/1187 +f 1689/1199 1691/1200 433/1201 +f 1688/1202 433/1201 1691/1200 +f 1691/1200 1686/1194 1690/1203 +f 432/1196 1690/1203 1686/1194 +f 434/1192 1682/1193 1692/1204 +f 1694/1205 1692/1204 1682/1193 +f 1694/1205 1689/1199 1693/1206 +f 433/1201 1693/1206 1689/1199 +f 340/1207 1695/1208 1311/1209 +f 1697/1210 1311/1209 1695/1208 +f 432/1196 1685/1197 1696/1211 +f 1697/1210 1696/1211 1685/1197 +f 1699/1212 1700/1213 436/1214 +f 1698/1215 436/1214 1700/1213 +f 1306/1216 1700/1213 340/1207 +f 1695/1208 340/1207 1700/1213 +f 437/1217 1702/1218 1701/1219 +f 1704/1220 1701/1219 1702/1218 +f 436/1214 1703/1221 1699/1212 +f 1704/1220 1699/1212 1703/1221 +f 1690/1203 432/1196 1706/1222 +f 1696/1211 1706/1222 432/1196 +f 1705/1223 1706/1222 437/1217 +f 1702/1218 437/1217 1706/1222 +f 1707/1224 1710/1225 337/1226 +f 1290/1227 337/1226 1710/1225 +f 1709/1228 1710/1225 441/1229 +f 1708/1230 441/1229 1710/1225 +f 439/1231 1712/1232 1711/1233 +f 1713/1234 1711/1233 1712/1232 +f 337/1226 1299/1235 1707/1224 +f 1713/1234 1707/1224 1299/1235 +f 1715/1236 1717/1237 440/1238 +f 1714/1239 440/1238 1717/1237 +f 1716/1240 1717/1237 439/1231 +f 1712/1232 439/1231 1717/1237 +f 441/1229 1708/1230 1718/1241 +f 1720/1242 1718/1241 1708/1230 +f 440/1238 1719/1243 1715/1236 +f 1720/1242 1715/1236 1719/1243 +f 1723/1244 746/1245 1721/1246 +f 190/1247 1721/1246 746/1245 +f 1722/1248 439/1231 1723/1244 +f 1711/1233 1723/1244 439/1231 +f 1725/1249 1683/1191 1724/1250 +f 434/1192 1724/1250 1683/1191 +f 1721/1246 190/1247 1725/1249 +f 740/1251 1725/1249 190/1247 +f 1728/1252 1726/1253 1727/1254 +f 443/1255 1727/1254 1726/1253 +f 434/1192 1692/1204 1724/1250 +f 1728/1252 1724/1250 1692/1204 +f 1730/1256 1716/1240 1722/1248 +f 439/1231 1722/1248 1716/1240 +f 1727/1254 443/1255 1730/1256 +f 1729/1257 1730/1256 443/1255 +f 445/1258 1732/1259 1731/1260 +f 1734/1261 1731/1260 1732/1259 +f 1701/1219 1734/1261 437/1217 +f 1733/1262 437/1217 1734/1261 +f 446/1263 1736/1264 1735/1265 +f 1738/1266 1735/1265 1736/1264 +f 1737/1267 1738/1266 445/1258 +f 1732/1259 445/1258 1738/1266 +f 1739/1268 1741/1269 433/1201 +f 1693/1206 433/1201 1741/1269 +f 1740/1270 1741/1269 446/1263 +f 1736/1264 446/1263 1741/1269 +f 437/1217 1733/1262 1705/1223 +f 1742/1271 1705/1223 1733/1262 +f 433/1201 1688/1202 1739/1268 +f 1742/1271 1739/1268 1688/1202 +f 1746/1272 1743/1273 1744/1274 +f 448/1275 1744/1274 1743/1273 +f 446/1263 1735/1265 1745/1276 +f 1746/1272 1745/1276 1735/1265 +f 1747/1277 1749/1278 440/1238 +f 1719/1243 440/1238 1749/1278 +f 1744/1274 448/1275 1749/1278 +f 1748/1279 1749/1278 448/1275 +f 443/1255 1750/1280 1729/1257 +f 1751/1281 1729/1257 1750/1280 +f 440/1238 1714/1239 1747/1277 +f 1751/1281 1747/1277 1714/1239 +f 1745/1276 1752/1282 446/1263 +f 1740/1270 446/1263 1752/1282 +f 1726/1253 1752/1282 443/1255 +f 1750/1280 443/1255 1752/1282 +f 1754/1283 1757/1284 450/1285 +f 1753/1286 450/1285 1757/1284 +f 1756/1287 1757/1284 452/1288 +f 1755/1289 452/1288 1757/1284 +f 451/1290 1759/1291 1758/1292 +f 1761/1293 1758/1292 1759/1291 +f 450/1285 1760/1294 1754/1283 +f 1761/1293 1754/1283 1760/1294 +f 452/1288 1755/1289 1762/1295 +f 1764/1296 1762/1295 1755/1289 +f 1763/1297 1764/1296 451/1290 +f 1759/1291 451/1290 1764/1296 +f 452/1288 1765/1298 1756/1287 +f 1768/1299 1756/1287 1765/1298 +f 1766/1300 455/1301 1768/1299 +f 1767/1302 1768/1299 455/1301 +f 1770/1303 1771/1304 454/1305 +f 1769/1306 454/1305 1771/1304 +f 1762/1295 1771/1304 452/1288 +f 1765/1298 452/1288 1771/1304 +f 208/82 1772/1307 806/91 +f 1774/1308 806/91 1772/1307 +f 454/1305 1773/1309 1770/1303 +f 1774/1308 1770/1303 1773/1309 +f 1775/1310 1776/1311 229/173 +f 881/180 229/173 1776/1311 +f 800/84 1776/1311 208/82 +f 1772/1307 208/82 1776/1311 +f 1778/1312 1777/1313 1766/1300 +f 455/1301 1766/1300 1777/1313 +f 229/173 875/174 1775/1310 +f 1778/1312 1775/1310 875/174 +f 455/1301 1779/1314 1767/1302 +f 1781/1315 1767/1302 1779/1314 +f 450/1285 1753/1286 1780/1316 +f 1781/1315 1780/1316 1753/1286 +f 1782/1317 1783/1318 258/303 +f 989/308 258/303 1783/1318 +f 1777/1313 1783/1318 455/1301 +f 1779/1314 455/1301 1783/1318 +f 1784/1319 1785/1320 249/251 +f 942/252 249/251 1785/1320 +f 258/303 986/305 1782/1317 +f 1785/1320 1782/1317 986/305 +f 1786/1321 457/1322 1788/1323 +f 1787/1324 1788/1323 457/1322 +f 1784/1319 249/251 1788/1323 +f 952/264 1788/1323 249/251 +f 1780/1316 1790/1325 450/1285 +f 1760/1294 450/1285 1790/1325 +f 1789/1326 1790/1325 457/1322 +f 1787/1324 457/1322 1790/1325 +f 1792/1327 1795/1328 459/1329 +f 1791/1330 459/1329 1795/1328 +f 1793/1331 460/1332 1795/1328 +f 1794/1333 1795/1328 460/1332 +f 457/1322 1796/1334 1789/1326 +f 1798/1335 1789/1326 1796/1334 +f 459/1329 1797/1336 1792/1327 +f 1798/1335 1792/1327 1797/1336 +f 1284/678 333/673 1800/1337 +f 1799/1338 1800/1337 333/673 +f 1786/1321 1800/1337 457/1322 +f 1796/1334 457/1322 1800/1337 +f 1802/1339 1801/1340 1793/1331 +f 460/1332 1793/1331 1801/1340 +f 333/673 1279/674 1799/1338 +f 1802/1339 1799/1338 1279/674 +f 360/803 1803/1341 1380/804 +f 1806/1342 1380/804 1803/1341 +f 463/1343 1805/1344 1804/1345 +f 1806/1342 1804/1345 1805/1344 +f 1807/1346 1808/1347 454/1305 +f 1773/1309 454/1305 1808/1347 +f 1387/812 1808/1347 360/803 +f 1803/1341 360/803 1808/1347 +f 462/1348 1810/1349 1809/1350 +f 1811/1351 1809/1350 1810/1349 +f 454/1305 1769/1306 1807/1346 +f 1811/1351 1807/1346 1769/1306 +f 1804/1345 1814/1352 463/1343 +f 1812/1353 463/1343 1814/1352 +f 1813/1354 1814/1352 462/1348 +f 1810/1349 462/1348 1814/1352 +f 451/1290 1815/1355 1763/1297 +f 1818/1356 1763/1297 1815/1355 +f 467/1357 1817/1358 1816/1359 +f 1818/1356 1816/1359 1817/1358 +f 1821/1360 1819/1361 1820/1362 +f 465/1363 1820/1362 1819/1361 +f 1758/1292 1821/1360 451/1290 +f 1815/1355 451/1290 1821/1360 +f 1823/1364 1825/1365 466/1366 +f 1822/1367 466/1366 1825/1365 +f 1820/1362 465/1363 1825/1365 +f 1824/1368 1825/1365 465/1363 +f 1826/1369 467/1357 1828/1370 +f 1816/1359 1828/1370 467/1357 +f 1823/1364 466/1366 1828/1370 +f 1827/1371 1828/1370 466/1366 +f 1829/1372 1831/1373 459/1329 +f 1797/1336 459/1329 1831/1373 +f 1819/1361 1831/1373 465/1363 +f 1830/1374 465/1363 1831/1373 +f 469/1375 1833/1376 1832/1377 +f 1834/1378 1832/1377 1833/1376 +f 459/1329 1791/1330 1829/1372 +f 1834/1378 1829/1372 1791/1330 +f 1836/1379 1838/1380 470/1381 +f 1835/1382 470/1381 1838/1380 +f 1837/1383 1838/1380 469/1375 +f 1833/1376 469/1375 1838/1380 +f 465/1363 1830/1374 1824/1368 +f 1840/1384 1824/1368 1830/1374 +f 470/1381 1839/1385 1836/1379 +f 1840/1384 1836/1379 1839/1385 +f 1844/1386 1813/1354 1841/1387 +f 462/1348 1841/1387 1813/1354 +f 473/1388 1843/1389 1842/1390 +f 1844/1386 1842/1390 1843/1389 +f 1845/1391 1846/1392 467/1357 +f 1817/1358 467/1357 1846/1392 +f 1841/1387 462/1348 1846/1392 +f 1809/1350 1846/1392 462/1348 +f 472/1393 1848/1394 1847/1395 +f 1849/1396 1847/1395 1848/1394 +f 1849/1396 1845/1391 1826/1369 +f 467/1357 1826/1369 1845/1391 +f 1842/1390 1852/1397 473/1388 +f 1850/1398 473/1388 1852/1397 +f 1851/1399 1852/1397 472/1393 +f 1848/1394 472/1393 1852/1397 +f 1853/1400 1855/1401 470/1381 +f 1839/1385 470/1381 1855/1401 +f 1854/1402 466/1366 1855/1401 +f 1822/1367 1855/1401 466/1366 +f 1858/1403 1856/1404 1857/1405 +f 475/1406 1857/1405 1856/1404 +f 470/1381 1835/1382 1853/1400 +f 1858/1403 1853/1400 1835/1382 +f 472/1393 1859/1407 1851/1399 +f 1861/1408 1851/1399 1859/1407 +f 475/1406 1860/1409 1857/1405 +f 1861/1408 1857/1405 1860/1409 +f 1854/1402 1862/1410 466/1366 +f 1827/1371 466/1366 1862/1410 +f 1859/1407 472/1393 1862/1410 +f 1847/1395 1862/1410 472/1393 +f 477/1411 1864/1412 1863/1413 +f 1867/1414 1863/1413 1864/1412 +f 1867/1414 1865/1415 1866/1416 +f 480/1417 1866/1416 1865/1415 +f 478/1418 1869/1419 1868/1420 +f 1871/1421 1868/1420 1869/1419 +f 1870/1422 1871/1421 477/1411 +f 1864/1412 477/1411 1871/1421 +f 1872/1423 479/1424 1875/1425 +f 1873/1426 1875/1425 479/1424 +f 1874/1427 1875/1425 478/1418 +f 1869/1419 478/1418 1875/1425 +f 1865/1415 1878/1428 480/1417 +f 1876/1429 480/1417 1878/1428 +f 479/1424 1877/1430 1873/1426 +f 1878/1428 1873/1426 1877/1430 +f 1879/1431 1882/1432 480/1417 +f 1866/1416 480/1417 1882/1432 +f 1880/1433 484/1434 1882/1432 +f 1881/1435 1882/1432 484/1434 +f 482/1436 1884/1437 1883/1438 +f 1885/1439 1883/1438 1884/1437 +f 1885/1439 1879/1431 1876/1429 +f 480/1417 1876/1429 1879/1431 +f 1887/1440 1889/1441 483/1442 +f 1886/1443 483/1442 1889/1441 +f 1888/1444 1889/1441 482/1436 +f 1884/1437 482/1436 1889/1441 +f 484/1434 1880/1433 1890/1445 +f 1892/1446 1890/1445 1880/1433 +f 483/1442 1891/1447 1887/1440 +f 1892/1446 1887/1440 1891/1447 +f 1894/1448 1897/1449 486/1450 +f 1893/1451 486/1450 1897/1449 +f 1897/1449 1895/1452 1896/1453 +f 489/1454 1896/1453 1895/1452 +f 1899/1455 1901/1456 487/1457 +f 1898/1458 487/1457 1901/1456 +f 486/1450 1900/1459 1894/1448 +f 1901/1456 1894/1448 1900/1459 +f 488/1460 1903/1461 1902/1462 +f 1905/1463 1902/1462 1903/1461 +f 487/1457 1904/1464 1899/1455 +f 1905/1463 1899/1455 1904/1464 +f 1895/1452 1908/1465 489/1454 +f 1906/1466 489/1454 1908/1465 +f 1907/1467 1908/1465 488/1460 +f 1903/1461 488/1460 1908/1465 +f 1910/1468 1913/1469 491/1470 +f 1909/1471 491/1470 1913/1469 +f 1912/1472 1913/1469 493/1473 +f 1911/1474 493/1473 1913/1469 +f 492/1475 1915/1476 1914/1477 +f 1917/1478 1914/1477 1915/1476 +f 491/1470 1916/1479 1910/1468 +f 1917/1478 1910/1468 1916/1479 +f 1918/1480 1920/1481 487/1457 +f 1904/1464 487/1457 1920/1481 +f 1919/1482 1920/1481 492/1475 +f 1915/1476 492/1475 1920/1481 +f 493/1473 1911/1474 1921/1483 +f 1922/1484 1921/1483 1911/1474 +f 487/1457 1898/1458 1918/1480 +f 1922/1484 1918/1480 1898/1458 +f 495/1485 1924/1486 1923/1487 +f 1927/1488 1923/1487 1924/1486 +f 1926/1489 1927/1488 498/1490 +f 1925/1491 498/1490 1927/1488 +f 1929/1492 1931/1493 496/1494 +f 1928/1495 496/1494 1931/1493 +f 1930/1496 1931/1493 495/1485 +f 1924/1486 495/1485 1931/1493 +f 1933/1497 1935/1498 497/1499 +f 1932/1500 497/1499 1935/1498 +f 496/1494 1934/1501 1929/1492 +f 1935/1498 1929/1492 1934/1501 +f 498/1490 1925/1491 1936/1502 +f 1938/1503 1936/1502 1925/1491 +f 497/1499 1937/1504 1933/1497 +f 1938/1503 1933/1497 1937/1504 +f 500/1505 1940/1506 1939/1507 +f 1942/1508 1939/1507 1940/1506 +f 486/1450 1893/1451 1941/1509 +f 1942/1508 1941/1509 1893/1451 +f 1944/1510 1946/1511 501/1512 +f 1943/1513 501/1512 1946/1511 +f 1945/1514 1946/1511 500/1505 +f 1940/1506 500/1505 1946/1511 +f 502/1515 1948/1516 1947/1517 +f 1950/1518 1947/1517 1948/1516 +f 501/1512 1949/1519 1944/1510 +f 1950/1518 1944/1510 1949/1519 +f 1941/1509 1952/1520 486/1450 +f 1900/1459 486/1450 1952/1520 +f 1951/1521 1952/1520 502/1515 +f 1948/1516 502/1515 1952/1520 +f 1954/1522 1956/1523 504/1524 +f 1953/1525 504/1524 1956/1523 +f 1955/1526 477/1411 1956/1523 +f 1863/1413 1956/1523 477/1411 +f 505/1527 1958/1528 1957/1529 +f 1960/1530 1957/1529 1958/1528 +f 504/1524 1959/1531 1954/1522 +f 1960/1530 1954/1522 1959/1531 +f 1961/1532 1963/1533 501/1512 +f 1949/1519 501/1512 1963/1533 +f 1962/1534 1963/1533 505/1527 +f 1958/1528 505/1527 1963/1533 +f 1964/1535 1870/1422 1955/1526 +f 477/1411 1955/1526 1870/1422 +f 501/1512 1943/1513 1961/1532 +f 1964/1535 1961/1532 1943/1513 +f 1966/1536 1969/1537 507/1538 +f 1965/1539 507/1538 1969/1537 +f 509/1540 1968/1541 1967/1542 +f 1969/1537 1967/1542 1968/1541 +f 1971/1543 1973/1544 508/1545 +f 1970/1546 508/1545 1973/1544 +f 1973/1544 1966/1536 1972/1547 +f 507/1538 1972/1547 1966/1536 +f 505/1527 1974/1548 1962/1534 +f 1976/1549 1962/1534 1974/1548 +f 1976/1549 1971/1543 1975/1550 +f 508/1545 1975/1550 1971/1543 +f 1977/1551 509/1540 1978/1552 +f 1967/1542 1978/1552 509/1540 +f 1957/1529 1978/1552 505/1527 +f 1974/1548 505/1527 1978/1552 +f 493/1473 1979/1553 1912/1472 +f 1982/1554 1912/1472 1979/1553 +f 511/1555 1981/1556 1980/1557 +f 1982/1554 1980/1557 1981/1556 +f 502/1515 1983/1558 1951/1521 +f 1984/1559 1951/1521 1983/1558 +f 1921/1483 1984/1559 493/1473 +f 1979/1553 493/1473 1984/1559 +f 1975/1550 508/1545 1986/1560 +f 1985/1561 1986/1560 508/1545 +f 1947/1517 1986/1560 502/1515 +f 1983/1558 502/1515 1986/1560 +f 1980/1557 1988/1562 511/1555 +f 1987/1563 511/1555 1988/1562 +f 508/1545 1970/1546 1985/1561 +f 1988/1562 1985/1561 1970/1546 +f 498/1490 1989/1564 1926/1489 +f 1992/1565 1926/1489 1989/1564 +f 515/1566 1991/1567 1990/1568 +f 1992/1565 1990/1568 1991/1567 +f 1994/1569 1995/1570 513/1571 +f 1993/1572 513/1571 1995/1570 +f 1936/1502 1995/1570 498/1490 +f 1989/1564 498/1490 1995/1570 +f 514/1573 1997/1574 1996/1575 +f 1999/1576 1996/1575 1997/1574 +f 513/1571 1998/1577 1994/1569 +f 1999/1576 1994/1569 1998/1577 +f 1990/1568 2002/1578 515/1566 +f 2000/1579 515/1566 2002/1578 +f 2001/1580 2002/1578 514/1573 +f 1997/1574 514/1573 2002/1578 +f 2004/1581 2007/1582 517/1583 +f 2003/1584 517/1583 2007/1582 +f 2006/1585 2007/1582 519/1586 +f 2005/1587 519/1586 2007/1582 +f 518/1588 2009/1589 2008/1590 +f 2011/1591 2008/1590 2009/1589 +f 2011/1591 2004/1581 2010/1592 +f 517/1583 2010/1592 2004/1581 +f 2012/1593 2014/1594 513/1571 +f 1998/1577 513/1571 2014/1594 +f 2013/1595 2014/1594 518/1588 +f 2009/1589 518/1588 2014/1594 +f 519/1586 2005/1587 2015/1596 +f 2016/1597 2015/1596 2005/1587 +f 513/1571 1993/1572 2012/1593 +f 2016/1597 2012/1593 1993/1572 +f 2020/1598 1968/1541 2017/1599 +f 509/1540 2017/1599 1968/1541 +f 2020/1598 2018/1600 2019/1601 +f 522/1602 2019/1601 2018/1600 +f 2021/1603 521/1604 2023/1605 +f 2022/1606 2023/1605 521/1604 +f 2023/1605 2017/1599 1977/1551 +f 509/1540 1977/1551 2017/1599 +f 518/1588 2024/1607 2013/1595 +f 2026/1608 2013/1595 2024/1607 +f 521/1604 2025/1609 2022/1606 +f 2026/1608 2022/1606 2025/1609 +f 2018/1600 2028/1610 522/1602 +f 2027/1611 522/1602 2028/1610 +f 2008/1590 2028/1610 518/1588 +f 2024/1607 518/1588 2028/1610 +f 484/1434 2029/1612 1881/1435 +f 2031/1613 1881/1435 2029/1612 +f 504/1524 1953/1525 2030/1614 +f 2031/1613 2030/1614 1953/1525 +f 514/1573 2032/1615 2001/1580 +f 2033/1616 2001/1580 2032/1615 +f 1890/1445 2033/1616 484/1434 +f 2029/1612 484/1434 2033/1616 +f 2034/1617 2035/1618 521/1604 +f 2025/1609 521/1604 2035/1618 +f 1996/1575 2035/1618 514/1573 +f 2032/1615 514/1573 2035/1618 +f 1959/1531 504/1524 2036/1619 +f 2030/1614 2036/1619 504/1524 +f 521/1604 2021/1603 2034/1617 +f 2036/1619 2034/1617 2021/1603 +f 2038/1620 2041/1621 525/1622 +f 2037/1623 525/1622 2041/1621 +f 2040/1624 2041/1621 528/1625 +f 2039/1626 528/1625 2041/1621 +f 526/1627 2043/1628 2042/1629 +f 2045/1630 2042/1629 2043/1628 +f 525/1622 2044/1631 2038/1620 +f 2045/1630 2038/1620 2044/1631 +f 2047/1632 2049/1633 527/1634 +f 2046/1635 527/1634 2049/1633 +f 2048/1636 2049/1633 526/1627 +f 2043/1628 526/1627 2049/1633 +f 2052/1637 2050/1638 2039/1626 +f 528/1625 2039/1626 2050/1638 +f 527/1634 2051/1639 2047/1632 +f 2052/1637 2047/1632 2051/1639 +f 2057/1640 2053/1641 2054/1642 +f 530/1643 2054/1642 2053/1641 +f 2056/1644 2057/1640 532/1645 +f 2055/1646 532/1645 2057/1640 +f 531/1647 2059/1648 2058/1649 +f 2061/1650 2058/1649 2059/1648 +f 2061/1650 2054/1642 2060/1651 +f 530/1643 2060/1651 2054/1642 +f 2062/1652 2064/1653 526/1627 +f 2048/1636 526/1627 2064/1653 +f 2063/1654 2064/1653 531/1647 +f 2059/1648 531/1647 2064/1653 +f 532/1645 2055/1646 2065/1655 +f 2066/1656 2065/1655 2055/1646 +f 526/1627 2042/1629 2062/1652 +f 2066/1656 2062/1652 2042/1629 +f 534/1657 2068/1658 2067/1659 +f 2071/1660 2067/1659 2068/1658 +f 537/1661 2070/1662 2069/1663 +f 2071/1660 2069/1663 2070/1662 +f 2072/1664 535/1665 2075/1666 +f 2073/1667 2075/1666 535/1665 +f 2074/1668 2075/1666 534/1657 +f 2068/1658 534/1657 2075/1666 +f 536/1669 2077/1670 2076/1671 +f 2079/1672 2076/1671 2077/1670 +f 2079/1672 2073/1667 2078/1673 +f 535/1665 2078/1673 2073/1667 +f 2080/1674 537/1661 2082/1675 +f 2069/1663 2082/1675 537/1661 +f 2081/1676 2082/1675 536/1669 +f 2077/1670 536/1669 2082/1675 +f 2084/1677 2086/1678 539/1679 +f 2083/1680 539/1679 2086/1678 +f 2053/1641 2086/1678 530/1643 +f 2085/1681 530/1643 2086/1678 +f 536/1669 2087/1682 2081/1676 +f 2089/1683 2081/1676 2087/1682 +f 539/1679 2088/1684 2084/1677 +f 2089/1683 2084/1677 2088/1684 +f 2091/1685 2092/1686 540/1687 +f 2090/1688 540/1687 2092/1686 +f 2076/1671 2092/1686 536/1669 +f 2087/1682 536/1669 2092/1686 +f 530/1643 2085/1681 2060/1651 +f 2094/1689 2060/1651 2085/1681 +f 540/1687 2093/1690 2091/1685 +f 2094/1689 2091/1685 2093/1690 +f 542/1691 2096/1692 2095/1693 +f 2098/1694 2095/1693 2096/1692 +f 507/1538 1965/1539 2097/1695 +f 2098/1694 2097/1695 1965/1539 +f 2099/1696 2101/1697 532/1645 +f 2056/1644 532/1645 2101/1697 +f 2100/1698 2101/1697 542/1691 +f 2096/1692 542/1691 2101/1697 +f 543/1699 2103/1700 2102/1701 +f 2104/1702 2102/1701 2103/1700 +f 2104/1702 2099/1696 2065/1655 +f 532/1645 2065/1655 2099/1696 +f 2097/1695 2106/1703 507/1538 +f 1972/1547 507/1538 2106/1703 +f 2105/1704 2106/1703 543/1699 +f 2103/1700 543/1699 2106/1703 +f 2010/1592 517/1583 2110/1705 +f 2107/1706 2110/1705 517/1583 +f 2109/1707 2110/1705 546/1708 +f 2108/1709 546/1708 2110/1705 +f 2113/1710 2111/1711 2112/1712 +f 545/1713 2112/1712 2111/1711 +f 517/1583 2003/1584 2107/1706 +f 2113/1710 2107/1706 2003/1584 +f 537/1661 2114/1714 2070/1662 +f 2116/1715 2070/1662 2114/1714 +f 545/1713 2115/1716 2112/1712 +f 2116/1715 2112/1712 2115/1716 +f 546/1708 2108/1709 2117/1717 +f 2118/1718 2117/1717 2108/1709 +f 2080/1674 2118/1718 537/1661 +f 2114/1714 537/1661 2118/1718 +f 2119/1719 2122/1720 491/1470 +f 1916/1479 491/1470 2122/1720 +f 2121/1721 2122/1720 549/1722 +f 2120/1723 549/1722 2122/1720 +f 2125/1724 2123/1725 2124/1726 +f 548/1727 2124/1726 2123/1725 +f 491/1470 1909/1471 2119/1719 +f 2125/1724 2119/1719 1909/1471 +f 528/1625 2126/1728 2040/1624 +f 2128/1729 2040/1624 2126/1728 +f 2124/1726 548/1727 2128/1729 +f 2127/1730 2128/1729 548/1727 +f 549/1722 2120/1723 2129/1731 +f 2130/1732 2129/1731 2120/1723 +f 2050/1638 2130/1732 528/1625 +f 2126/1728 528/1625 2130/1732 +f 2131/1733 2133/1734 539/1679 +f 2088/1684 539/1679 2133/1734 +f 2117/1717 2133/1734 546/1708 +f 2132/1735 546/1708 2133/1734 +f 542/1691 2134/1736 2100/1698 +f 2135/1737 2100/1698 2134/1736 +f 539/1679 2083/1680 2131/1733 +f 2135/1737 2131/1733 2083/1680 +f 2136/1738 2137/1739 522/1602 +f 2019/1601 522/1602 2137/1739 +f 2095/1693 2137/1739 542/1691 +f 2134/1736 542/1691 2137/1739 +f 546/1708 2132/1735 2109/1707 +f 2138/1740 2109/1707 2132/1735 +f 522/1602 2027/1611 2136/1738 +f 2138/1740 2136/1738 2027/1611 +f 543/1699 2139/1741 2105/1704 +f 2141/1742 2105/1704 2139/1741 +f 511/1555 1987/1563 2140/1743 +f 2141/1742 2140/1743 1987/1563 +f 2142/1744 2143/1745 525/1622 +f 2044/1631 525/1622 2143/1745 +f 2102/1701 2143/1745 543/1699 +f 2139/1741 543/1699 2143/1745 +f 548/1727 2144/1746 2127/1730 +f 2145/1747 2127/1730 2144/1746 +f 525/1622 2037/1623 2142/1744 +f 2145/1747 2142/1744 2037/1623 +f 2140/1743 2146/1748 511/1555 +f 1981/1556 511/1555 2146/1748 +f 2123/1725 2146/1748 548/1727 +f 2144/1746 548/1727 2146/1748 +f 2150/1749 2121/1721 2147/1750 +f 549/1722 2147/1750 2121/1721 +f 2149/1751 2150/1749 555/1752 +f 2148/1753 555/1752 2150/1749 +f 2152/1754 2153/1755 553/1756 +f 2151/1757 553/1756 2153/1755 +f 2147/1750 549/1722 2153/1755 +f 2129/1731 2153/1755 549/1722 +f 554/1758 2155/1759 2154/1760 +f 2157/1761 2154/1760 2155/1759 +f 2157/1761 2152/1754 2156/1762 +f 553/1756 2156/1762 2152/1754 +f 2158/1763 555/1752 2160/1764 +f 2148/1753 2160/1764 555/1752 +f 2159/1765 2160/1764 554/1758 +f 2155/1759 554/1758 2160/1764 +f 2164/1766 2159/1767 2161/1768 +f 554/1769 2161/1768 2159/1767 +f 559/1770 2163/1771 2162/1772 +f 2164/1766 2162/1772 2163/1771 +f 2166/1773 2167/1774 557/1775 +f 2165/1776 557/1775 2167/1774 +f 2161/1768 554/1769 2167/1774 +f 2154/1777 2167/1774 554/1769 +f 558/1778 2169/1779 2168/1780 +f 2171/1781 2168/1780 2169/1779 +f 2171/1781 2166/1773 2170/1782 +f 557/1775 2170/1782 2166/1773 +f 2162/1772 2174/1783 559/1770 +f 2172/1784 559/1770 2174/1783 +f 2173/1785 2174/1783 558/1778 +f 2169/1779 558/1778 2174/1783 +f 2175/1786 2178/1787 559/1770 +f 2163/1771 559/1770 2178/1787 +f 2177/1788 2178/1787 563/1789 +f 2176/1790 563/1789 2178/1787 +f 561/1791 2180/1792 2179/1793 +f 2181/1794 2179/1793 2180/1792 +f 559/1770 2172/1784 2175/1786 +f 2181/1794 2175/1786 2172/1784 +f 2183/1795 2185/1796 562/1797 +f 2182/1798 562/1797 2185/1796 +f 2184/1799 2185/1796 561/1791 +f 2180/1792 561/1791 2185/1796 +f 563/1789 2176/1790 2186/1800 +f 2188/1801 2186/1800 2176/1790 +f 562/1797 2187/1802 2183/1795 +f 2188/1801 2183/1795 2187/1802 +f 2190/1803 2192/1804 565/1805 +f 2189/1806 565/1805 2192/1804 +f 2179/1793 2192/1804 561/1791 +f 2191/1807 561/1791 2192/1804 +f 2194/1808 2196/1809 566/1810 +f 2193/1811 566/1810 2196/1809 +f 565/1805 2195/1812 2190/1803 +f 2196/1809 2190/1803 2195/1812 +f 2198/1813 2200/1814 567/1815 +f 2197/1816 567/1815 2200/1814 +f 566/1810 2199/1817 2194/1808 +f 2200/1814 2194/1808 2199/1817 +f 561/1791 2191/1807 2184/1799 +f 2202/1818 2184/1799 2191/1807 +f 567/1815 2201/1819 2198/1813 +f 2202/1818 2198/1813 2201/1819 +f 2204/1820 2207/1821 569/1822 +f 2203/1823 569/1822 2207/1821 +f 2205/1824 572/1825 2207/1821 +f 2206/1826 2207/1821 572/1825 +f 2209/1827 2211/1828 570/1829 +f 2208/1830 570/1829 2211/1828 +f 569/1822 2210/1831 2204/1820 +f 2211/1828 2204/1820 2210/1831 +f 571/1832 2213/1833 2212/1834 +f 2215/1835 2212/1834 2213/1833 +f 570/1829 2214/1836 2209/1827 +f 2215/1835 2209/1827 2214/1836 +f 572/1825 2205/1824 2216/1837 +f 2218/1838 2216/1837 2205/1824 +f 2213/1833 571/1832 2218/1838 +f 2217/1839 2218/1838 571/1832 +f 2220/1840 2223/1841 574/1842 +f 2219/1843 574/1842 2223/1841 +f 2221/1844 577/1845 2223/1841 +f 2222/1846 2223/1841 577/1845 +f 2225/1847 2227/1848 575/1849 +f 2224/1850 575/1849 2227/1848 +f 574/1842 2226/1851 2220/1840 +f 2227/1848 2220/1840 2226/1851 +f 576/1852 2229/1853 2228/1854 +f 2231/1855 2228/1854 2229/1853 +f 575/1849 2230/1856 2225/1847 +f 2231/1855 2225/1847 2230/1856 +f 577/1845 2221/1844 2232/1857 +f 2234/1858 2232/1857 2221/1844 +f 2229/1853 576/1852 2234/1858 +f 2233/1859 2234/1858 576/1852 +f 579/1860 2236/1861 2235/1862 +f 2238/1863 2235/1862 2236/1861 +f 515/1864 2000/1865 2237/1866 +f 2238/1863 2237/1866 2000/1865 +f 574/1842 2239/1867 2226/1851 +f 2241/1868 2226/1851 2239/1867 +f 2236/1861 579/1860 2241/1868 +f 2240/1869 2241/1868 579/1860 +f 580/1870 2243/1871 2242/1872 +f 2244/1873 2242/1872 2243/1871 +f 574/1842 2219/1843 2239/1867 +f 2244/1873 2239/1867 2219/1843 +f 2237/1866 2246/1874 515/1864 +f 1991/1875 515/1864 2246/1874 +f 2243/1871 580/1870 2246/1874 +f 2245/1876 2246/1874 580/1870 +f 2248/1877 2251/1878 582/1879 +f 2247/1880 582/1879 2251/1878 +f 2250/1881 2251/1878 584/1882 +f 2249/1883 584/1882 2251/1878 +f 576/1852 2252/1884 2233/1859 +f 2254/1885 2233/1859 2252/1884 +f 582/1879 2253/1886 2248/1877 +f 2254/1885 2248/1877 2253/1886 +f 583/1887 2256/1888 2255/1889 +f 2257/1890 2255/1889 2256/1888 +f 2252/1884 576/1852 2257/1890 +f 2228/1854 2257/1890 576/1852 +f 584/1882 2249/1883 2258/1891 +f 2260/1892 2258/1891 2249/1883 +f 2260/1892 2256/1888 2259/1893 +f 583/1887 2259/1893 2256/1888 +f 2261/1894 2263/1895 483/1896 +f 1891/1897 483/1896 2263/1895 +f 2235/1862 2263/1895 579/1860 +f 2262/1898 579/1860 2263/1895 +f 583/1887 2264/1899 2259/1893 +f 2265/1900 2259/1893 2264/1899 +f 483/1896 1886/1901 2261/1894 +f 2265/1900 2261/1894 1886/1901 +f 2266/1902 2267/1903 575/1849 +f 2230/1856 575/1849 2267/1903 +f 583/1887 2255/1889 2264/1899 +f 2267/1903 2264/1899 2255/1889 +f 579/1860 2262/1898 2240/1869 +f 2268/1904 2240/1869 2262/1898 +f 575/1849 2224/1850 2266/1902 +f 2268/1904 2266/1902 2224/1850 +f 2271/1905 1930/1906 2269/1907 +f 495/1908 2269/1907 1930/1906 +f 2271/1905 2270/1909 2247/1880 +f 582/1879 2247/1880 2270/1909 +f 2272/1910 2273/1911 580/1870 +f 2245/1876 580/1870 2273/1911 +f 2269/1907 495/1908 2273/1911 +f 1923/1912 2273/1911 495/1908 +f 577/1845 2274/1913 2222/1846 +f 2275/1914 2222/1846 2274/1913 +f 580/1870 2242/1872 2272/1910 +f 2275/1914 2272/1910 2242/1872 +f 2270/1909 2276/1915 582/1879 +f 2253/1886 582/1879 2276/1915 +f 2276/1915 2274/1913 2232/1857 +f 577/1845 2232/1857 2274/1913 +f 500/1916 2277/1917 1945/1918 +f 2280/1919 1945/1918 2277/1917 +f 589/1920 2279/1921 2278/1922 +f 2280/1919 2278/1922 2279/1921 +f 2282/1923 2283/1924 588/1925 +f 2281/1926 588/1925 2283/1924 +f 1939/1927 2283/1924 500/1916 +f 2277/1917 500/1916 2283/1924 +f 572/1825 2284/1928 2206/1826 +f 2286/1929 2206/1826 2284/1928 +f 588/1925 2285/1930 2282/1923 +f 2286/1929 2282/1923 2285/1930 +f 2278/1922 2288/1931 589/1920 +f 2287/1932 589/1920 2288/1931 +f 2284/1928 572/1825 2288/1931 +f 2216/1837 2288/1931 572/1825 +f 2292/1933 2289/1934 2290/1935 +f 591/1936 2290/1935 2289/1934 +f 489/1937 1906/1938 2291/1939 +f 2292/1933 2291/1939 1906/1938 +f 2293/1940 2295/1941 569/1822 +f 2210/1831 569/1822 2295/1941 +f 2290/1935 591/1936 2295/1941 +f 2294/1942 2295/1941 591/1936 +f 588/1925 2296/1943 2285/1930 +f 2297/1944 2285/1930 2296/1943 +f 569/1822 2203/1823 2293/1940 +f 2297/1944 2293/1940 2203/1823 +f 1896/1945 489/1937 2298/1946 +f 2291/1939 2298/1946 489/1937 +f 2296/1943 588/1925 2298/1946 +f 2281/1926 2298/1946 588/1925 +f 478/1947 2299/1948 1874/1949 +f 2302/1950 1874/1949 2299/1948 +f 593/1951 2301/1952 2300/1953 +f 2302/1950 2300/1953 2301/1952 +f 2303/1954 2304/1955 589/1920 +f 2279/1921 589/1920 2304/1955 +f 1868/1956 2304/1955 478/1947 +f 2299/1948 478/1947 2304/1955 +f 571/1832 2305/1957 2217/1839 +f 2306/1958 2217/1839 2305/1957 +f 589/1920 2287/1932 2303/1954 +f 2306/1958 2303/1954 2287/1932 +f 2300/1953 2308/1959 593/1951 +f 2307/1960 593/1951 2308/1959 +f 2212/1834 2308/1959 571/1832 +f 2305/1957 571/1832 2308/1959 +f 2310/1961 2312/1962 595/1963 +f 2309/1964 595/1963 2312/1962 +f 2289/1934 2312/1962 591/1936 +f 2311/1965 591/1936 2312/1962 +f 2313/1966 2315/1967 593/1951 +f 2301/1952 593/1951 2315/1967 +f 595/1963 2314/1968 2310/1961 +f 2315/1967 2310/1961 2314/1968 +f 570/1829 2316/1969 2214/1836 +f 2317/1970 2214/1836 2316/1969 +f 593/1951 2307/1960 2313/1966 +f 2317/1970 2313/1966 2307/1960 +f 591/1936 2311/1965 2294/1942 +f 2318/1971 2294/1942 2311/1965 +f 570/1829 2208/1830 2316/1969 +f 2318/1971 2316/1969 2208/1830 +f 2319/1972 2322/1973 565/1805 +f 2195/1812 565/1805 2322/1973 +f 2321/1974 2322/1973 599/1975 +f 2320/1976 599/1975 2322/1973 +f 558/1778 2323/1977 2173/1785 +f 2324/1978 2173/1785 2323/1977 +f 565/1805 2189/1806 2319/1972 +f 2324/1978 2319/1972 2189/1806 +f 2326/1979 2327/1980 597/1981 +f 2325/1982 597/1981 2327/1980 +f 2323/1977 558/1778 2327/1980 +f 2168/1780 2327/1980 558/1778 +f 598/1983 2329/1984 2328/1985 +f 2331/1986 2328/1985 2329/1984 +f 2331/1986 2326/1979 2330/1987 +f 597/1981 2330/1987 2326/1979 +f 2320/1976 2334/1988 599/1975 +f 2332/1989 599/1975 2334/1988 +f 2333/1990 2334/1988 598/1983 +f 2329/1984 598/1983 2334/1988 +f 2335/1991 601/1992 2339/1993 +f 2336/1994 2339/1993 601/1992 +f 2338/1995 2339/1993 604/1996 +f 2337/1997 604/1996 2339/1993 +f 2341/1998 2343/1999 602/2000 +f 2340/2001 602/2000 2343/1999 +f 2336/1994 601/1992 2343/1999 +f 2342/2002 2343/1999 601/1992 +f 2345/2003 2347/2004 603/2005 +f 2344/2006 603/2005 2347/2004 +f 602/2000 2346/2007 2341/1998 +f 2347/2004 2341/1998 2346/2007 +f 604/1996 2337/1997 2348/2008 +f 2350/2009 2348/2008 2337/1997 +f 603/2005 2349/2010 2345/2003 +f 2350/2009 2345/2003 2349/2010 +f 2351/2011 2353/2012 603/2005 +f 2349/2010 603/2005 2353/2012 +f 2352/2013 598/2014 2353/2012 +f 2328/2015 2353/2012 598/2014 +f 606/2016 2355/2017 2354/2018 +f 2356/2019 2354/2018 2355/2017 +f 603/2005 2344/2006 2351/2011 +f 2356/2019 2351/2011 2344/2006 +f 2358/2020 2360/2021 607/2022 +f 2357/2023 607/2022 2360/2021 +f 2359/2024 2360/2021 606/2016 +f 2355/2017 606/2016 2360/2021 +f 2362/2025 2333/2026 2352/2013 +f 598/2014 2352/2013 2333/2026 +f 607/2022 2361/2027 2358/2020 +f 2362/2025 2358/2020 2361/2027 +f 2363/2028 2366/2029 606/2016 +f 2359/2024 606/2016 2366/2029 +f 2365/2030 2366/2029 610/2031 +f 2364/2032 610/2031 2366/2029 +f 2367/2033 2368/2034 602/2000 +f 2346/2007 602/2000 2368/2034 +f 606/2016 2354/2018 2363/2028 +f 2368/2034 2363/2028 2354/2018 +f 2370/2035 2371/2036 609/2037 +f 2369/2038 609/2037 2371/2036 +f 602/2000 2340/2001 2367/2033 +f 2371/2036 2367/2033 2340/2001 +f 610/2031 2364/2032 2372/2039 +f 2374/2040 2372/2039 2364/2032 +f 609/2037 2373/2041 2370/2035 +f 2374/2040 2370/2035 2373/2041 +f 612/2042 2376/2043 2375/2044 +f 2378/2045 2375/2044 2376/2043 +f 324/2046 1247/2047 2377/2048 +f 2378/2045 2377/2048 1247/2047 +f 2379/2049 2381/2050 527/1634 +f 2051/1639 527/1634 2381/2050 +f 2380/2051 2381/2050 612/2042 +f 2376/2043 612/2042 2381/2050 +f 613/2052 2383/2053 2382/2054 +f 2384/2055 2382/2054 2383/2053 +f 527/1634 2046/1635 2379/2049 +f 2384/2055 2379/2049 2046/1635 +f 2377/2048 2386/2056 324/2046 +f 1254/2057 324/2046 2386/2056 +f 2385/2058 2386/2056 613/2052 +f 2383/2053 613/2052 2386/2056 +f 615/2059 2388/2060 2387/2061 +f 2390/2062 2387/2061 2388/2060 +f 2390/2062 2389/2063 1261/2064 +f 328/2065 1261/2064 2389/2063 +f 2391/2066 2393/2067 540/1687 +f 2093/1690 540/1687 2393/2067 +f 2392/2068 2393/2067 615/2059 +f 2388/2060 615/2059 2393/2067 +f 2396/2069 2394/2070 2395/2071 +f 616/2072 2395/2071 2394/2070 +f 540/1687 2090/1688 2391/2066 +f 2396/2069 2391/2066 2090/1688 +f 2389/2063 2398/2073 328/2065 +f 1268/2074 328/2065 2398/2073 +f 2395/2071 616/2072 2398/2073 +f 2397/2075 2398/2073 616/2072 +f 616/2072 2399/2076 2397/2075 +f 2401/2077 2397/2075 2399/2076 +f 2401/2077 2400/2078 1275/2079 +f 332/2080 1275/2079 2400/2078 +f 2078/1673 535/1665 2403/2081 +f 2402/2082 2403/2081 535/1665 +f 2394/2070 2403/2081 616/2072 +f 2399/2076 616/2072 2403/2081 +f 618/2083 2405/2084 2404/2085 +f 2406/2086 2404/2085 2405/2084 +f 2406/2086 2402/2082 2072/1664 +f 535/1665 2072/1664 2402/2082 +f 2400/2078 2408/2087 332/2080 +f 1281/2088 332/2080 2408/2087 +f 2405/2084 618/2083 2408/2087 +f 2407/2089 2408/2087 618/2083 +f 620/2090 2410/2091 2409/2092 +f 2412/2093 2409/2092 2410/2091 +f 335/2094 1287/2095 2411/2096 +f 2412/2093 2411/2096 1287/2095 +f 2413/2097 2415/2098 595/2099 +f 2314/2100 595/2099 2415/2098 +f 2414/2101 2415/2098 620/2090 +f 2410/2091 620/2090 2415/2098 +f 2418/2102 2416/2103 2417/2104 +f 621/2105 2417/2104 2416/2103 +f 2418/2102 2413/2097 2309/2106 +f 595/2099 2309/2106 2413/2097 +f 2411/2096 2420/2107 335/2094 +f 1294/2108 335/2094 2420/2107 +f 2417/2104 621/2105 2420/2107 +f 2419/2109 2420/2107 621/2105 +f 2421/2110 623/2111 2424/2112 +f 2422/2113 2424/2112 623/2111 +f 2423/2114 339/2115 2424/2112 +f 1301/2116 2424/2112 339/2115 +f 584/2117 2425/2118 2250/2119 +f 2427/2120 2250/2119 2425/2118 +f 623/2111 2426/2121 2422/2113 +f 2427/2120 2422/2113 2426/2121 +f 2429/2122 2430/2123 624/2124 +f 2428/2125 624/2124 2430/2123 +f 2425/2118 584/2117 2430/2123 +f 2258/2126 2430/2123 584/2117 +f 2432/2127 1308/2128 2423/2114 +f 339/2115 2423/2114 1308/2128 +f 624/2124 2431/2129 2429/2122 +f 2432/2127 2429/2122 2431/2129 +f 613/2052 2433/2130 2385/2058 +f 2435/2131 2385/2058 2433/2130 +f 2435/2131 2434/2132 1315/2133 +f 343/2134 1315/2133 2434/2132 +f 2063/1654 531/1647 2437/2135 +f 2436/2136 2437/2135 531/1647 +f 2382/2054 2437/2135 613/2052 +f 2433/2130 613/2052 2437/2135 +f 2439/2137 2392/2068 2438/2138 +f 615/2059 2438/2138 2392/2068 +f 531/1647 2058/1649 2436/2136 +f 2439/2137 2436/2136 2058/1649 +f 2434/2132 2440/2139 343/2134 +f 1320/2140 343/2134 2440/2139 +f 2438/2138 615/2059 2440/2139 +f 2387/2061 2440/2139 615/2059 +f 627/2141 2442/2142 2441/2143 +f 2444/2144 2441/2143 2442/2142 +f 345/2145 1325/2146 2443/2147 +f 2444/2144 2443/2147 1325/2146 +f 2156/1762 553/1756 2447/2148 +f 2445/2149 2447/2148 553/1756 +f 2446/2150 2447/2148 627/2141 +f 2442/2142 627/2141 2447/2148 +f 612/2042 2448/2151 2380/2051 +f 2449/2152 2380/2051 2448/2151 +f 553/1756 2151/1757 2445/2149 +f 2449/2152 2445/2149 2151/1757 +f 1331/2153 345/2145 2450/2154 +f 2443/2147 2450/2154 345/2145 +f 2375/2044 2450/2154 612/2042 +f 2448/2151 612/2042 2450/2154 +f 629/2155 2452/2156 2451/2157 +f 2454/2158 2451/2157 2452/2156 +f 2454/2158 2453/2159 1337/746 +f 348/748 1337/746 2453/2159 +f 2170/2160 557/2161 2457/2162 +f 2455/2163 2457/2162 557/2161 +f 629/2155 2456/2164 2452/2156 +f 2457/2162 2452/2156 2456/2164 +f 2459/2165 2446/2166 2458/2167 +f 627/2168 2458/2167 2446/2166 +f 557/2161 2165/2169 2455/2163 +f 2459/2165 2455/2163 2165/2169 +f 2453/2159 2460/2170 348/748 +f 1343/756 348/748 2460/2170 +f 2458/2167 627/2168 2460/2170 +f 2441/2171 2460/2170 627/2168 +f 631/2172 2462/2173 2461/2174 +f 2464/2175 2461/2174 2462/2173 +f 2464/2175 2463/2176 1349/766 +f 351/768 1349/766 2463/2176 +f 2465/2177 632/2178 2468/2179 +f 2466/2180 2468/2179 632/2178 +f 2467/2181 2468/2179 631/2172 +f 2462/2173 631/2172 2468/2179 +f 633/2182 2470/2183 2469/2184 +f 2472/2185 2469/2184 2470/2183 +f 632/2178 2471/2186 2466/2180 +f 2472/2185 2466/2180 2471/2186 +f 2463/2176 2474/2187 351/768 +f 1356/776 351/768 2474/2187 +f 2473/2188 2474/2187 633/2182 +f 2470/2183 633/2182 2474/2187 +f 2478/2189 2475/2190 2476/2191 +f 635/2192 2476/2191 2475/2190 +f 1365/785 2478/2189 356/786 +f 2477/2193 356/786 2478/2189 +f 566/1810 2479/2194 2199/1817 +f 2481/2195 2199/1817 2479/2194 +f 2476/2191 635/2192 2481/2195 +f 2480/2196 2481/2195 635/2192 +f 631/2172 2482/2197 2467/2181 +f 2483/2198 2467/2181 2482/2197 +f 2193/1811 2483/2198 566/1810 +f 2479/2194 566/1810 2483/2198 +f 356/786 2477/2193 1371/794 +f 2484/2199 1371/794 2477/2193 +f 2482/2197 631/2172 2484/2199 +f 2461/2174 2484/2199 631/2172 +f 637/2200 2486/2201 2485/2202 +f 2488/2203 2485/2202 2486/2201 +f 2488/2203 2487/2204 1377/2205 +f 359/2206 1377/2205 2487/2204 +f 2489/2207 2491/2208 496/1494 +f 1934/1501 496/1494 2491/2208 +f 2490/2209 2491/2208 637/2200 +f 2486/2201 637/2200 2491/2208 +f 2492/2210 2493/2211 623/2111 +f 2426/2121 623/2111 2493/2211 +f 496/1494 1928/1495 2489/2207 +f 2493/2211 2489/2207 1928/1495 +f 2487/2204 2494/2212 359/2206 +f 1383/2213 359/2206 2494/2212 +f 2494/2212 2492/2210 2421/2110 +f 623/2111 2421/2110 2492/2210 +f 2495/2214 2497/2215 621/2105 +f 2419/2109 621/2105 2497/2215 +f 2496/2216 362/2217 2497/2215 +f 1389/2218 2497/2215 362/2217 +f 488/1460 2498/2219 1907/1467 +f 2499/2220 1907/1467 2498/2219 +f 2499/2220 2495/2214 2416/2103 +f 621/2105 2416/2103 2495/2214 +f 2501/2221 2502/2222 639/2223 +f 2500/2224 639/2223 2502/2222 +f 1902/1462 2502/2222 488/1460 +f 2498/2219 488/1460 2502/2222 +f 2504/2225 1395/2226 2496/2216 +f 362/2217 2496/2216 1395/2226 +f 639/2223 2503/2227 2501/2221 +f 2504/2225 2501/2221 2503/2227 +f 2505/2228 2507/2229 639/2223 +f 2503/2227 639/2223 2507/2229 +f 2506/2230 365/2231 2507/2229 +f 1401/2232 2507/2229 365/2231 +f 492/1475 2508/2233 1919/1482 +f 2509/2234 1919/1482 2508/2233 +f 639/2223 2500/2224 2505/2228 +f 2509/2234 2505/2228 2500/2224 +f 2511/2235 2512/2236 641/2237 +f 2510/2238 641/2237 2512/2236 +f 1914/1477 2512/2236 492/1475 +f 2508/2233 492/1475 2512/2236 +f 2514/2239 1407/2240 2506/2230 +f 365/2231 2506/2230 1407/2240 +f 641/2237 2513/2241 2511/2235 +f 2514/2239 2511/2235 2513/2241 +f 2515/2242 2517/2243 641/2237 +f 2513/2241 641/2237 2517/2243 +f 2516/2244 368/2245 2517/2243 +f 1413/2246 2517/2243 368/2245 +f 2519/2247 2149/1751 2518/2248 +f 555/1752 2518/2248 2149/1751 +f 641/2237 2510/2238 2515/2242 +f 2519/2247 2515/2242 2510/2238 +f 2522/2249 2520/2250 2521/2251 +f 643/2252 2521/2251 2520/2250 +f 555/1752 2158/1763 2518/2248 +f 2522/2249 2518/2248 2158/1763 +f 1419/2253 368/2245 2524/2254 +f 2516/2244 2524/2254 368/2245 +f 2521/2251 643/2252 2524/2254 +f 2523/2255 2524/2254 643/2252 +f 643/2256 2525/2257 2523/2258 +f 2527/2259 2523/2258 2525/2257 +f 371/855 1425/857 2526/2260 +f 2527/2259 2526/2260 1425/857 +f 563/1789 2528/2261 2177/1788 +f 2529/2262 2177/1788 2528/2261 +f 2520/2263 2529/2262 643/2256 +f 2525/2257 643/2256 2529/2262 +f 2531/2264 2532/2265 645/2266 +f 2530/2267 645/2266 2532/2265 +f 2186/1800 2532/2265 563/1789 +f 2528/2261 563/1789 2532/2265 +f 1431/866 371/855 2534/2268 +f 2526/2260 2534/2268 371/855 +f 645/2266 2533/2269 2531/2264 +f 2534/2268 2531/2264 2533/2269 +f 2535/2270 2537/2271 645/2266 +f 2533/2269 645/2266 2537/2271 +f 2536/2272 374/874 2537/2271 +f 1437/875 2537/2271 374/874 +f 562/1797 2538/2273 2187/1802 +f 2539/2274 2187/1802 2538/2273 +f 645/2266 2530/2267 2535/2270 +f 2539/2274 2535/2270 2530/2267 +f 2541/2275 2542/2276 647/2277 +f 2540/2278 647/2277 2542/2276 +f 2182/1798 2542/2276 562/1797 +f 2538/2273 562/1797 2542/2276 +f 2544/2279 1443/881 2536/2272 +f 374/874 2536/2272 1443/881 +f 647/2277 2543/2280 2541/2275 +f 2544/2279 2541/2275 2543/2280 +f 2545/2281 2547/2282 647/2277 +f 2543/2280 647/2277 2547/2282 +f 2547/2282 2546/2283 1449/887 +f 377/889 1449/887 2546/2283 +f 2548/2284 2549/2285 567/1815 +f 2201/1819 567/1815 2549/2285 +f 2540/2278 2549/2285 647/2277 +f 2545/2281 647/2277 2549/2285 +f 635/2192 2550/2286 2480/2196 +f 2551/2287 2480/2196 2550/2286 +f 567/1815 2197/1816 2548/2284 +f 2551/2287 2548/2284 2197/1816 +f 2546/2283 2552/2288 377/889 +f 1454/893 377/889 2552/2288 +f 2550/2286 635/2192 2552/2288 +f 2475/2190 2552/2288 635/2192 +f 2555/2289 1461/899 2553/2290 +f 380/900 2553/2290 1461/899 +f 2555/2289 2554/2291 2451/2157 +f 629/2155 2451/2157 2554/2291 +f 2557/2292 2558/2293 650/2294 +f 2556/2295 650/2294 2558/2293 +f 380/900 1470/916 2553/2290 +f 2558/2293 2553/2290 1470/916 +f 604/2296 2559/2297 2338/2298 +f 2561/2299 2338/2298 2559/2297 +f 650/2294 2560/2300 2557/2292 +f 2561/2299 2557/2292 2560/2300 +f 2562/2301 2563/2302 597/2303 +f 2330/2304 597/2303 2563/2302 +f 2348/2305 2563/2302 604/2296 +f 2559/2297 604/2296 2563/2302 +f 2554/2291 2564/2306 629/2155 +f 2456/2164 629/2155 2564/2306 +f 2564/2306 2562/2301 2325/2307 +f 597/2303 2325/2307 2562/2301 +f 2321/1974 599/1975 2567/2308 +f 2565/2309 2567/2308 599/1975 +f 2465/2177 2567/2308 632/2178 +f 2566/2310 632/2178 2567/2308 +f 652/2311 2569/2312 2568/2313 +f 2570/2314 2568/2313 2569/2312 +f 599/1975 2332/1989 2565/2309 +f 2570/2314 2565/2309 2332/1989 +f 2471/2186 632/2178 2572/2315 +f 2566/2310 2572/2315 632/2178 +f 2571/2316 2572/2315 652/2311 +f 2569/2312 652/2311 2572/2315 +f 654/2317 2574/2318 2573/2319 +f 2577/2320 2573/2319 2574/2318 +f 657/2321 2576/2322 2575/2323 +f 2577/2320 2575/2323 2576/2322 +f 2579/2324 2581/2325 655/2326 +f 2578/2327 655/2326 2581/2325 +f 2580/2328 2581/2325 654/2317 +f 2574/2318 654/2317 2581/2325 +f 656/2329 2583/2330 2582/2331 +f 2585/2332 2582/2331 2583/2330 +f 655/2326 2584/2333 2579/2324 +f 2585/2332 2579/2324 2584/2333 +f 2575/2323 2588/2334 657/2321 +f 2586/2335 657/2321 2588/2334 +f 2587/2336 2588/2334 656/2329 +f 2583/2330 656/2329 2588/2334 +f 659/2337 2590/2338 2589/2339 +f 2593/2340 2589/2339 2590/2338 +f 2593/2340 2591/2341 2592/2342 +f 662/2343 2592/2342 2591/2341 +f 660/2344 2595/2345 2594/2346 +f 2597/2347 2594/2346 2595/2345 +f 2590/2338 659/2337 2597/2347 +f 2596/2348 2597/2347 659/2337 +f 2601/2349 2598/2350 2599/2351 +f 661/2352 2599/2351 2598/2350 +f 2595/2345 660/2344 2601/2349 +f 2600/2353 2601/2349 660/2344 +f 2591/2341 2604/2354 662/2343 +f 2602/2355 662/2343 2604/2354 +f 2599/2351 661/2352 2604/2354 +f 2603/2356 2604/2354 661/2352 +f 2606/2357 2609/2358 664/2359 +f 2605/2360 664/2359 2609/2358 +f 2608/2361 2609/2358 667/2362 +f 2607/2363 667/2362 2609/2358 +f 2613/2364 2610/2365 2611/2366 +f 665/2367 2611/2366 2610/2365 +f 664/2359 2612/2368 2606/2357 +f 2613/2364 2606/2357 2612/2368 +f 2615/2369 2617/2370 666/2371 +f 2614/2372 666/2371 2617/2370 +f 2611/2366 665/2367 2617/2370 +f 2616/2373 2617/2370 665/2367 +f 2607/2363 2620/2374 667/2362 +f 2618/2375 667/2362 2620/2374 +f 2620/2374 2615/2369 2619/2376 +f 666/2371 2619/2376 2615/2369 +f 2603/2356 661/2352 2624/2377 +f 2621/2378 2624/2377 661/2352 +f 671/2379 2623/2380 2622/2381 +f 2624/2377 2622/2381 2623/2380 +f 2626/2382 2627/2383 669/2384 +f 2625/2385 669/2384 2627/2383 +f 2621/2378 661/2352 2627/2383 +f 2598/2350 2627/2383 661/2352 +f 670/2386 2629/2387 2628/2388 +f 2631/2389 2628/2388 2629/2387 +f 2631/2389 2626/2382 2630/2390 +f 669/2384 2630/2390 2626/2382 +f 671/2379 2622/2381 2632/2391 +f 2634/2392 2632/2391 2622/2381 +f 2629/2387 670/2386 2634/2392 +f 2633/2393 2634/2392 670/2386 +f 2638/2394 2633/2393 2635/2395 +f 670/2386 2635/2395 2633/2393 +f 674/2396 2637/2397 2636/2398 +f 2638/2394 2636/2398 2637/2397 +f 2641/2399 2639/2400 2640/2401 +f 673/2402 2640/2401 2639/2400 +f 2635/2395 670/2386 2641/2399 +f 2628/2388 2641/2399 670/2386 +f 2619/2376 666/2371 2644/2403 +f 2642/2404 2644/2403 666/2371 +f 2644/2403 2640/2401 2643/2405 +f 673/2402 2643/2405 2640/2401 +f 2646/2406 2645/2407 2636/2398 +f 674/2396 2636/2398 2645/2407 +f 666/2371 2614/2372 2642/2404 +f 2646/2406 2642/2404 2614/2372 +f 676/2408 2648/2409 2647/2410 +f 2650/2411 2647/2410 2648/2409 +f 2589/2339 2650/2411 659/2337 +f 2649/2412 659/2337 2650/2411 +f 2652/2413 2654/2414 677/2415 +f 2651/2416 677/2415 2654/2414 +f 2653/2417 2654/2414 676/2408 +f 2648/2409 676/2408 2654/2414 +f 2612/2368 664/2359 2657/2418 +f 2655/2419 2657/2418 664/2359 +f 677/2415 2656/2420 2652/2413 +f 2657/2418 2652/2413 2656/2420 +f 659/2337 2649/2412 2596/2348 +f 2658/2421 2596/2348 2649/2412 +f 664/2359 2605/2360 2655/2419 +f 2658/2421 2655/2419 2605/2360 +f 2660/2422 2662/2423 679/2424 +f 2659/2425 679/2424 2662/2423 +f 2661/2426 676/2427 2662/2423 +f 2647/2428 2662/2423 676/2427 +f 2663/2429 2665/2430 607/2022 +f 2361/2027 607/2022 2665/2430 +f 2664/2431 2665/2430 679/2424 +f 2660/2422 679/2424 2665/2430 +f 610/2031 2666/2432 2365/2030 +f 2667/2433 2365/2030 2666/2432 +f 607/2022 2357/2023 2663/2429 +f 2667/2433 2663/2429 2357/2023 +f 2669/2434 2670/2435 680/2436 +f 2668/2437 680/2436 2670/2435 +f 2372/2039 2670/2435 610/2031 +f 2666/2432 610/2031 2670/2435 +f 676/2427 2661/2426 2653/2438 +f 2672/2439 2653/2438 2661/2426 +f 680/2436 2671/2440 2669/2434 +f 2672/2439 2669/2434 2671/2440 +f 2656/2441 677/2442 2676/2443 +f 2673/2444 2676/2443 677/2442 +f 2675/2445 2676/2443 682/2446 +f 2674/2447 682/2446 2676/2443 +f 680/2436 2677/2448 2671/2440 +f 2678/2449 2671/2440 2677/2448 +f 677/2442 2651/2450 2673/2444 +f 2678/2449 2673/2444 2651/2450 +f 609/2037 2679/2451 2373/2041 +f 2680/2452 2373/2041 2679/2451 +f 2680/2452 2677/2448 2668/2437 +f 680/2436 2668/2437 2677/2448 +f 2682/2453 2342/2002 2681/2454 +f 601/1992 2681/2454 2342/2002 +f 609/2037 2369/2038 2679/2451 +f 2682/2453 2679/2451 2369/2038 +f 2684/2455 2683/2456 2674/2447 +f 682/2446 2674/2447 2683/2456 +f 2684/2455 2681/2454 2335/1991 +f 601/1992 2335/1991 2681/2454 +f 665/2457 2685/2458 2616/2459 +f 2688/2460 2616/2459 2685/2458 +f 684/2461 2687/2462 2686/2463 +f 2688/2460 2686/2463 2687/2462 +f 2689/2464 2690/2465 682/2466 +f 2675/2467 682/2466 2690/2465 +f 2610/2468 2690/2465 665/2457 +f 2685/2458 665/2457 2690/2465 +f 650/2294 2691/2469 2560/2300 +f 2692/2470 2560/2300 2691/2469 +f 2692/2470 2689/2464 2683/2471 +f 682/2466 2683/2471 2689/2464 +f 2693/2472 2694/2473 415/1075 +f 1602/1082 415/1075 2694/2473 +f 2556/2295 2694/2473 650/2294 +f 2691/2469 650/2294 2694/2473 +f 2686/2463 2696/2474 684/2461 +f 2695/2475 684/2461 2696/2474 +f 415/1075 1597/1077 2693/2472 +f 2696/2474 2693/2472 1597/1077 +f 2697/2476 2700/2477 419/1095 +f 1610/1096 419/1095 2700/2477 +f 2699/2478 2700/2477 687/2479 +f 2698/2480 687/2479 2700/2477 +f 633/2182 2701/2481 2473/2188 +f 2702/2482 2473/2188 2701/2481 +f 419/1095 1621/1110 2697/2476 +f 2702/2482 2697/2476 1621/1110 +f 2704/2483 2705/2484 686/2485 +f 2703/2486 686/2485 2705/2484 +f 2469/2184 2705/2484 633/2182 +f 2701/2481 633/2182 2705/2484 +f 2706/2487 2708/2488 671/2489 +f 2623/2490 671/2489 2708/2488 +f 686/2485 2707/2491 2704/2483 +f 2708/2488 2704/2483 2707/2491 +f 2710/2492 2709/2493 2698/2480 +f 687/2479 2698/2480 2709/2493 +f 2706/2487 671/2489 2710/2492 +f 2632/2494 2710/2492 671/2489 +f 1625/1114 421/1115 2713/2495 +f 2711/2496 2713/2495 421/1115 +f 684/2461 2695/2475 2712/2497 +f 2713/2495 2712/2497 2695/2475 +f 687/2498 2714/2499 2699/2500 +f 2715/2501 2699/2500 2714/2499 +f 2715/2501 2711/2496 1631/1127 +f 421/1115 1631/1127 2711/2496 +f 2716/2502 2717/2503 674/2504 +f 2637/2505 674/2504 2717/2503 +f 2714/2499 687/2498 2717/2503 +f 2709/2506 2717/2503 687/2498 +f 2712/2497 2718/2507 684/2461 +f 2687/2462 684/2461 2718/2507 +f 2645/2508 2718/2507 674/2504 +f 2716/2502 674/2504 2718/2507 +f 652/2311 2719/2509 2571/2316 +f 2721/2510 2571/2316 2719/2509 +f 686/2485 2703/2486 2720/2511 +f 2721/2510 2720/2511 2703/2486 +f 2664/2512 679/2513 2723/2514 +f 2722/2515 2723/2514 679/2513 +f 2568/2313 2723/2514 652/2311 +f 2719/2509 652/2311 2723/2514 +f 2724/2516 2725/2517 662/2518 +f 2592/2519 662/2518 2725/2517 +f 2659/2520 2725/2517 679/2513 +f 2722/2515 679/2513 2725/2517 +f 2720/2511 2726/2521 686/2485 +f 2707/2491 686/2485 2726/2521 +f 662/2518 2602/2522 2724/2516 +f 2726/2521 2724/2516 2602/2522 +f 660/2344 2727/2523 2600/2353 +f 2730/2524 2600/2353 2727/2523 +f 2730/2524 2728/2525 2729/2526 +f 692/2527 2729/2526 2728/2525 +f 2731/2528 691/2529 2733/2530 +f 2732/2531 2733/2530 691/2529 +f 2594/2346 2733/2530 660/2344 +f 2727/2523 660/2344 2733/2530 +f 657/2321 2734/2532 2576/2322 +f 2736/2533 2576/2322 2734/2532 +f 691/2529 2735/2534 2732/2531 +f 2736/2533 2732/2531 2735/2534 +f 692/2527 2728/2525 2737/2535 +f 2738/2536 2737/2535 2728/2525 +f 657/2321 2586/2335 2734/2532 +f 2738/2536 2734/2532 2586/2335 +f 2739/2537 2742/2538 669/2384 +f 2630/2390 669/2384 2742/2538 +f 2741/2539 2742/2538 694/2540 +f 2740/2541 694/2540 2742/2538 +f 2729/2526 692/2527 2744/2542 +f 2743/2543 2744/2542 692/2527 +f 669/2384 2625/2385 2739/2537 +f 2744/2542 2739/2537 2625/2385 +f 656/2329 2745/2544 2587/2336 +f 2746/2545 2587/2336 2745/2544 +f 692/2527 2737/2535 2743/2543 +f 2746/2545 2743/2543 2737/2535 +f 694/2540 2740/2541 2747/2546 +f 2748/2547 2747/2546 2740/2541 +f 656/2329 2582/2331 2745/2544 +f 2748/2547 2745/2544 2582/2331 +f 673/2402 2749/2548 2643/2405 +f 2752/2549 2643/2405 2749/2548 +f 2752/2549 2750/2550 2751/2551 +f 696/2552 2751/2551 2750/2550 +f 2754/2553 2741/2539 2753/2554 +f 694/2540 2753/2554 2741/2539 +f 2639/2400 2754/2553 673/2402 +f 2749/2548 673/2402 2754/2553 +f 2755/2555 2756/2556 655/2326 +f 2584/2333 655/2326 2756/2556 +f 2753/2554 694/2540 2756/2556 +f 2747/2546 2756/2556 694/2540 +f 696/2552 2750/2550 2757/2557 +f 2758/2558 2757/2557 2750/2550 +f 655/2326 2578/2327 2755/2555 +f 2758/2558 2755/2555 2578/2327 +f 2759/2559 2761/2560 667/2362 +f 2608/2361 667/2362 2761/2560 +f 2731/2528 2761/2560 691/2529 +f 2760/2561 691/2529 2761/2560 +f 2763/2562 2751/2551 2762/2563 +f 696/2552 2762/2563 2751/2551 +f 667/2362 2618/2375 2759/2559 +f 2763/2562 2759/2559 2618/2375 +f 654/2317 2764/2564 2580/2328 +f 2765/2565 2580/2328 2764/2564 +f 696/2552 2757/2557 2762/2563 +f 2765/2565 2762/2563 2757/2557 +f 691/2529 2760/2561 2735/2534 +f 2766/2566 2735/2534 2760/2561 +f 654/2317 2573/2319 2764/2564 +f 2766/2566 2764/2564 2573/2319 +f 2767/2567 699/2568 2770/2569 +f 2768/2570 2770/2569 699/2568 +f 2769/2571 482/2572 2770/2569 +f 1883/2573 2770/2569 482/2572 +f 2774/2574 2771/2575 2772/2576 +f 700/2577 2772/2576 2771/2575 +f 699/2568 2773/2578 2768/2570 +f 2774/2574 2768/2570 2773/2578 +f 2778/2579 2775/2580 2776/2581 +f 701/2582 2776/2581 2775/2580 +f 2772/2576 700/2577 2778/2579 +f 2777/2583 2778/2579 700/2577 +f 2780/2584 1888/2585 2769/2571 +f 482/2572 2769/2571 1888/2585 +f 2776/2581 701/2582 2780/2584 +f 2779/2586 2780/2584 701/2582 +f 701/2582 2781/2587 2779/2586 +f 2783/2588 2779/2586 2781/2587 +f 624/2589 2428/2590 2782/2591 +f 2783/2588 2782/2591 2428/2590 +f 2785/2592 2786/2593 703/2594 +f 2784/2595 703/2594 2786/2593 +f 2775/2580 2786/2593 701/2582 +f 2781/2587 701/2582 2786/2593 +f 436/1214 2787/2596 1703/1221 +f 2789/2597 1703/1221 2787/2596 +f 703/2594 2788/2598 2785/2592 +f 2789/2597 2785/2592 2788/2598 +f 2782/2591 2790/2599 624/2589 +f 2431/2600 624/2589 2790/2599 +f 1698/1215 2790/2599 436/1214 +f 2787/2596 436/1214 2790/2599 +f 2791/2601 2793/2602 441/1229 +f 1709/1228 441/1229 2793/2602 +f 2409/2603 2793/2602 620/2604 +f 2792/2605 620/2604 2793/2602 +f 705/2606 2795/2607 2794/2608 +f 2796/2609 2794/2608 2795/2607 +f 441/1229 1718/1241 2791/2601 +f 2796/2609 2791/2601 1718/1241 +f 2797/2610 706/2611 2800/2612 +f 2798/2613 2800/2612 706/2611 +f 2799/2614 2800/2612 705/2606 +f 2795/2607 705/2606 2800/2612 +f 620/2604 2792/2605 2414/2615 +f 2802/2616 2414/2615 2792/2605 +f 706/2611 2801/2617 2798/2613 +f 2802/2616 2798/2613 2801/2617 +f 2803/2618 2805/2619 706/2611 +f 2801/2617 706/2611 2805/2619 +f 2805/2619 2804/2620 1872/2621 +f 479/2622 1872/2621 2804/2620 +f 2807/2623 2808/2624 708/2625 +f 2806/2626 708/2625 2808/2624 +f 2808/2624 2803/2618 2797/2610 +f 706/2611 2797/2610 2803/2618 +f 699/2568 2809/2627 2773/2578 +f 2811/2628 2773/2578 2809/2627 +f 2811/2628 2807/2623 2810/2629 +f 708/2625 2810/2629 2807/2623 +f 2804/2620 2812/2630 479/2622 +f 1877/2631 479/2622 2812/2630 +f 2812/2630 2809/2627 2767/2567 +f 699/2568 2767/2567 2809/2627 +f 2813/2632 2815/2633 703/2594 +f 2788/2598 703/2594 2815/2633 +f 445/1258 1731/1260 2814/2634 +f 2815/2633 2814/2634 1731/1260 +f 700/2577 2816/2635 2777/2583 +f 2817/2636 2777/2583 2816/2635 +f 703/2594 2784/2595 2813/2632 +f 2817/2636 2813/2632 2784/2595 +f 2819/2637 2820/2638 710/2639 +f 2818/2640 710/2639 2820/2638 +f 2771/2575 2820/2638 700/2577 +f 2816/2635 700/2577 2820/2638 +f 2822/2641 1737/1267 2814/2634 +f 445/1258 2814/2634 1737/1267 +f 710/2639 2821/2642 2819/2637 +f 2822/2641 2819/2637 2821/2642 +f 710/2639 2823/2643 2821/2642 +f 2825/2644 2821/2642 2823/2643 +f 1743/1273 2825/2644 448/1275 +f 2824/2645 448/1275 2825/2644 +f 2826/2646 2827/2647 708/2625 +f 2810/2629 708/2625 2827/2647 +f 2818/2640 2827/2647 710/2639 +f 2823/2643 710/2639 2827/2647 +f 705/2606 2828/2648 2799/2614 +f 2829/2649 2799/2614 2828/2648 +f 708/2625 2806/2626 2826/2646 +f 2829/2649 2826/2646 2806/2626 +f 2824/2645 2830/2650 448/1275 +f 1748/1279 448/1275 2830/2650 +f 2794/2608 2830/2650 705/2606 +f 2828/2648 705/2606 2830/2650 +f 2832/2651 2835/2652 713/2653 +f 2831/2654 713/2653 2835/2652 +f 2834/2655 2835/2652 715/2656 +f 2833/2657 715/2656 2835/2652 +f 2836/2658 714/2659 2839/2660 +f 2837/2661 2839/2660 714/2659 +f 713/2653 2838/2662 2832/2651 +f 2839/2660 2832/2651 2838/2662 +f 715/2656 2833/2657 2840/2663 +f 2842/2664 2840/2663 2833/2657 +f 714/2659 2841/2665 2837/2661 +f 2842/2664 2837/2661 2841/2665 +f 2844/2666 2846/2667 717/2668 +f 2843/2669 717/2668 2846/2667 +f 713/2653 2831/2654 2845/2670 +f 2846/2667 2845/2670 2831/2654 +f 519/1586 2847/2671 2006/1585 +f 2849/2672 2006/1585 2847/2671 +f 2849/2672 2844/2666 2848/2673 +f 717/2668 2848/2673 2844/2666 +f 2850/2674 2851/2675 497/1499 +f 1937/1504 497/1499 2851/2675 +f 2015/1596 2851/2675 519/1586 +f 2847/2671 519/1586 2851/2675 +f 718/2676 2853/2677 2852/2678 +f 2854/2679 2852/2678 2853/2677 +f 497/1499 1932/1500 2850/2674 +f 2854/2679 2850/2674 1932/1500 +f 2845/2670 2856/2680 713/2653 +f 2838/2662 713/2653 2856/2680 +f 2855/2681 2856/2680 718/2676 +f 2853/2677 718/2676 2856/2680 +f 715/2656 2857/2682 2834/2655 +f 2859/2683 2834/2655 2857/2682 +f 717/2668 2843/2669 2858/2684 +f 2859/2683 2858/2684 2843/2669 +f 2861/2685 2862/2686 720/2687 +f 2860/2688 720/2687 2862/2686 +f 2840/2663 2862/2686 715/2656 +f 2857/2682 715/2656 2862/2686 +f 2863/2689 2865/2690 534/1657 +f 2074/1668 534/1657 2865/2690 +f 2864/2691 2865/2690 720/2687 +f 2861/2685 720/2687 2865/2690 +f 545/1713 2866/2692 2115/1716 +f 2867/2693 2115/1716 2866/2692 +f 2863/2689 534/1657 2867/2693 +f 2067/1659 2867/2693 534/1657 +f 2858/2684 2868/2694 717/2668 +f 2848/2673 717/2668 2868/2694 +f 2111/1711 2868/2694 545/1713 +f 2866/2692 545/1713 2868/2694 +f 2869/2695 2872/2696 460/2697 +f 1794/2698 460/2697 2872/2696 +f 2871/2699 2872/2696 722/2700 +f 2870/2701 722/2700 2872/2696 +f 618/2083 2873/2702 2407/2089 +f 2874/2703 2407/2089 2873/2702 +f 2874/2703 2869/2695 1801/2704 +f 460/2697 1801/2704 2869/2695 +f 2864/2691 720/2687 2876/2705 +f 2875/2706 2876/2705 720/2687 +f 2404/2085 2876/2705 618/2083 +f 2873/2702 618/2083 2876/2705 +f 722/2700 2870/2701 2877/2707 +f 2878/2708 2877/2707 2870/2701 +f 720/2687 2860/2688 2875/2706 +f 2878/2708 2875/2706 2860/2688 +f 463/2709 2879/2710 1805/2711 +f 2881/2712 1805/2711 2879/2710 +f 637/2200 2485/2202 2880/2713 +f 2881/2712 2880/2713 2485/2202 +f 2883/2714 2884/2715 724/2716 +f 2882/2717 724/2716 2884/2715 +f 1812/2718 2884/2715 463/2709 +f 2879/2710 463/2709 2884/2715 +f 718/2676 2885/2719 2855/2681 +f 2887/2720 2855/2681 2885/2719 +f 724/2716 2886/2721 2883/2714 +f 2887/2720 2883/2714 2886/2721 +f 2880/2713 2888/2722 637/2200 +f 2490/2209 637/2200 2888/2722 +f 2852/2678 2888/2722 718/2676 +f 2885/2719 718/2676 2888/2722 +f 726/2723 2890/2724 2889/2725 +f 2892/2726 2889/2725 2890/2724 +f 714/2659 2836/2658 2891/2727 +f 2892/2726 2891/2727 2836/2658 +f 2894/2728 2896/2729 727/2730 +f 2893/2731 727/2730 2896/2729 +f 2895/2732 2896/2729 726/2723 +f 2890/2724 726/2723 2896/2729 +f 2898/2733 2900/2734 728/2735 +f 2897/2736 728/2735 2900/2734 +f 2894/2728 727/2730 2900/2734 +f 2899/2737 2900/2734 727/2730 +f 2841/2665 714/2659 2902/2738 +f 2891/2727 2902/2738 714/2659 +f 2902/2738 2898/2733 2901/2739 +f 728/2735 2901/2739 2898/2733 +f 2901/2739 728/2735 2905/2740 +f 2903/2741 2905/2740 728/2735 +f 2877/2707 2905/2740 722/2700 +f 2904/2742 722/2700 2905/2740 +f 730/2743 2907/2744 2906/2745 +f 2908/2746 2906/2745 2907/2744 +f 728/2735 2897/2736 2903/2741 +f 2908/2746 2903/2741 2897/2736 +f 2909/2747 2911/2748 469/2749 +f 1837/2750 469/2749 2911/2748 +f 2910/2751 2911/2748 730/2743 +f 2907/2744 730/2743 2911/2748 +f 722/2700 2904/2742 2871/2699 +f 2912/2752 2871/2699 2904/2742 +f 469/2749 1832/2753 2909/2747 +f 2912/2752 2909/2747 1832/2753 +f 473/2754 2913/2755 1843/2756 +f 2915/2757 1843/2756 2913/2755 +f 2915/2757 2914/2758 2882/2717 +f 724/2716 2882/2717 2914/2758 +f 2917/2759 2918/2760 732/2761 +f 2916/2762 732/2761 2918/2760 +f 1850/2763 2918/2760 473/2754 +f 2913/2755 473/2754 2918/2760 +f 2921/2764 2895/2732 2919/2765 +f 726/2723 2919/2765 2895/2732 +f 732/2761 2920/2766 2917/2759 +f 2921/2764 2917/2759 2920/2766 +f 2914/2758 2922/2767 724/2716 +f 2886/2721 724/2716 2922/2767 +f 2919/2765 726/2723 2922/2767 +f 2889/2725 2922/2767 726/2723 +f 2923/2768 2925/2769 727/2730 +f 2899/2737 727/2730 2925/2769 +f 2906/2745 2925/2769 730/2743 +f 2924/2770 730/2743 2925/2769 +f 2926/2771 2927/2772 732/2761 +f 2920/2766 732/2761 2927/2772 +f 2923/2768 727/2730 2927/2772 +f 2893/2731 2927/2772 727/2730 +f 475/2773 2928/2774 1860/2775 +f 2929/2776 1860/2775 2928/2774 +f 732/2761 2916/2762 2926/2771 +f 2929/2776 2926/2771 2916/2762 +f 730/2743 2924/2770 2910/2751 +f 2930/2777 2910/2751 2924/2770 +f 2930/2777 2928/2774 1856/2778 +f 475/2773 1856/2778 2928/2774 +f 738/6 6/2779 739/1 +f 735/2 739/1 6/2779 +f 193/2780 737/7 736/3 +f 739/1 736/3 737/7 +f 743/11 742/12 740/10 +f 14/2781 740/10 742/12 +f 741/9 193/2780 743/11 +f 736/3 743/11 193/2780 +f 747/14 746/17 744/16 +f 10/2782 744/16 746/17 +f 193/2780 741/9 745/13 +f 747/14 745/13 741/9 +f 16/2783 748/18 749/20 +f 750/19 749/20 748/18 +f 745/13 750/19 193/2780 +f 737/7 193/2780 750/19 +f 754/22 735/2 751/24 +f 6/2779 751/24 735/2 +f 197/2784 753/25 752/21 +f 754/22 752/21 753/25 +f 18/2785 755/28 757/30 +f 758/29 757/30 755/28 +f 752/21 758/29 197/2784 +f 756/27 197/2784 758/29 +f 762/33 761/35 759/31 +f 13/2786 759/31 761/35 +f 197/2784 756/27 760/34 +f 762/33 760/34 756/27 +f 763/37 14/2781 764/36 +f 742/12 764/36 14/2781 +f 760/34 764/36 197/2784 +f 753/25 197/2784 764/36 +f 1/2787 765/39 768/42 +f 769/38 768/42 765/39 +f 767/44 769/38 202/2788 +f 766/40 202/2788 769/38 +f 12/2789 770/48 772/49 +f 773/46 772/49 770/48 +f 202/2788 766/40 771/45 +f 773/46 771/45 766/40 +f 774/52 777/53 11/2790 +f 776/54 11/2790 777/53 +f 771/45 777/53 202/2788 +f 775/51 202/2788 777/53 +f 24/2791 778/55 779/57 +f 780/56 779/57 778/55 +f 202/2788 775/51 767/44 +f 780/56 767/44 775/51 +f 7/2792 781/61 784/62 +f 785/59 784/62 781/61 +f 206/2793 783/64 782/58 +f 785/59 782/58 783/64 +f 779/57 788/66 24/2791 +f 787/67 24/2791 788/66 +f 782/58 788/66 206/2793 +f 786/65 206/2793 788/66 +f 11/2790 789/71 774/52 +f 791/69 774/52 789/71 +f 206/2793 786/65 790/68 +f 791/69 790/68 786/65 +f 792/72 794/73 23/2794 +f 793/74 23/2794 794/73 +f 790/68 794/73 206/2793 +f 783/64 206/2793 794/73 +f 2/2795 795/78 798/80 +f 799/76 798/80 795/78 +f 211/2796 797/81 796/75 +f 799/76 796/75 797/81 +f 800/84 803/85 27/2797 +f 802/86 27/2797 803/85 +f 796/75 803/85 211/2796 +f 801/83 211/2796 803/85 +f 804/89 807/90 19/2798 +f 806/91 19/2798 807/90 +f 211/2796 801/83 805/88 +f 807/90 805/88 801/83 +f 20/2799 808/93 809/94 +f 810/92 809/94 808/93 +f 810/92 797/81 805/88 +f 211/2796 805/88 797/81 +f 768/42 814/96 1/2787 +f 813/98 1/2787 814/96 +f 812/99 814/96 215/2800 +f 811/95 215/2800 814/96 +f 24/2791 815/103 778/55 +f 817/101 778/55 815/103 +f 215/2800 811/95 816/100 +f 817/101 816/100 811/95 +f 818/106 821/107 15/2801 +f 820/108 15/2801 821/107 +f 816/100 821/107 215/2800 +f 819/105 215/2800 821/107 +f 16/2783 822/110 823/111 +f 824/109 823/111 822/110 +f 215/2800 819/105 812/99 +f 824/109 812/99 819/105 +f 828/113 827/114 738/6 +f 6/2779 738/6 827/114 +f 218/2802 826/116 825/112 +f 828/113 825/112 826/116 +f 16/2783 823/111 748/18 +f 830/118 748/18 823/111 +f 825/112 830/118 218/2802 +f 829/117 218/2802 830/118 +f 15/2801 831/122 818/106 +f 833/120 818/106 831/122 +f 218/2802 829/117 832/119 +f 833/120 832/119 829/117 +f 834/123 836/124 32/2803 +f 835/125 32/2803 836/124 +f 832/119 836/124 218/2802 +f 826/116 218/2802 836/124 +f 841/129 840/132 837/128 +f 5/2804 837/128 840/132 +f 838/127 222/2805 841/129 +f 839/130 841/129 222/2805 +f 32/2803 835/125 843/135 +f 844/134 843/135 835/125 +f 844/134 842/133 838/127 +f 222/2805 838/127 842/133 +f 831/122 15/2801 847/136 +f 845/137 847/136 15/2801 +f 842/133 847/136 222/2805 +f 846/138 222/2805 847/136 +f 849/142 30/2806 850/140 +f 848/141 850/140 30/2806 +f 222/2805 846/138 839/130 +f 850/140 839/130 846/138 +f 851/145 854/146 7/2792 +f 781/61 7/2792 854/146 +f 853/147 854/146 224/2807 +f 852/144 224/2807 854/146 +f 857/149 856/150 849/142 +f 30/2806 849/142 856/150 +f 855/148 224/2807 857/149 +f 852/144 857/149 224/2807 +f 15/2801 820/108 845/137 +f 859/151 845/137 820/108 +f 859/151 858/152 855/148 +f 224/2807 855/148 858/152 +f 24/2791 787/67 815/103 +f 860/153 815/103 787/67 +f 858/152 860/153 224/2807 +f 853/147 224/2807 860/153 +f 861/156 864/157 2/2795 +f 795/78 2/2795 864/157 +f 863/158 864/157 228/2808 +f 862/155 228/2808 864/157 +f 18/2785 865/162 867/163 +f 868/160 867/163 865/162 +f 228/2808 862/155 866/159 +f 868/160 866/159 862/155 +f 869/166 872/167 17/2809 +f 871/168 17/2809 872/167 +f 866/159 872/167 228/2808 +f 870/165 228/2808 872/167 +f 27/2797 802/86 873/170 +f 874/169 873/170 802/86 +f 228/2808 870/165 863/158 +f 874/169 863/158 870/165 +f 879/172 878/177 875/174 +f 8/2810 875/174 878/177 +f 232/2811 877/175 876/171 +f 879/172 876/171 877/175 +f 873/170 882/179 27/2797 +f 881/180 27/2797 882/179 +f 876/171 882/179 232/2811 +f 880/178 232/2811 882/179 +f 17/2809 883/184 869/166 +f 885/182 869/166 883/184 +f 232/2811 880/178 884/181 +f 885/182 884/181 880/178 +f 887/187 29/2812 888/185 +f 886/186 888/185 29/2812 +f 884/181 888/185 232/2811 +f 877/175 232/2811 888/185 +f 837/128 5/2804 892/188 +f 889/189 892/188 5/2804 +f 891/192 892/188 235/2813 +f 890/190 235/2813 892/188 +f 29/2812 887/187 894/195 +f 895/194 894/195 887/187 +f 235/2813 890/190 893/193 +f 895/194 893/193 890/190 +f 896/198 898/199 17/2809 +f 883/184 17/2809 898/199 +f 893/193 898/199 235/2813 +f 897/197 235/2813 898/199 +f 899/201 32/2803 900/200 +f 843/135 900/200 32/2803 +f 235/2813 897/197 891/192 +f 900/200 891/192 897/197 +f 751/24 6/2779 903/203 +f 827/114 903/203 6/2779 +f 236/2814 902/204 901/202 +f 903/203 901/202 902/204 +f 32/2803 899/201 834/123 +f 905/206 834/123 899/201 +f 901/202 905/206 236/2814 +f 904/205 236/2814 905/206 +f 17/2809 871/168 896/198 +f 907/208 896/198 871/168 +f 236/2814 904/205 906/207 +f 907/208 906/207 904/205 +f 18/2785 757/30 865/162 +f 908/209 865/162 757/30 +f 906/207 908/209 236/2814 +f 902/204 236/2814 908/209 +f 913/211 912/214 909/213 +f 3/2815 909/213 912/214 +f 241/2816 911/216 910/210 +f 913/211 910/210 911/216 +f 22/2817 914/219 916/221 +f 917/220 916/221 914/219 +f 915/218 241/2816 917/220 +f 910/210 917/220 241/2816 +f 21/2818 918/222 920/226 +f 921/224 920/226 918/222 +f 921/224 919/225 915/218 +f 241/2816 915/218 919/225 +f 31/2819 922/227 923/229 +f 924/228 923/229 922/227 +f 919/225 924/228 241/2816 +f 911/216 241/2816 924/228 +f 925/233 929/231 9/2820 +f 928/235 9/2820 929/231 +f 245/2821 927/234 926/230 +f 929/231 926/230 927/234 +f 923/229 932/238 31/2819 +f 931/239 31/2819 932/238 +f 926/230 932/238 245/2821 +f 930/237 245/2821 932/238 +f 21/2818 933/243 918/222 +f 935/241 918/222 933/243 +f 245/2821 930/237 934/240 +f 935/241 934/240 930/237 +f 938/244 937/246 936/245 +f 33/2822 936/245 937/246 +f 934/240 938/244 245/2821 +f 927/234 245/2821 938/244 +f 939/249 943/250 4/2823 +f 942/252 4/2823 943/250 +f 941/253 943/250 250/2824 +f 940/248 250/2824 943/250 +f 28/2825 944/257 946/258 +f 947/255 946/258 944/257 +f 250/2824 940/248 945/254 +f 947/255 945/254 940/248 +f 948/260 951/259 25/2826 +f 950/263 25/2826 951/259 +f 945/254 951/259 250/2824 +f 949/261 250/2824 951/259 +f 26/2827 952/264 953/266 +f 954/265 953/266 952/264 +f 954/265 941/253 949/261 +f 250/2824 949/261 941/253 +f 9/2820 928/235 957/269 +f 958/268 957/269 928/235 +f 253/2828 956/271 955/267 +f 958/268 955/267 956/271 +f 959/274 961/275 33/2822 +f 936/245 33/2822 961/275 +f 955/267 961/275 253/2828 +f 960/273 253/2828 961/275 +f 25/2826 950/263 963/278 +f 964/277 963/278 950/263 +f 253/2828 960/273 962/276 +f 964/277 962/276 960/273 +f 965/279 966/280 28/2825 +f 944/257 28/2825 966/280 +f 962/276 966/280 253/2828 +f 956/271 253/2828 966/280 +f 840/132 970/282 5/2804 +f 969/284 5/2804 970/282 +f 968/285 970/282 256/2829 +f 967/281 256/2829 970/282 +f 30/2806 971/289 848/141 +f 973/287 848/141 971/289 +f 256/2829 967/281 972/286 +f 973/287 972/286 967/281 +f 975/292 31/2819 976/290 +f 931/239 976/290 31/2819 +f 972/286 976/290 256/2829 +f 974/291 256/2829 976/290 +f 9/2820 977/294 925/233 +f 978/293 925/233 977/294 +f 256/2829 974/291 968/285 +f 978/293 968/285 974/291 +f 29/2812 979/298 886/186 +f 982/296 886/186 979/298 +f 982/296 980/295 981/299 +f 259/2830 981/299 980/295 +f 946/258 985/300 28/2825 +f 984/302 28/2825 985/300 +f 980/295 985/300 259/2830 +f 983/301 259/2830 985/300 +f 986/305 988/306 4/2823 +f 939/249 4/2823 988/306 +f 259/2830 983/301 987/304 +f 988/306 987/304 983/301 +f 878/177 990/307 8/2810 +f 989/308 8/2810 990/307 +f 981/299 259/2830 990/307 +f 987/304 990/307 259/2830 +f 23/2794 991/309 792/72 +f 994/311 792/72 991/309 +f 994/311 992/312 993/313 +f 262/2831 993/313 992/312 +f 22/2817 916/221 996/316 +f 997/314 996/316 916/221 +f 992/312 997/314 262/2831 +f 995/315 262/2831 997/314 +f 998/320 1000/318 3/2815 +f 909/213 3/2815 1000/318 +f 262/2831 995/315 999/317 +f 1000/318 999/317 995/315 +f 784/62 1002/321 7/2792 +f 1001/322 7/2792 1002/321 +f 993/313 262/2831 1002/321 +f 999/317 1002/321 262/2831 +f 28/2825 984/302 965/279 +f 1005/324 965/279 984/302 +f 263/2832 1004/325 1003/323 +f 1005/324 1003/323 1004/325 +f 894/195 1007/327 29/2812 +f 979/298 29/2812 1007/327 +f 1003/323 1007/327 263/2832 +f 1006/326 263/2832 1007/327 +f 5/2804 969/284 889/189 +f 1009/329 889/189 969/284 +f 263/2832 1006/326 1008/328 +f 1009/329 1008/328 1006/326 +f 957/269 1010/330 9/2820 +f 977/294 9/2820 1010/330 +f 1008/328 1010/330 263/2832 +f 1004/325 263/2832 1010/330 +f 856/150 1013/332 30/2806 +f 971/289 30/2806 1013/332 +f 1012/333 1013/332 264/2833 +f 1011/331 264/2833 1013/332 +f 7/2792 1001/322 851/145 +f 1015/335 851/145 1001/322 +f 264/2833 1011/331 1014/334 +f 1015/335 1014/334 1011/331 +f 912/214 1017/337 3/2815 +f 998/320 3/2815 1017/337 +f 1014/334 1017/337 264/2833 +f 1016/336 264/2833 1017/337 +f 31/2819 975/292 922/227 +f 1018/338 922/227 975/292 +f 264/2833 1016/336 1012/333 +f 1018/338 1012/333 1016/336 +f 23/2794 1019/339 991/309 +f 1022/341 991/309 1019/339 +f 1020/342 268/2834 1022/341 +f 1021/343 1022/341 268/2834 +f 35/2835 1023/344 1025/348 +f 1026/346 1025/348 1023/344 +f 1026/346 1024/347 1020/342 +f 268/2834 1020/342 1024/347 +f 1029/353 34/2836 1030/349 +f 1027/350 1030/349 34/2836 +f 1024/347 1030/349 268/2834 +f 1028/351 268/2834 1030/349 +f 1032/354 1031/355 996/316 +f 22/2817 996/316 1031/355 +f 268/2834 1028/351 1021/343 +f 1032/354 1021/343 1028/351 +f 1033/358 1036/359 35/2837 +f 1023/361 35/2837 1036/359 +f 1035/360 1036/359 272/2838 +f 1034/357 272/2838 1036/359 +f 37/2839 1037/366 1039/367 +f 1040/364 1039/367 1037/366 +f 272/2838 1034/357 1038/363 +f 1040/364 1038/363 1034/357 +f 1043/372 36/2840 1044/368 +f 1041/369 1044/368 36/2840 +f 1038/363 1044/368 272/2838 +f 1042/370 272/2838 1044/368 +f 1046/373 1045/375 1029/374 +f 34/2841 1029/374 1045/375 +f 272/2838 1042/370 1035/360 +f 1046/373 1035/360 1042/370 +f 35/2837 1047/379 1033/358 +f 1050/377 1033/358 1047/379 +f 276/2842 1049/380 1048/376 +f 1050/377 1048/376 1049/380 +f 1051/383 1054/384 40/2843 +f 1053/385 40/2843 1054/384 +f 1048/376 1054/384 276/2842 +f 1052/382 276/2842 1054/384 +f 41/2844 1055/389 1057/390 +f 1058/387 1057/390 1055/389 +f 276/2842 1052/382 1056/386 +f 1058/387 1056/386 1052/382 +f 1039/367 1060/391 37/2839 +f 1059/392 37/2839 1060/391 +f 1056/386 1060/391 276/2842 +f 1049/380 276/2842 1060/391 +f 37/2839 1059/392 1063/395 +f 1064/394 1063/395 1059/392 +f 280/2845 1062/397 1061/393 +f 1064/394 1061/393 1062/397 +f 1065/400 1067/401 41/2844 +f 1055/389 41/2844 1067/401 +f 1061/393 1067/401 280/2845 +f 1066/399 280/2845 1067/401 +f 1071/405 1070/406 1068/404 +f 42/2846 1068/404 1070/406 +f 280/2845 1066/399 1069/403 +f 1071/405 1069/403 1066/399 +f 38/2847 1072/407 1073/409 +f 1074/408 1073/409 1072/407 +f 1074/408 1062/397 1069/403 +f 280/2845 1069/403 1062/397 +f 1079/411 1078/416 1075/413 +f 43/2848 1075/413 1078/416 +f 285/2849 1077/414 1076/410 +f 1079/411 1076/410 1077/414 +f 1080/420 1083/418 48/2850 +f 1082/421 48/2850 1083/418 +f 285/2849 1076/410 1081/417 +f 1083/418 1081/417 1076/410 +f 1084/424 1087/425 45/2851 +f 1086/426 45/2851 1087/425 +f 285/2849 1081/417 1085/423 +f 1087/425 1085/423 1081/417 +f 1088/427 1090/428 46/2852 +f 1089/429 46/2852 1090/428 +f 285/2849 1085/423 1077/414 +f 1090/428 1077/414 1085/423 +f 1091/433 1095/431 44/2853 +f 1094/435 44/2853 1095/431 +f 290/2854 1093/434 1092/430 +f 1095/431 1092/430 1093/434 +f 1099/438 1098/441 1096/440 +f 50/2855 1096/440 1098/441 +f 290/2854 1092/430 1097/437 +f 1099/438 1097/437 1092/430 +f 1100/444 1103/445 47/2856 +f 1102/446 47/2856 1103/445 +f 1097/437 1103/445 290/2854 +f 1101/443 290/2854 1103/445 +f 1104/447 1106/448 49/2857 +f 1105/449 49/2857 1106/448 +f 290/2854 1101/443 1093/434 +f 1106/448 1093/434 1101/443 +f 18/2858 867/452 1109/455 +f 1110/453 1109/455 867/452 +f 1107/451 293/2859 1110/453 +f 1108/456 1110/453 293/2859 +f 1113/458 861/461 1111/460 +f 2/2860 1111/460 861/461 +f 293/2859 1107/451 1112/457 +f 1113/458 1112/457 1107/451 +f 1094/435 1116/463 44/2853 +f 1115/464 44/2853 1116/463 +f 1112/457 1116/463 293/2859 +f 1114/462 293/2859 1116/463 +f 1117/466 1118/465 49/2857 +f 1104/447 49/2857 1118/465 +f 293/2859 1114/462 1108/456 +f 1118/465 1108/456 1114/462 +f 20/2861 1119/470 1122/471 +f 1123/468 1122/471 1119/470 +f 297/2862 1121/473 1120/467 +f 1123/468 1120/467 1121/473 +f 13/2863 1124/475 1126/478 +f 1127/474 1126/478 1124/475 +f 1120/467 1127/474 297/2862 +f 1125/476 297/2862 1127/474 +f 1102/446 1130/480 47/2856 +f 1129/481 47/2856 1130/480 +f 297/2862 1125/476 1128/479 +f 1130/480 1128/479 1125/476 +f 1131/482 1132/483 50/2855 +f 1096/440 50/2855 1132/483 +f 1128/479 1132/483 297/2862 +f 1121/473 297/2862 1132/483 +f 18/2858 1109/455 755/486 +f 1135/485 755/486 1109/455 +f 298/2864 1134/488 1133/484 +f 1135/485 1133/484 1134/488 +f 1105/449 1137/490 49/2857 +f 1117/466 49/2857 1137/490 +f 1133/484 1137/490 298/2864 +f 1136/489 298/2864 1137/490 +f 1129/481 1139/492 47/2856 +f 1100/444 47/2856 1139/492 +f 298/2864 1136/489 1138/491 +f 1139/492 1138/491 1136/489 +f 13/2863 761/493 1124/475 +f 1140/494 1124/475 761/493 +f 1138/491 1140/494 298/2864 +f 1134/488 298/2864 1140/494 +f 20/2861 1122/471 808/498 +f 1143/495 808/498 1122/471 +f 1142/497 1143/495 299/2865 +f 1141/496 299/2865 1143/495 +f 1098/441 1145/501 50/2855 +f 1131/482 50/2855 1145/501 +f 299/2865 1141/496 1144/500 +f 1145/501 1144/500 1141/496 +f 1115/464 1147/503 44/2853 +f 1091/433 44/2853 1147/503 +f 1144/500 1147/503 299/2865 +f 1146/502 299/2865 1147/503 +f 1148/504 1111/460 798/505 +f 2/2860 798/505 1111/460 +f 1148/504 1142/497 1146/502 +f 299/2865 1146/502 1142/497 +f 16/2866 1149/508 822/511 +f 1152/509 822/511 1149/508 +f 1151/512 1152/509 302/2867 +f 1150/507 302/2867 1152/509 +f 1082/421 1155/514 48/2850 +f 1154/515 48/2850 1155/514 +f 302/2867 1150/507 1153/513 +f 1155/514 1153/513 1150/507 +f 1156/518 1158/519 43/2848 +f 1075/413 43/2848 1158/519 +f 1153/513 1158/519 302/2867 +f 1157/517 302/2867 1158/519 +f 1160/520 1159/522 813/521 +f 1/2868 813/521 1159/522 +f 302/2867 1157/517 1151/512 +f 1160/520 1151/512 1157/517 +f 772/525 1164/526 12/2869 +f 1163/528 12/2869 1164/526 +f 1161/524 304/2870 1164/526 +f 1162/527 1164/526 304/2870 +f 1159/522 1166/531 1/2868 +f 765/532 1/2868 1166/531 +f 1166/531 1165/530 1161/524 +f 304/2870 1161/524 1165/530 +f 1078/416 1168/534 43/2848 +f 1156/518 43/2848 1168/534 +f 1165/530 1168/534 304/2870 +f 1167/533 304/2870 1168/534 +f 1169/536 1170/535 46/2852 +f 1088/427 46/2852 1170/535 +f 304/2870 1167/533 1162/527 +f 1170/535 1162/527 1167/533 +f 1171/539 1174/540 10/2871 +f 744/542 10/2871 1174/540 +f 1173/543 1174/540 306/2872 +f 1172/538 306/2872 1174/540 +f 1086/426 1177/545 45/2851 +f 1176/546 45/2851 1177/545 +f 306/2872 1172/538 1175/544 +f 1177/545 1175/544 1172/538 +f 1154/515 1179/548 48/2850 +f 1080/420 48/2850 1179/548 +f 1175/544 1179/548 306/2872 +f 1178/547 306/2872 1179/548 +f 16/2866 749/550 1149/508 +f 1180/549 1149/508 749/550 +f 306/2872 1178/547 1173/543 +f 1180/549 1173/543 1178/547 +f 12/2869 1163/528 1183/553 +f 1184/552 1183/553 1163/528 +f 308/2873 1182/555 1181/551 +f 1184/552 1181/551 1182/555 +f 1089/429 1186/557 46/2852 +f 1169/536 46/2852 1186/557 +f 1181/551 1186/557 308/2873 +f 1185/556 308/2873 1186/557 +f 1176/546 1188/559 45/2851 +f 1084/424 45/2851 1188/559 +f 308/2873 1185/556 1187/558 +f 1188/559 1187/558 1185/556 +f 10/2871 1189/560 1171/539 +f 1190/561 1171/539 1189/560 +f 1187/558 1190/561 308/2873 +f 1182/555 308/2873 1190/561 +f 38/2847 1191/565 1072/407 +f 1194/563 1072/407 1191/565 +f 312/2874 1193/566 1192/562 +f 1194/563 1192/562 1193/566 +f 51/2875 1195/567 1197/571 +f 1198/569 1197/571 1195/567 +f 312/2874 1192/562 1196/570 +f 1198/569 1196/570 1192/562 +f 1201/576 53/2876 1202/572 +f 1199/573 1202/572 53/2876 +f 312/2874 1196/570 1200/574 +f 1202/572 1200/574 1196/570 +f 1205/578 1204/579 1043/372 +f 36/2840 1043/372 1204/579 +f 312/2874 1200/574 1203/577 +f 1205/578 1203/577 1200/574 +f 1063/395 1206/580 37/2839 +f 1037/366 37/2839 1206/580 +f 1203/577 1206/580 312/2874 +f 1193/566 312/2874 1206/580 +f 52/2877 1207/584 1210/585 +f 1211/582 1210/585 1207/584 +f 1211/582 1208/581 1209/587 +f 317/2878 1209/587 1208/581 +f 1212/590 1215/591 53/2879 +f 1214/592 53/2879 1215/591 +f 1208/581 1215/591 317/2878 +f 1213/589 317/2878 1215/591 +f 1216/595 1219/596 57/2880 +f 1218/597 57/2880 1219/596 +f 1217/594 317/2878 1219/596 +f 1213/589 1219/596 317/2878 +f 1222/598 1221/600 1220/599 +f 56/2881 1220/599 1221/600 +f 317/2878 1217/594 1209/587 +f 1222/598 1209/587 1217/594 +f 1225/602 1212/590 1201/604 +f 53/2879 1201/604 1212/590 +f 320/2882 1224/605 1223/601 +f 1225/602 1223/601 1224/605 +f 51/2883 1226/608 1195/610 +f 1228/609 1195/610 1226/608 +f 1227/607 320/2882 1228/609 +f 1223/601 1228/609 320/2882 +f 1232/612 1231/615 1229/614 +f 54/2884 1229/614 1231/615 +f 320/2882 1227/607 1230/611 +f 1232/612 1230/611 1227/607 +f 1218/597 1234/616 57/2880 +f 1233/617 57/2880 1234/616 +f 1230/611 1234/616 320/2882 +f 1224/605 320/2882 1234/616 +f 1238/619 1229/614 1235/621 +f 54/2884 1235/621 1229/614 +f 323/2885 1237/622 1236/618 +f 1238/619 1236/618 1237/622 +f 1239/625 1242/626 55/2886 +f 1241/627 55/2886 1242/626 +f 1236/618 1242/626 323/2885 +f 1240/624 323/2885 1242/626 +f 1221/600 1245/629 56/2881 +f 1244/630 56/2881 1245/629 +f 323/2885 1240/624 1243/628 +f 1245/629 1243/628 1240/624 +f 1233/617 1246/631 57/2880 +f 1216/595 57/2880 1246/631 +f 1243/628 1246/631 323/2885 +f 1237/622 323/2885 1246/631 +f 1247/634 1251/635 69/2887 +f 1250/637 69/2887 1251/635 +f 1249/638 1251/635 327/2888 +f 1248/633 327/2888 1251/635 +f 76/2889 1252/642 1254/643 +f 1255/640 1254/643 1252/642 +f 327/2888 1248/633 1253/639 +f 1255/640 1253/639 1248/633 +f 920/226 1258/645 21/2818 +f 1257/646 21/2818 1258/645 +f 1253/639 1258/645 327/2888 +f 1256/644 327/2888 1258/645 +f 22/2817 1259/648 914/219 +f 1260/647 914/219 1259/648 +f 327/2888 1256/644 1249/638 +f 1260/647 1249/638 1256/644 +f 1264/654 77/2890 1265/649 +f 1261/650 1265/649 77/2890 +f 1263/655 1265/649 331/2891 +f 1262/651 331/2891 1265/649 +f 1269/657 1268/660 1266/659 +f 80/2892 1266/659 1268/660 +f 331/2891 1262/651 1267/656 +f 1269/657 1267/656 1262/651 +f 963/278 1272/662 25/2826 +f 1271/663 25/2826 1272/662 +f 1270/661 331/2891 1272/662 +f 1267/656 1272/662 331/2891 +f 33/2822 1273/665 959/274 +f 1274/664 959/274 1273/665 +f 331/2891 1270/661 1263/655 +f 1274/664 1263/655 1270/661 +f 1266/659 80/2892 1278/666 +f 1275/667 1278/666 80/2892 +f 1277/670 1278/666 334/2893 +f 1276/668 334/2893 1278/666 +f 1282/672 1281/675 1279/674 +f 81/2894 1279/674 1281/675 +f 334/2893 1276/668 1280/671 +f 1282/672 1280/671 1276/668 +f 1284/678 26/2827 1285/676 +f 953/266 1285/676 26/2827 +f 1280/671 1285/676 334/2893 +f 1283/677 334/2893 1285/676 +f 25/2826 1271/663 948/260 +f 1286/679 948/260 1271/663 +f 1286/679 1277/670 1283/677 +f 334/2893 1283/677 1277/670 +f 1287/682 1291/683 67/2895 +f 1290/685 67/2895 1291/683 +f 1289/686 1291/683 338/2896 +f 1288/681 338/2896 1291/683 +f 1295/688 1294/691 1292/690 +f 68/2897 1292/690 1294/691 +f 338/2896 1288/681 1293/687 +f 1295/688 1293/687 1288/681 +f 1297/696 12/2789 1298/692 +f 1183/693 1298/692 12/2789 +f 1293/687 1298/692 338/2896 +f 1296/694 338/2896 1298/692 +f 1300/697 1189/699 1299/698 +f 10/2782 1299/698 1189/699 +f 338/2896 1296/694 1289/686 +f 1300/697 1289/686 1296/694 +f 78/2898 1301/703 1304/704 +f 1305/701 1304/704 1301/703 +f 1305/701 1302/700 1303/706 +f 342/2899 1303/706 1302/700 +f 1306/709 1309/710 74/2900 +f 1308/711 74/2900 1309/710 +f 1307/708 342/2899 1309/710 +f 1302/700 1309/710 342/2899 +f 1312/713 1311/716 1126/715 +f 13/2786 1126/715 1311/716 +f 342/2899 1307/708 1310/712 +f 1312/713 1310/712 1307/708 +f 1313/717 1314/718 20/2799 +f 1119/719 20/2799 1314/718 +f 1303/706 342/2899 1314/718 +f 1310/712 1314/718 342/2899 +f 1315/721 1318/720 76/2889 +f 1252/642 76/2889 1318/720 +f 1317/724 1318/720 344/2901 +f 1316/722 344/2901 1318/720 +f 1321/726 1320/727 1264/654 +f 77/2890 1264/654 1320/727 +f 344/2901 1316/722 1319/725 +f 1321/726 1319/725 1316/722 +f 937/246 1323/729 33/2822 +f 1273/665 33/2822 1323/729 +f 1322/728 344/2901 1323/729 +f 1319/725 1323/729 344/2901 +f 21/2818 1257/646 933/243 +f 1324/730 933/243 1257/646 +f 344/2901 1322/728 1317/724 +f 1324/730 1317/724 1322/728 +f 1328/736 70/2902 1329/734 +f 1325/733 1329/734 70/2902 +f 1326/732 347/2903 1329/734 +f 1327/737 1329/734 347/2903 +f 69/2887 1250/637 1331/740 +f 1332/739 1331/740 1250/637 +f 347/2903 1326/732 1330/738 +f 1332/739 1330/738 1326/732 +f 1031/355 1334/742 22/2817 +f 1259/648 22/2817 1334/742 +f 1330/738 1334/742 347/2903 +f 1333/741 347/2903 1334/742 +f 34/2836 1335/743 1027/350 +f 1336/744 1027/350 1335/743 +f 347/2903 1333/741 1327/737 +f 1336/744 1327/737 1333/741 +f 1340/750 71/2904 1341/745 +f 1337/746 1341/745 71/2904 +f 1339/751 1341/745 350/2905 +f 1338/747 350/2905 1341/745 +f 1344/753 1343/756 1328/755 +f 70/2906 1328/755 1343/756 +f 350/2905 1338/747 1342/752 +f 1344/753 1342/752 1338/747 +f 1045/759 1346/760 34/2907 +f 1335/761 34/2907 1346/760 +f 1345/758 350/2905 1346/760 +f 1342/752 1346/760 350/2905 +f 36/2908 1347/762 1041/764 +f 1348/763 1041/764 1347/762 +f 1348/763 1339/751 1345/758 +f 350/2905 1345/758 1339/751 +f 59/2909 1349/766 1352/770 +f 1353/765 1352/770 1349/766 +f 1351/771 1353/765 355/2910 +f 1350/767 355/2910 1353/765 +f 65/2911 1354/775 1356/776 +f 1357/773 1356/776 1354/775 +f 355/2910 1350/767 1355/772 +f 1357/773 1355/772 1350/767 +f 1358/779 1361/780 39/2912 +f 1360/781 39/2912 1361/780 +f 1355/772 1361/780 355/2910 +f 1359/778 355/2910 1361/780 +f 38/2847 1362/783 1363/784 +f 1364/782 1363/784 1362/783 +f 355/2910 1359/778 1351/771 +f 1364/782 1351/771 1359/778 +f 1368/790 60/2913 1369/787 +f 1365/785 1369/787 60/2913 +f 358/2914 1367/789 1366/788 +f 1369/787 1366/788 1367/789 +f 1372/793 1371/794 1352/770 +f 59/2909 1352/770 1371/794 +f 1370/792 358/2914 1372/793 +f 1366/788 1372/793 358/2914 +f 38/2847 1073/409 1362/783 +f 1374/795 1362/783 1073/409 +f 1374/795 1373/796 1370/792 +f 358/2914 1370/792 1373/796 +f 1375/798 1376/797 42/2846 +f 1068/404 42/2846 1376/797 +f 1373/796 1376/797 358/2914 +f 1367/789 358/2914 1376/797 +f 1380/804 79/2915 1381/799 +f 1377/800 1381/799 79/2915 +f 1379/805 1381/799 361/2916 +f 1378/801 361/2916 1381/799 +f 1383/808 78/2898 1384/806 +f 1304/704 1384/806 78/2898 +f 361/2916 1378/801 1382/807 +f 1384/806 1382/807 1378/801 +f 20/2799 809/94 1313/717 +f 1386/810 1313/717 809/94 +f 1385/809 361/2916 1386/810 +f 1382/807 1386/810 361/2916 +f 19/2798 1387/812 804/89 +f 1388/811 804/89 1387/812 +f 1388/811 1379/805 1385/809 +f 361/2916 1385/809 1379/805 +f 68/2897 1389/816 1292/690 +f 1392/814 1292/690 1389/816 +f 364/2917 1391/817 1390/813 +f 1392/814 1390/813 1391/817 +f 1393/820 1396/821 58/2918 +f 1395/822 58/2918 1396/821 +f 1394/819 364/2917 1396/821 +f 1390/813 1396/821 364/2917 +f 11/2790 776/54 1398/825 +f 1399/824 1398/825 776/54 +f 364/2917 1394/819 1397/823 +f 1399/824 1397/823 1394/819 +f 770/48 12/2789 1400/826 +f 1297/696 1400/826 12/2789 +f 1397/823 1400/826 364/2917 +f 1391/817 364/2917 1400/826 +f 1404/828 1393/820 1401/830 +f 58/2918 1401/830 1393/820 +f 367/2919 1403/831 1402/827 +f 1404/828 1402/827 1403/831 +f 1405/834 1408/835 61/2920 +f 1407/836 61/2920 1408/835 +f 1406/833 367/2919 1408/835 +f 1402/827 1408/835 367/2919 +f 23/2794 793/74 1410/839 +f 1411/838 1410/839 793/74 +f 367/2919 1406/833 1409/837 +f 1411/838 1409/837 1406/833 +f 1398/825 1412/840 11/2790 +f 789/71 11/2790 1412/840 +f 1409/837 1412/840 367/2919 +f 1403/831 367/2919 1412/840 +f 1413/844 1416/842 61/2920 +f 1405/834 61/2920 1416/842 +f 370/2921 1415/845 1414/841 +f 1416/842 1414/841 1415/845 +f 1420/847 1419/850 1417/849 +f 62/2922 1417/849 1419/850 +f 370/2921 1414/841 1418/846 +f 1420/847 1418/846 1414/841 +f 35/2835 1025/348 1422/853 +f 1423/852 1422/853 1025/348 +f 1421/851 370/2921 1423/852 +f 1418/846 1423/852 370/2921 +f 1410/839 1424/854 23/2794 +f 1019/339 23/2794 1424/854 +f 1421/851 1424/854 370/2921 +f 1415/845 370/2921 1424/854 +f 1425/857 1428/858 62/2923 +f 1417/860 62/2923 1428/858 +f 1427/861 1428/858 373/2924 +f 1426/856 373/2924 1428/858 +f 1429/864 1432/865 63/2925 +f 1431/866 63/2925 1432/865 +f 373/2924 1426/856 1430/863 +f 1432/865 1430/863 1426/856 +f 1435/868 1434/869 1053/385 +f 40/2843 1053/385 1434/869 +f 1433/867 373/2924 1435/868 +f 1430/863 1435/868 373/2924 +f 35/2837 1422/871 1047/379 +f 1436/870 1047/379 1422/871 +f 1436/870 1427/861 1433/867 +f 373/2924 1433/867 1427/861 +f 1440/873 1429/864 1437/875 +f 63/2925 1437/875 1429/864 +f 376/2926 1439/876 1438/872 +f 1440/873 1438/872 1439/876 +f 1441/879 1444/880 64/2927 +f 1443/881 64/2927 1444/880 +f 1438/872 1444/880 376/2926 +f 1442/878 376/2926 1444/880 +f 41/2844 1057/390 1446/884 +f 1447/883 1446/884 1057/390 +f 376/2926 1442/878 1445/882 +f 1447/883 1445/882 1442/878 +f 1434/869 1448/885 40/2843 +f 1051/383 40/2843 1448/885 +f 1445/882 1448/885 376/2926 +f 1439/876 376/2926 1448/885 +f 1452/886 1441/879 1449/887 +f 64/2927 1449/887 1441/879 +f 1451/890 1452/886 378/2928 +f 1450/888 378/2928 1452/886 +f 1455/892 1454/893 1368/790 +f 60/2913 1368/790 1454/893 +f 378/2928 1450/888 1453/891 +f 1455/892 1453/891 1450/888 +f 1070/406 1457/895 42/2846 +f 1375/798 42/2846 1457/895 +f 1453/891 1457/895 378/2928 +f 1456/894 378/2928 1457/895 +f 41/2844 1446/884 1065/400 +f 1458/896 1065/400 1446/884 +f 1458/896 1451/890 1456/894 +f 378/2928 1456/894 1451/890 +f 1462/897 1461/899 1340/750 +f 71/2904 1340/750 1461/899 +f 381/2929 1460/901 1459/898 +f 1462/897 1459/898 1460/901 +f 1347/762 36/2908 1464/902 +f 1204/903 1464/902 36/2908 +f 381/2929 1459/898 1463/904 +f 1464/902 1463/904 1459/898 +f 53/2930 1214/909 1199/910 +f 1466/907 1199/910 1214/909 +f 381/2929 1463/904 1465/906 +f 1466/907 1465/906 1463/904 +f 1467/913 1469/914 52/2931 +f 1207/915 52/2931 1469/914 +f 381/2929 1465/906 1468/912 +f 1469/914 1468/912 1465/906 +f 1470/916 1472/917 72/2932 +f 1471/918 72/2932 1472/917 +f 381/2929 1468/912 1460/901 +f 1472/917 1460/901 1468/912 +f 38/2847 1363/784 1191/565 +f 1475/919 1191/565 1363/784 +f 1475/919 1473/920 1474/921 +f 383/2933 1474/921 1473/920 +f 39/2912 1476/925 1358/779 +f 1478/923 1358/779 1476/925 +f 1478/923 1477/922 1473/920 +f 383/2933 1473/920 1477/922 +f 1197/571 1480/926 51/2875 +f 1479/927 51/2875 1480/926 +f 1477/922 1480/926 383/2933 +f 1474/921 383/2933 1480/926 +f 1485/931 1484/933 1481/930 +f 85/2934 1481/930 1484/933 +f 1483/934 1485/931 388/2935 +f 1482/929 388/2935 1485/931 +f 1489/936 1488/939 1486/938 +f 83/2936 1486/938 1488/939 +f 388/2935 1482/929 1487/935 +f 1489/936 1487/935 1482/929 +f 1490/942 1493/943 84/2937 +f 1492/944 84/2937 1493/943 +f 1487/935 1493/943 388/2935 +f 1491/941 388/2935 1493/943 +f 1496/945 1495/947 1494/946 +f 82/2938 1494/946 1495/947 +f 388/2935 1491/941 1483/934 +f 1496/945 1483/934 1491/941 +f 1497/949 1501/948 92/2939 +f 1500/953 92/2939 1501/948 +f 1499/954 1501/948 393/2940 +f 1498/950 393/2940 1501/948 +f 1505/956 1504/959 1502/958 +f 89/2941 1502/958 1504/959 +f 393/2940 1498/950 1503/955 +f 1505/956 1503/955 1498/950 +f 1509/961 1508/964 1506/963 +f 88/2942 1506/963 1508/964 +f 1507/960 393/2940 1509/961 +f 1503/955 1509/961 393/2940 +f 93/2943 1510/966 1511/967 +f 1512/965 1511/967 1510/966 +f 1512/965 1499/954 1507/960 +f 393/2940 1507/960 1499/954 +f 93/2943 1513/968 1516/972 +f 1517/970 1516/972 1513/968 +f 1517/970 1514/971 1515/974 +f 398/2944 1515/974 1514/971 +f 1521/975 1520/979 1518/976 +f 86/2945 1518/976 1520/979 +f 1514/971 1521/975 398/2944 +f 1519/977 398/2944 1521/975 +f 1525/981 1524/984 1522/983 +f 87/2946 1522/983 1524/984 +f 398/2944 1519/977 1523/980 +f 1525/981 1523/980 1519/977 +f 1526/985 1528/986 94/2947 +f 1527/987 94/2947 1528/986 +f 1515/974 398/2944 1528/986 +f 1523/980 1528/986 398/2944 +f 89/2941 1529/990 1502/958 +f 1532/991 1502/958 1529/990 +f 1530/989 402/2948 1532/991 +f 1531/992 1532/991 402/2948 +f 1535/997 90/2949 1536/994 +f 1533/996 1536/994 90/2949 +f 1530/989 1536/994 402/2948 +f 1534/993 402/2948 1536/994 +f 1539/1002 91/2950 1540/998 +f 1537/999 1540/998 91/2950 +f 1534/993 1540/998 402/2948 +f 1538/1000 402/2948 1540/998 +f 1542/1003 1541/1004 1508/964 +f 88/2942 1508/964 1541/1004 +f 402/2948 1538/1000 1531/992 +f 1542/1003 1531/992 1538/1000 +f 1543/1007 1546/1008 90/2949 +f 1533/996 90/2949 1546/1008 +f 1544/1006 405/2951 1546/1008 +f 1545/1009 1546/1008 405/2951 +f 1524/984 1549/1011 87/2946 +f 1548/1012 87/2946 1549/1011 +f 1547/1010 405/2951 1549/1011 +f 1544/1006 1549/1011 405/2951 +f 1518/976 86/2945 1552/1014 +f 1550/1016 1552/1014 86/2945 +f 405/2951 1547/1010 1551/1013 +f 1552/1014 1551/1013 1547/1010 +f 1554/1017 1553/1018 1539/1002 +f 91/2950 1539/1002 1553/1018 +f 1545/1009 405/2951 1554/1017 +f 1551/1013 1554/1017 405/2951 +f 92/2939 1500/953 1557/1022 +f 1558/1020 1557/1022 1500/953 +f 408/2952 1556/1023 1555/1019 +f 1558/1020 1555/1019 1556/1023 +f 93/2943 1516/972 1510/966 +f 1560/1025 1510/966 1516/972 +f 1555/1019 1560/1025 408/2952 +f 1559/1024 408/2952 1560/1025 +f 1561/1028 1563/1029 94/2947 +f 1526/985 94/2947 1563/1029 +f 1562/1027 408/2952 1563/1029 +f 1559/1024 1563/1029 408/2952 +f 95/2953 1564/1031 1565/1032 +f 1566/1030 1565/1032 1564/1031 +f 408/2952 1562/1027 1556/1023 +f 1566/1030 1556/1023 1562/1027 +f 1570/1034 1569/1039 1557/1036 +f 92/2954 1557/1036 1569/1039 +f 411/2955 1568/1037 1567/1033 +f 1570/1034 1567/1033 1568/1037 +f 1571/1042 1573/1043 95/2956 +f 1564/1044 95/2956 1573/1043 +f 411/2955 1567/1033 1572/1041 +f 1573/1043 1572/1041 1567/1033 +f 55/2886 1241/627 1575/1047 +f 1576/1046 1575/1047 1241/627 +f 411/2955 1572/1041 1574/1045 +f 1576/1046 1574/1045 1572/1041 +f 1231/615 1578/1049 54/2884 +f 1235/621 54/2884 1578/1049 +f 1574/1045 1578/1049 411/2955 +f 1577/1048 411/2955 1578/1049 +f 51/2883 1579/1051 1226/608 +f 1580/1050 1226/608 1579/1051 +f 411/2955 1577/1048 1568/1037 +f 1580/1050 1568/1037 1577/1048 +f 94/2957 1581/1052 1561/1056 +f 1584/1054 1561/1056 1581/1052 +f 1584/1054 1582/1055 1583/1058 +f 413/2958 1583/1058 1582/1055 +f 1586/1061 52/2877 1587/1059 +f 1210/585 1587/1059 52/2877 +f 1585/1060 413/2958 1587/1059 +f 1582/1055 1587/1059 413/2958 +f 1244/630 1589/1063 56/2881 +f 1220/599 56/2881 1589/1063 +f 413/2958 1585/1060 1588/1062 +f 1589/1063 1588/1062 1585/1060 +f 1575/1047 1591/1064 55/2886 +f 1239/625 55/2886 1591/1064 +f 413/2958 1588/1062 1590/1065 +f 1591/1064 1590/1065 1588/1062 +f 1571/1042 95/2956 1592/1067 +f 1565/1066 1592/1067 95/2956 +f 1590/1065 1592/1067 413/2958 +f 1583/1058 413/2958 1592/1067 +f 1593/1070 1596/1071 87/2959 +f 1522/1073 87/2959 1596/1071 +f 416/2960 1595/1074 1594/1069 +f 1596/1071 1594/1069 1595/1074 +f 1597/1077 1600/1078 73/2961 +f 1599/1079 73/2961 1600/1078 +f 416/2960 1594/1069 1598/1076 +f 1600/1078 1598/1076 1594/1069 +f 72/2932 1471/918 1602/1082 +f 1603/1081 1602/1082 1471/918 +f 416/2960 1598/1076 1601/1080 +f 1603/1081 1601/1080 1598/1076 +f 1605/1083 1467/913 1586/1084 +f 52/2931 1586/1084 1467/913 +f 416/2960 1601/1080 1604/1085 +f 1605/1083 1604/1085 1601/1080 +f 94/2962 1527/1087 1581/1089 +f 1606/1088 1581/1089 1527/1087 +f 1606/1088 1595/1074 1604/1085 +f 416/2960 1604/1085 1595/1074 +f 1611/1091 1610/1096 1607/1093 +f 66/2963 1607/1093 1610/1096 +f 420/2964 1609/1094 1608/1090 +f 1611/1091 1608/1090 1609/1094 +f 1614/1098 1613/1101 1535/1100 +f 90/2965 1535/1100 1613/1101 +f 420/2964 1608/1090 1612/1097 +f 1614/1098 1612/1097 1608/1090 +f 1615/1104 1617/1105 89/2966 +f 1529/1106 89/2966 1617/1105 +f 420/2964 1612/1097 1616/1103 +f 1617/1105 1616/1103 1612/1097 +f 39/2912 1360/781 1619/1109 +f 1620/1108 1619/1109 1360/781 +f 420/2964 1616/1103 1618/1107 +f 1620/1108 1618/1107 1616/1103 +f 1621/1110 1622/1111 65/2911 +f 1354/775 65/2911 1622/1111 +f 1618/1107 1622/1111 420/2964 +f 1609/1094 420/2964 1622/1111 +f 73/2961 1599/1079 1625/1114 +f 1626/1113 1625/1114 1599/1079 +f 1626/1113 1623/1112 1624/1116 +f 422/2967 1624/1116 1623/1112 +f 87/2959 1548/1117 1593/1070 +f 1628/1119 1593/1070 1548/1117 +f 422/2967 1623/1112 1627/1120 +f 1628/1119 1627/1120 1623/1112 +f 1630/1122 1543/1125 1613/1124 +f 90/2968 1613/1124 1543/1125 +f 422/2967 1627/1120 1629/1121 +f 1630/1122 1629/1121 1627/1120 +f 66/2969 1631/1127 1607/1128 +f 1632/1126 1607/1128 1631/1127 +f 1624/1116 422/2967 1632/1126 +f 1629/1121 1632/1126 422/2967 +f 1619/1109 1635/1130 39/2912 +f 1476/925 39/2912 1635/1130 +f 1634/1131 1635/1130 423/2970 +f 1633/1129 423/2970 1635/1130 +f 1637/1135 1615/1104 1504/1134 +f 89/2966 1504/1134 1615/1104 +f 423/2970 1633/1129 1636/1133 +f 1637/1135 1636/1133 1633/1129 +f 92/2971 1569/1139 1497/1140 +f 1639/1137 1497/1140 1569/1139 +f 423/2970 1636/1133 1638/1136 +f 1639/1137 1638/1136 1636/1133 +f 51/2875 1479/927 1579/1142 +f 1640/1141 1579/1142 1479/927 +f 423/2970 1638/1136 1634/1131 +f 1640/1141 1634/1131 1638/1136 +f 1506/963 88/2942 1644/1143 +f 1641/1144 1644/1143 88/2942 +f 1643/1147 1644/1143 426/2972 +f 1642/1145 426/2972 1644/1143 +f 1488/939 1647/1149 83/2936 +f 1646/1150 83/2936 1647/1149 +f 1642/1145 1647/1149 426/2972 +f 1645/1148 426/2972 1647/1149 +f 1648/1153 1650/1154 85/2934 +f 1481/930 85/2934 1650/1154 +f 1649/1152 426/2972 1650/1154 +f 1645/1148 1650/1154 426/2972 +f 93/2943 1511/967 1651/1156 +f 1652/1155 1651/1156 1511/967 +f 426/2972 1649/1152 1643/1147 +f 1652/1155 1643/1147 1649/1152 +f 91/2950 1653/1157 1537/999 +f 1656/1159 1537/999 1653/1157 +f 1656/1159 1654/1160 1655/1161 +f 428/2973 1655/1161 1654/1160 +f 1492/944 1659/1163 84/2937 +f 1658/1164 84/2937 1659/1163 +f 1654/1160 1659/1163 428/2973 +f 1657/1162 428/2973 1659/1163 +f 1646/1150 1661/1166 83/2936 +f 1486/938 83/2936 1661/1166 +f 1657/1162 1661/1166 428/2973 +f 1660/1165 428/2973 1661/1166 +f 1541/1004 1662/1167 88/2942 +f 1641/1144 88/2942 1662/1167 +f 1662/1167 1655/1161 1660/1165 +f 428/2973 1660/1165 1655/1161 +f 86/2945 1663/1169 1550/1016 +f 1666/1168 1550/1016 1663/1169 +f 1665/1172 1666/1168 430/2974 +f 1664/1170 430/2974 1666/1168 +f 1668/1175 82/2938 1669/1174 +f 1495/947 1669/1174 82/2938 +f 1664/1170 1669/1174 430/2974 +f 1667/1173 430/2974 1669/1174 +f 1658/1164 1671/1177 84/2937 +f 1490/942 84/2937 1671/1177 +f 1670/1176 430/2974 1671/1177 +f 1667/1173 1671/1177 430/2974 +f 91/2950 1553/1018 1653/1157 +f 1672/1178 1653/1157 1553/1018 +f 1672/1178 1665/1172 1670/1176 +f 430/2974 1670/1176 1665/1172 +f 93/2943 1651/1156 1513/968 +f 1675/1179 1513/968 1651/1156 +f 431/2975 1674/1181 1673/1180 +f 1675/1179 1673/1180 1674/1181 +f 1484/933 1677/1183 85/2934 +f 1648/1153 85/2934 1677/1183 +f 1673/1180 1677/1183 431/2975 +f 1676/1182 431/2975 1677/1183 +f 1668/1175 1679/1185 82/2938 +f 1494/946 82/2938 1679/1185 +f 1678/1184 431/2975 1679/1185 +f 1676/1182 1679/1185 431/2975 +f 1520/979 1680/1186 86/2945 +f 1663/1169 86/2945 1680/1186 +f 1674/1181 431/2975 1680/1186 +f 1678/1184 1680/1186 431/2975 +f 14/2976 763/1190 1683/1191 +f 1684/1188 1683/1191 763/1190 +f 1684/1188 1681/1187 1682/1193 +f 435/2977 1682/1193 1681/1187 +f 1687/1195 759/1198 1685/1197 +f 13/2978 1685/1197 759/1198 +f 435/2977 1681/1187 1686/1194 +f 1687/1195 1686/1194 1681/1187 +f 1688/1202 1691/1200 97/2979 +f 1690/1203 97/2979 1691/1200 +f 1689/1199 435/2977 1691/1200 +f 1686/1194 1691/1200 435/2977 +f 1692/1204 1694/1205 98/2980 +f 1693/1206 98/2980 1694/1205 +f 1682/1193 435/2977 1694/1205 +f 1689/1199 1694/1205 435/2977 +f 1685/1197 13/2978 1697/1210 +f 1311/1209 1697/1210 13/2978 +f 1696/1211 1697/1210 438/2981 +f 1695/1208 438/2981 1697/1210 +f 1700/1213 1306/1216 1698/1215 +f 74/2982 1698/1215 1306/1216 +f 438/2981 1695/1208 1699/1212 +f 1700/1213 1699/1212 1695/1208 +f 1701/1219 1704/1220 100/2983 +f 1703/1221 100/2983 1704/1220 +f 1699/1212 1704/1220 438/2981 +f 1702/1218 438/2981 1704/1220 +f 97/2979 1690/1203 1705/1223 +f 1706/1222 1705/1223 1690/1203 +f 438/2981 1702/1218 1696/1211 +f 1706/1222 1696/1211 1702/1218 +f 67/2984 1290/1227 1709/1228 +f 1710/1225 1709/1228 1290/1227 +f 442/2985 1708/1230 1707/1224 +f 1710/1225 1707/1224 1708/1230 +f 1711/1233 1713/1234 10/2986 +f 1299/1235 10/2986 1713/1234 +f 1707/1224 1713/1234 442/2985 +f 1712/1232 442/2985 1713/1234 +f 96/2987 1714/1239 1716/1240 +f 1717/1237 1716/1240 1714/1239 +f 442/2985 1712/1232 1715/1236 +f 1717/1237 1715/1236 1712/1232 +f 1718/1241 1720/1242 99/2988 +f 1719/1243 99/2988 1720/1242 +f 1715/1236 1720/1242 442/2985 +f 1708/1230 442/2985 1720/1242 +f 10/2986 746/1245 1711/1233 +f 1723/1244 1711/1233 746/1245 +f 1721/1246 444/2989 1723/1244 +f 1722/1248 1723/1244 444/2989 +f 740/1251 14/2976 1725/1249 +f 1683/1191 1725/1249 14/2976 +f 1725/1249 1724/1250 1721/1246 +f 444/2989 1721/1246 1724/1250 +f 1692/1204 98/2980 1728/1252 +f 1726/1253 1728/1252 98/2980 +f 1724/1250 1728/1252 444/2989 +f 1727/1254 444/2989 1728/1252 +f 1729/1257 96/2987 1730/1256 +f 1716/1240 1730/1256 96/2987 +f 444/2989 1727/1254 1722/1248 +f 1730/1256 1722/1248 1727/1254 +f 1734/1261 1701/1219 1731/1260 +f 100/2983 1731/1260 1701/1219 +f 447/2990 1733/1262 1732/1259 +f 1734/1261 1732/1259 1733/1262 +f 75/2991 1735/1265 1737/1267 +f 1738/1266 1737/1267 1735/1265 +f 1732/1259 1738/1266 447/2990 +f 1736/1264 447/2990 1738/1266 +f 98/2980 1693/1206 1740/1270 +f 1741/1269 1740/1270 1693/1206 +f 447/2990 1736/1264 1739/1268 +f 1741/1269 1739/1268 1736/1264 +f 1688/1202 97/2979 1742/1271 +f 1705/1223 1742/1271 97/2979 +f 1739/1268 1742/1271 447/2990 +f 1733/1262 447/2990 1742/1271 +f 75/2991 1743/1273 1735/1265 +f 1746/1272 1735/1265 1743/1273 +f 1745/1276 1746/1272 449/2992 +f 1744/1274 449/2992 1746/1272 +f 1749/1278 1748/1279 1719/1243 +f 99/2988 1719/1243 1748/1279 +f 449/2992 1744/1274 1747/1277 +f 1749/1278 1747/1277 1744/1274 +f 1729/1257 1751/1281 96/2987 +f 1714/1239 96/2987 1751/1281 +f 1747/1277 1751/1281 449/2992 +f 1750/1280 449/2992 1751/1281 +f 98/2980 1740/1270 1726/1253 +f 1752/1282 1726/1253 1740/1270 +f 449/2992 1750/1280 1745/1276 +f 1752/1282 1745/1276 1750/1280 +f 1757/1284 1756/1287 1753/1286 +f 101/2993 1753/1286 1756/1287 +f 1757/1284 1754/1283 1755/1289 +f 453/2994 1755/1289 1754/1283 +f 1758/1292 1761/1293 102/2995 +f 1760/1294 102/2995 1761/1293 +f 1754/1283 1761/1293 453/2994 +f 1759/1291 453/2994 1761/1293 +f 1762/1295 1764/1296 103/2996 +f 1763/1297 103/2996 1764/1296 +f 1759/1291 1764/1296 453/2994 +f 1755/1289 453/2994 1764/1296 +f 1768/1299 1767/1302 1756/1287 +f 101/2993 1756/1287 1767/1302 +f 456/2997 1766/1300 1765/1298 +f 1768/1299 1765/1298 1766/1300 +f 103/2996 1769/1306 1762/1295 +f 1771/1304 1762/1295 1769/1306 +f 456/2997 1765/1298 1770/1303 +f 1771/1304 1770/1303 1765/1298 +f 806/91 1774/1308 19/2798 +f 1773/1309 19/2798 1774/1308 +f 1770/1303 1774/1308 456/2997 +f 1772/1307 456/2997 1774/1308 +f 27/2797 881/180 800/84 +f 1776/1311 800/84 881/180 +f 456/2997 1772/1307 1775/1310 +f 1776/1311 1775/1310 1772/1307 +f 875/174 8/2810 1778/1312 +f 1777/1313 1778/1312 8/2810 +f 456/2997 1775/1310 1766/1300 +f 1778/1312 1766/1300 1775/1310 +f 1767/1302 1781/1315 101/2993 +f 1753/1286 101/2993 1781/1315 +f 458/2998 1780/1316 1779/1314 +f 1781/1315 1779/1314 1780/1316 +f 8/2810 989/308 1777/1313 +f 1783/1318 1777/1313 989/308 +f 458/2998 1779/1314 1782/1317 +f 1783/1318 1782/1317 1779/1314 +f 1785/1320 986/305 942/252 +f 4/2823 942/252 986/305 +f 458/2998 1782/1317 1784/1319 +f 1785/1320 1784/1319 1782/1317 +f 26/2827 1786/1321 952/264 +f 1788/1323 952/264 1786/1321 +f 458/2998 1784/1319 1787/1324 +f 1788/1323 1787/1324 1784/1319 +f 102/2995 1760/1294 1789/1326 +f 1790/1325 1789/1326 1760/1294 +f 458/2998 1787/1324 1780/1316 +f 1790/1325 1780/1316 1787/1324 +f 1795/1328 1794/1333 1791/1330 +f 104/2999 1791/1330 1794/1333 +f 461/3000 1793/1331 1792/1327 +f 1795/1328 1792/1327 1793/1331 +f 1789/1326 1798/1335 102/2995 +f 1797/1336 102/2995 1798/1335 +f 1792/1327 1798/1335 461/3000 +f 1796/1334 461/3000 1798/1335 +f 1786/1321 26/2827 1800/1337 +f 1284/678 1800/1337 26/2827 +f 1800/1337 1799/1338 1796/1334 +f 461/3000 1796/1334 1799/1338 +f 1279/674 81/2894 1802/1339 +f 1801/1340 1802/1339 81/2894 +f 1799/1338 1802/1339 461/3000 +f 1793/1331 461/3000 1802/1339 +f 1805/1344 79/2915 1806/1342 +f 1380/804 1806/1342 79/2915 +f 1804/1345 1806/1342 464/3001 +f 1803/1341 464/3001 1806/1342 +f 19/2798 1773/1309 1387/812 +f 1808/1347 1387/812 1773/1309 +f 464/3001 1803/1341 1807/1346 +f 1808/1347 1807/1346 1803/1341 +f 1809/1350 1811/1351 103/2996 +f 1769/1306 103/2996 1811/1351 +f 1807/1346 1811/1351 464/3001 +f 1810/1349 464/3001 1811/1351 +f 1814/1352 1813/1354 1812/1353 +f 105/3002 1812/1353 1813/1354 +f 464/3001 1810/1349 1804/1345 +f 1814/1352 1804/1345 1810/1349 +f 1763/1297 1818/1356 103/2996 +f 1817/1358 103/2996 1818/1356 +f 1815/1355 468/3003 1818/1356 +f 1816/1359 1818/1356 468/3003 +f 102/2995 1819/1361 1758/1292 +f 1821/1360 1758/1292 1819/1361 +f 1821/1360 1820/1362 1815/1355 +f 468/3003 1815/1355 1820/1362 +f 1825/1365 1824/1368 1822/1367 +f 106/3004 1822/1367 1824/1368 +f 468/3003 1820/1362 1823/1364 +f 1825/1365 1823/1364 1820/1362 +f 1828/1370 1827/1371 1826/1369 +f 107/3005 1826/1369 1827/1371 +f 1828/1370 1816/1359 1823/1364 +f 468/3003 1823/1364 1816/1359 +f 102/2995 1797/1336 1819/1361 +f 1831/1373 1819/1361 1797/1336 +f 471/3006 1830/1374 1829/1372 +f 1831/1373 1829/1372 1830/1374 +f 1832/1377 1834/1378 104/2999 +f 1791/1330 104/2999 1834/1378 +f 1829/1372 1834/1378 471/3006 +f 1833/1376 471/3006 1834/1378 +f 108/3007 1835/1382 1837/1383 +f 1838/1380 1837/1383 1835/1382 +f 471/3006 1833/1376 1836/1379 +f 1838/1380 1836/1379 1833/1376 +f 1824/1368 1840/1384 106/3004 +f 1839/1385 106/3004 1840/1384 +f 1836/1379 1840/1384 471/3006 +f 1830/1374 471/3006 1840/1384 +f 1843/1389 105/3002 1844/1386 +f 1813/1354 1844/1386 105/3002 +f 1842/1390 1844/1386 474/3008 +f 1841/1387 474/3008 1844/1386 +f 1846/1392 1809/1350 1817/1358 +f 103/2996 1817/1358 1809/1350 +f 474/3008 1841/1387 1845/1391 +f 1846/1392 1845/1391 1841/1387 +f 1847/1395 1849/1396 107/3005 +f 1826/1369 107/3005 1849/1396 +f 1848/1394 474/3008 1849/1396 +f 1845/1391 1849/1396 474/3008 +f 109/3009 1850/1398 1851/1399 +f 1852/1397 1851/1399 1850/1398 +f 1852/1397 1842/1390 1848/1394 +f 474/3008 1848/1394 1842/1390 +f 1855/1401 1822/1367 1839/1385 +f 106/3004 1839/1385 1822/1367 +f 476/3010 1854/1402 1853/1400 +f 1855/1401 1853/1400 1854/1402 +f 1856/1404 1858/1403 108/3007 +f 1835/1382 108/3007 1858/1403 +f 1853/1400 1858/1403 476/3010 +f 1857/1405 476/3010 1858/1403 +f 1851/1399 1861/1408 109/3009 +f 1860/1409 109/3009 1861/1408 +f 1857/1405 1861/1408 476/3010 +f 1859/1407 476/3010 1861/1408 +f 1862/1410 1847/1395 1827/1371 +f 107/3005 1827/1371 1847/1395 +f 476/3010 1859/1407 1854/1402 +f 1862/1410 1854/1402 1859/1407 +f 1863/1413 1867/1414 115/3011 +f 1866/1416 115/3011 1867/1414 +f 481/3012 1865/1415 1864/1412 +f 1867/1414 1864/1412 1865/1415 +f 125/3013 1868/1420 1870/1422 +f 1871/1421 1870/1422 1868/1420 +f 1869/1419 481/3012 1871/1421 +f 1864/1412 1871/1421 481/3012 +f 1875/1425 1874/1427 1872/1423 +f 119/3014 1872/1423 1874/1427 +f 481/3012 1869/1419 1873/1426 +f 1875/1425 1873/1426 1869/1419 +f 1878/1428 1877/1430 1876/1429 +f 123/3015 1876/1429 1877/1430 +f 1873/1426 1878/1428 481/3012 +f 1865/1415 481/3012 1878/1428 +f 1882/1432 1881/1435 1866/1416 +f 115/3011 1866/1416 1881/1435 +f 485/3016 1880/1433 1879/1431 +f 1882/1432 1879/1431 1880/1433 +f 1883/1438 1885/1439 123/3015 +f 1876/1429 123/3015 1885/1439 +f 1884/1437 485/3016 1885/1439 +f 1879/1431 1885/1439 485/3016 +f 1889/1441 1888/1444 1886/1443 +f 122/3017 1886/1443 1888/1444 +f 485/3016 1884/1437 1887/1440 +f 1889/1441 1887/1440 1884/1437 +f 127/3018 1890/1445 1891/1447 +f 1892/1446 1891/1447 1890/1445 +f 1887/1440 1892/1446 485/3016 +f 1880/1433 485/3016 1892/1446 +f 110/3019 1893/1451 1896/1453 +f 1897/1449 1896/1453 1893/1451 +f 1895/1452 1897/1449 490/3020 +f 1894/1448 490/3020 1897/1449 +f 133/3021 1898/1458 1900/1459 +f 1901/1456 1900/1459 1898/1458 +f 490/3020 1894/1448 1899/1455 +f 1901/1456 1899/1455 1894/1448 +f 1902/1462 1905/1463 120/3022 +f 1904/1464 120/3022 1905/1463 +f 1899/1455 1905/1463 490/3020 +f 1903/1461 490/3020 1905/1463 +f 121/3023 1906/1466 1907/1467 +f 1908/1465 1907/1467 1906/1466 +f 490/3020 1903/1461 1895/1452 +f 1908/1465 1895/1452 1903/1461 +f 116/3024 1909/1471 1912/1472 +f 1913/1469 1912/1472 1909/1471 +f 494/3025 1911/1474 1910/1468 +f 1913/1469 1910/1468 1911/1474 +f 1914/1477 1917/1478 132/3026 +f 1916/1479 132/3026 1917/1478 +f 1910/1468 1917/1478 494/3025 +f 1915/1476 494/3025 1917/1478 +f 120/3022 1904/1464 1919/1482 +f 1920/1481 1919/1482 1904/1464 +f 494/3025 1915/1476 1918/1480 +f 1920/1481 1918/1480 1915/1476 +f 1921/1483 1922/1484 133/3021 +f 1898/1458 133/3021 1922/1484 +f 1918/1480 1922/1484 494/3025 +f 1911/1474 494/3025 1922/1484 +f 111/3027 1923/1487 1926/1489 +f 1927/1488 1926/1489 1923/1487 +f 499/3028 1925/1491 1924/1486 +f 1927/1488 1924/1486 1925/1491 +f 129/3029 1928/1495 1930/1496 +f 1931/1493 1930/1496 1928/1495 +f 1931/1493 1929/1492 1924/1486 +f 499/3028 1924/1486 1929/1492 +f 1935/1498 1934/1501 1932/1500 +f 128/3030 1932/1500 1934/1501 +f 499/3028 1929/1492 1933/1497 +f 1935/1498 1933/1497 1929/1492 +f 1936/1502 1938/1503 136/3031 +f 1937/1504 136/3031 1938/1503 +f 1933/1497 1938/1503 499/3028 +f 1925/1491 499/3028 1938/1503 +f 1939/1507 1942/1508 110/3019 +f 1893/1451 110/3019 1942/1508 +f 1941/1509 1942/1508 503/3032 +f 1940/1506 503/3032 1942/1508 +f 125/3013 1943/1513 1945/1514 +f 1946/1511 1945/1514 1943/1513 +f 503/3032 1940/1506 1944/1510 +f 1946/1511 1944/1510 1940/1506 +f 1947/1517 1950/1518 124/3033 +f 1949/1519 124/3033 1950/1518 +f 1944/1510 1950/1518 503/3032 +f 1948/1516 503/3032 1950/1518 +f 133/3021 1900/1459 1951/1521 +f 1952/1520 1951/1521 1900/1459 +f 503/3032 1948/1516 1941/1509 +f 1952/1520 1941/1509 1948/1516 +f 1956/1523 1863/1413 1953/1525 +f 115/3011 1953/1525 1863/1413 +f 506/3034 1955/1526 1954/1522 +f 1956/1523 1954/1522 1955/1526 +f 1957/1529 1960/1530 141/3035 +f 1959/1531 141/3035 1960/1530 +f 1954/1522 1960/1530 506/3034 +f 1958/1528 506/3034 1960/1530 +f 124/3033 1949/1519 1962/1534 +f 1963/1533 1962/1534 1949/1519 +f 506/3034 1958/1528 1961/1532 +f 1963/1533 1961/1532 1958/1528 +f 125/3013 1870/1422 1943/1513 +f 1964/1535 1943/1513 1870/1422 +f 1961/1532 1964/1535 506/3034 +f 1955/1526 506/3034 1964/1535 +f 1969/1537 1968/1541 1965/1539 +f 114/3036 1965/1539 1968/1541 +f 1967/1542 1969/1537 510/3037 +f 1966/1536 510/3037 1969/1537 +f 1970/1546 1973/1544 139/3038 +f 1972/1547 139/3038 1973/1544 +f 510/3037 1966/1536 1971/1543 +f 1973/1544 1971/1543 1966/1536 +f 1962/1534 1976/1549 124/3033 +f 1975/1550 124/3033 1976/1549 +f 1974/1548 510/3037 1976/1549 +f 1971/1543 1976/1549 510/3037 +f 141/3035 1977/1551 1957/1529 +f 1978/1552 1957/1529 1977/1551 +f 1978/1552 1967/1542 1974/1548 +f 510/3037 1974/1548 1967/1542 +f 1912/1472 1982/1554 116/3024 +f 1981/1556 116/3024 1982/1554 +f 1979/1553 512/3039 1982/1554 +f 1980/1557 1982/1554 512/3039 +f 133/3021 1951/1521 1921/1483 +f 1984/1559 1921/1483 1951/1521 +f 1983/1558 512/3039 1984/1559 +f 1979/1553 1984/1559 512/3039 +f 124/3033 1975/1550 1947/1517 +f 1986/1560 1947/1517 1975/1550 +f 1986/1560 1985/1561 1983/1558 +f 512/3039 1983/1558 1985/1561 +f 1988/1562 1970/1546 1987/1563 +f 139/3038 1987/1563 1970/1546 +f 1985/1561 1988/1562 512/3039 +f 1980/1557 512/3039 1988/1562 +f 1926/1489 1992/1565 111/3027 +f 1991/1567 111/3027 1992/1565 +f 1990/1568 1992/1565 516/3040 +f 1989/1564 516/3040 1992/1565 +f 136/3031 1993/1572 1936/1502 +f 1995/1570 1936/1502 1993/1572 +f 516/3040 1989/1564 1994/1569 +f 1995/1570 1994/1569 1989/1564 +f 1996/1575 1999/1576 126/3041 +f 1998/1577 126/3041 1999/1576 +f 1994/1569 1999/1576 516/3040 +f 1997/1574 516/3040 1999/1576 +f 127/3018 2000/1579 2001/1580 +f 2002/1578 2001/1580 2000/1579 +f 516/3040 1997/1574 1990/1568 +f 2002/1578 1990/1568 1997/1574 +f 2007/1582 2006/1585 2003/1584 +f 117/3042 2003/1584 2006/1585 +f 520/3043 2005/1587 2004/1581 +f 2007/1582 2004/1581 2005/1587 +f 2008/1590 2011/1591 138/3044 +f 2010/1592 138/3044 2011/1591 +f 2009/1589 520/3043 2011/1591 +f 2004/1581 2011/1591 520/3043 +f 126/3041 1998/1577 2013/1595 +f 2014/1594 2013/1595 1998/1577 +f 520/3043 2009/1589 2012/1593 +f 2014/1594 2012/1593 2009/1589 +f 2015/1596 2016/1597 136/3031 +f 1993/1572 136/3031 2016/1597 +f 2012/1593 2016/1597 520/3043 +f 2005/1587 520/3043 2016/1597 +f 1968/1541 2020/1598 114/3036 +f 2019/1601 114/3036 2020/1598 +f 2017/1599 523/3045 2020/1598 +f 2018/1600 2020/1598 523/3045 +f 2021/1603 2023/1605 141/3035 +f 1977/1551 141/3035 2023/1605 +f 523/3045 2017/1599 2022/1606 +f 2023/1605 2022/1606 2017/1599 +f 2013/1595 2026/1608 126/3041 +f 2025/1609 126/3041 2026/1608 +f 2022/1606 2026/1608 523/3045 +f 2024/1607 523/3045 2026/1608 +f 138/3044 2027/1611 2008/1590 +f 2028/1610 2008/1590 2027/1611 +f 523/3045 2024/1607 2018/1600 +f 2028/1610 2018/1600 2024/1607 +f 1881/1435 2031/1613 115/3011 +f 1953/1525 115/3011 2031/1613 +f 524/3046 2030/1614 2029/1612 +f 2031/1613 2029/1612 2030/1614 +f 127/3018 2001/1580 1890/1445 +f 2033/1616 1890/1445 2001/1580 +f 2032/1615 524/3046 2033/1616 +f 2029/1612 2033/1616 524/3046 +f 126/3041 2025/1609 1996/1575 +f 2035/1618 1996/1575 2025/1609 +f 524/3046 2032/1615 2034/1617 +f 2035/1618 2034/1617 2032/1615 +f 141/3035 1959/1531 2021/1603 +f 2036/1619 2021/1603 1959/1531 +f 2034/1617 2036/1619 524/3046 +f 2030/1614 524/3046 2036/1619 +f 2041/1621 2040/1624 2037/1623 +f 112/3047 2037/1623 2040/1624 +f 529/3048 2039/1626 2038/1620 +f 2041/1621 2038/1620 2039/1626 +f 140/3049 2042/1629 2044/1631 +f 2045/1630 2044/1631 2042/1629 +f 2043/1628 529/3048 2045/1630 +f 2038/1620 2045/1630 529/3048 +f 130/3050 2046/1635 2048/1636 +f 2049/1633 2048/1636 2046/1635 +f 2049/1633 2047/1632 2043/1628 +f 529/3048 2043/1628 2047/1632 +f 131/3051 2050/1638 2051/1639 +f 2052/1637 2051/1639 2050/1638 +f 2047/1632 2052/1637 529/3048 +f 2039/1626 529/3048 2052/1637 +f 2056/1644 118/3052 2057/1640 +f 2053/1641 2057/1640 118/3052 +f 533/3053 2055/1646 2054/1642 +f 2057/1640 2054/1642 2055/1646 +f 2061/1650 2060/1651 2058/1649 +f 142/3054 2058/1649 2060/1651 +f 2054/1642 2061/1650 533/3053 +f 2059/1648 533/3053 2061/1650 +f 130/3050 2048/1636 2063/1654 +f 2064/1653 2063/1654 2048/1636 +f 533/3053 2059/1648 2062/1652 +f 2064/1653 2062/1652 2059/1648 +f 2065/1655 2066/1656 140/3049 +f 2042/1629 140/3049 2066/1656 +f 2062/1652 2066/1656 533/3053 +f 2055/1646 533/3053 2066/1656 +f 2067/1659 2071/1660 113/3055 +f 2070/1662 113/3055 2071/1660 +f 2069/1663 2071/1660 538/3056 +f 2068/1658 538/3056 2071/1660 +f 135/3057 2072/1664 2074/1668 +f 2075/1666 2074/1668 2072/1664 +f 2075/1666 2073/1667 2068/1658 +f 538/3056 2068/1658 2073/1667 +f 2076/1671 2079/1672 134/3058 +f 2078/1673 134/3058 2079/1672 +f 2073/1667 2079/1672 538/3056 +f 2077/1670 538/3056 2079/1672 +f 137/3059 2080/1674 2081/1676 +f 2082/1675 2081/1676 2080/1674 +f 538/3056 2077/1670 2069/1663 +f 2082/1675 2069/1663 2077/1670 +f 118/3052 2083/1680 2053/1641 +f 2086/1678 2053/1641 2083/1680 +f 541/3060 2085/1681 2084/1677 +f 2086/1678 2084/1677 2085/1681 +f 2081/1676 2089/1683 137/3059 +f 2088/1684 137/3059 2089/1683 +f 2084/1677 2089/1683 541/3060 +f 2087/1682 541/3060 2089/1683 +f 134/3058 2090/1688 2076/1671 +f 2092/1686 2076/1671 2090/1688 +f 541/3060 2087/1682 2091/1685 +f 2092/1686 2091/1685 2087/1682 +f 2060/1651 2094/1689 142/3054 +f 2093/1690 142/3054 2094/1689 +f 2091/1685 2094/1689 541/3060 +f 2085/1681 541/3060 2094/1689 +f 2095/1693 2098/1694 114/3036 +f 1965/1539 114/3036 2098/1694 +f 2097/1695 2098/1694 544/3061 +f 2096/1692 544/3061 2098/1694 +f 118/3052 2056/1644 2100/1698 +f 2101/1697 2100/1698 2056/1644 +f 544/3061 2096/1692 2099/1696 +f 2101/1697 2099/1696 2096/1692 +f 2102/1701 2104/1702 140/3049 +f 2065/1655 140/3049 2104/1702 +f 2099/1696 2104/1702 544/3061 +f 2103/1700 544/3061 2104/1702 +f 139/3038 1972/1547 2105/1704 +f 2106/1703 2105/1704 1972/1547 +f 544/3061 2103/1700 2097/1695 +f 2106/1703 2097/1695 2103/1700 +f 138/3044 2010/1592 2109/1707 +f 2110/1705 2109/1707 2010/1592 +f 2110/1705 2107/1706 2108/1709 +f 547/3062 2108/1709 2107/1706 +f 2111/1711 2113/1710 117/3042 +f 2003/1584 117/3042 2113/1710 +f 2107/1706 2113/1710 547/3062 +f 2112/1712 547/3062 2113/1710 +f 2070/1662 2116/1715 113/3055 +f 2115/1716 113/3055 2116/1715 +f 547/3062 2112/1712 2114/1714 +f 2116/1715 2114/1714 2112/1712 +f 2117/1717 2118/1718 137/3059 +f 2080/1674 137/3059 2118/1718 +f 2108/1709 547/3062 2118/1718 +f 2114/1714 2118/1718 547/3062 +f 132/3026 1916/1479 2121/1721 +f 2122/1720 2121/1721 1916/1479 +f 2122/1720 2119/1719 2120/1723 +f 550/3063 2120/1723 2119/1719 +f 2123/1725 2125/1724 116/3024 +f 1909/1471 116/3024 2125/1724 +f 2119/1719 2125/1724 550/3063 +f 2124/1726 550/3063 2125/1724 +f 2128/1729 2127/1730 2040/1624 +f 112/3047 2040/1624 2127/1730 +f 550/3063 2124/1726 2126/1728 +f 2128/1729 2126/1728 2124/1726 +f 131/3051 2129/1731 2050/1638 +f 2130/1732 2050/1638 2129/1731 +f 2120/1723 550/3063 2130/1732 +f 2126/1728 2130/1732 550/3063 +f 137/3059 2088/1684 2117/1717 +f 2133/1734 2117/1717 2088/1684 +f 551/3064 2132/1735 2131/1733 +f 2133/1734 2131/1733 2132/1735 +f 2100/1698 2135/1737 118/3052 +f 2083/1680 118/3052 2135/1737 +f 2131/1733 2135/1737 551/3064 +f 2134/1736 551/3064 2135/1737 +f 114/3036 2019/1601 2095/1693 +f 2137/1739 2095/1693 2019/1601 +f 551/3064 2134/1736 2136/1738 +f 2137/1739 2136/1738 2134/1736 +f 2109/1707 2138/1740 138/3044 +f 2027/1611 138/3044 2138/1740 +f 2136/1738 2138/1740 551/3064 +f 2132/1735 551/3064 2138/1740 +f 2105/1704 2141/1742 139/3038 +f 1987/1563 139/3038 2141/1742 +f 2140/1743 2141/1742 552/3065 +f 2139/1741 552/3065 2141/1742 +f 140/3049 2044/1631 2102/1701 +f 2143/1745 2102/1701 2044/1631 +f 552/3065 2139/1741 2142/1744 +f 2143/1745 2142/1744 2139/1741 +f 2127/1730 2145/1747 112/3047 +f 2037/1623 112/3047 2145/1747 +f 2142/1744 2145/1747 552/3065 +f 2144/1746 552/3065 2145/1747 +f 116/3024 1981/1556 2123/1725 +f 2146/1748 2123/1725 1981/1556 +f 552/3065 2144/1746 2140/1743 +f 2146/1748 2140/1743 2144/1746 +f 132/3026 2121/1721 2149/1751 +f 2150/1749 2149/1751 2121/1721 +f 2148/1753 2150/1749 556/3066 +f 2147/1750 556/3066 2150/1749 +f 2153/1755 2129/1731 2151/1757 +f 131/3051 2151/1757 2129/1731 +f 556/3066 2147/1750 2152/1754 +f 2153/1755 2152/1754 2147/1750 +f 2154/1760 2157/1761 143/3067 +f 2156/1762 143/3067 2157/1761 +f 2155/1759 556/3066 2157/1761 +f 2152/1754 2157/1761 556/3066 +f 144/3068 2158/1763 2159/1765 +f 2160/1764 2159/1765 2158/1763 +f 2160/1764 2148/1753 2155/1759 +f 556/3066 2155/1759 2148/1753 +f 2159/1767 2164/1766 144/3069 +f 2163/1771 144/3069 2164/1766 +f 2162/1772 2164/1766 560/3070 +f 2161/1768 560/3070 2164/1766 +f 2167/1774 2154/1777 2165/1776 +f 143/3071 2165/1776 2154/1777 +f 560/3070 2161/1768 2166/1773 +f 2167/1774 2166/1773 2161/1768 +f 2168/1780 2171/1781 145/3072 +f 2170/1782 145/3072 2171/1781 +f 2169/1779 560/3070 2171/1781 +f 2166/1773 2171/1781 560/3070 +f 146/3073 2172/1784 2173/1785 +f 2174/1783 2173/1785 2172/1784 +f 560/3070 2169/1779 2162/1772 +f 2174/1783 2162/1772 2169/1779 +f 144/3069 2163/1771 2177/1788 +f 2178/1787 2177/1788 2163/1771 +f 564/3074 2176/1790 2175/1786 +f 2178/1787 2175/1786 2176/1790 +f 2179/1793 2181/1794 146/3073 +f 2172/1784 146/3073 2181/1794 +f 2175/1786 2181/1794 564/3074 +f 2180/1792 564/3074 2181/1794 +f 150/3075 2182/1798 2184/1799 +f 2185/1796 2184/1799 2182/1798 +f 564/3074 2180/1792 2183/1795 +f 2185/1796 2183/1795 2180/1792 +f 2186/1800 2188/1801 149/3076 +f 2187/1802 149/3076 2188/1801 +f 2183/1795 2188/1801 564/3074 +f 2176/1790 564/3074 2188/1801 +f 146/3073 2189/1806 2179/1793 +f 2192/1804 2179/1793 2189/1806 +f 568/3077 2191/1807 2190/1803 +f 2192/1804 2190/1803 2191/1807 +f 147/3078 2193/1811 2195/1812 +f 2196/1809 2195/1812 2193/1811 +f 2190/1803 2196/1809 568/3077 +f 2194/1808 568/3077 2196/1809 +f 2200/1814 2199/1817 2197/1816 +f 151/3079 2197/1816 2199/1817 +f 568/3077 2194/1808 2198/1813 +f 2200/1814 2198/1813 2194/1808 +f 2184/1799 2202/1818 150/3075 +f 2201/1819 150/3075 2202/1818 +f 2198/1813 2202/1818 568/3077 +f 2191/1807 568/3077 2202/1818 +f 2207/1821 2206/1826 2203/1823 +f 152/3080 2203/1823 2206/1826 +f 573/3081 2205/1824 2204/1820 +f 2207/1821 2204/1820 2205/1824 +f 2208/1830 2211/1828 155/3082 +f 2210/1831 155/3082 2211/1828 +f 573/3081 2204/1820 2209/1827 +f 2211/1828 2209/1827 2204/1820 +f 2212/1834 2215/1835 154/3083 +f 2214/1836 154/3083 2215/1835 +f 573/3081 2209/1827 2213/1833 +f 2215/1835 2213/1833 2209/1827 +f 2216/1837 2218/1838 157/3084 +f 2217/1839 157/3084 2218/1838 +f 573/3081 2213/1833 2205/1824 +f 2218/1838 2205/1824 2213/1833 +f 2223/1841 2222/1846 2219/1843 +f 153/3085 2219/1843 2222/1846 +f 578/3086 2221/1844 2220/1840 +f 2223/1841 2220/1840 2221/1844 +f 2224/1850 2227/1848 158/3087 +f 2226/1851 158/3087 2227/1848 +f 578/3086 2220/1840 2225/1847 +f 2227/1848 2225/1847 2220/1840 +f 2228/1854 2231/1855 156/3088 +f 2230/1856 156/3088 2231/1855 +f 2225/1847 2231/1855 578/3086 +f 2229/1853 578/3086 2231/1855 +f 2232/1857 2234/1858 159/3089 +f 2233/1859 159/3089 2234/1858 +f 578/3086 2229/1853 2221/1844 +f 2234/1858 2221/1844 2229/1853 +f 127/3090 2235/1862 2000/1865 +f 2238/1863 2000/1865 2235/1862 +f 2237/1866 2238/1863 581/3091 +f 2236/1861 581/3091 2238/1863 +f 2226/1851 2241/1868 158/3087 +f 2240/1869 158/3087 2241/1868 +f 581/3091 2236/1861 2239/1867 +f 2241/1868 2239/1867 2236/1861 +f 2242/1872 2244/1873 153/3085 +f 2219/1843 153/3085 2244/1873 +f 2239/1867 2244/1873 581/3091 +f 2243/1871 581/3091 2244/1873 +f 2246/1874 2245/1876 1991/1875 +f 111/3092 1991/1875 2245/1876 +f 581/3091 2243/1871 2237/1866 +f 2246/1874 2237/1866 2243/1871 +f 129/3093 2247/1880 2250/1881 +f 2251/1878 2250/1881 2247/1880 +f 585/3094 2249/1883 2248/1877 +f 2251/1878 2248/1877 2249/1883 +f 2233/1859 2254/1885 159/3089 +f 2253/1886 159/3089 2254/1885 +f 2248/1877 2254/1885 585/3094 +f 2252/1884 585/3094 2254/1885 +f 2255/1889 2257/1890 156/3088 +f 2228/1854 156/3088 2257/1890 +f 585/3094 2252/1884 2256/1888 +f 2257/1890 2256/1888 2252/1884 +f 122/3095 2258/1891 2259/1893 +f 2260/1892 2259/1893 2258/1891 +f 2256/1888 2260/1892 585/3094 +f 2249/1883 585/3094 2260/1892 +f 127/3090 1891/1897 2235/1862 +f 2263/1895 2235/1862 1891/1897 +f 586/3096 2262/1898 2261/1894 +f 2263/1895 2261/1894 2262/1898 +f 122/3095 2259/1893 1886/1901 +f 2265/1900 1886/1901 2259/1893 +f 2261/1894 2265/1900 586/3096 +f 2264/1899 586/3096 2265/1900 +f 2230/1856 2267/1903 156/3088 +f 2255/1889 156/3088 2267/1903 +f 586/3096 2264/1899 2266/1902 +f 2267/1903 2266/1902 2264/1899 +f 2240/1869 2268/1904 158/3087 +f 2224/1850 158/3087 2268/1904 +f 2266/1902 2268/1904 586/3096 +f 2262/1898 586/3096 2268/1904 +f 129/3093 1930/1906 2247/1880 +f 2271/1905 2247/1880 1930/1906 +f 2269/1907 587/3097 2271/1905 +f 2270/1909 2271/1905 587/3097 +f 2273/1911 1923/1912 2245/1876 +f 111/3092 2245/1876 1923/1912 +f 2273/1911 2272/1910 2269/1907 +f 587/3097 2269/1907 2272/1910 +f 2222/1846 2275/1914 153/3085 +f 2242/1872 153/3085 2275/1914 +f 2272/1910 2275/1914 587/3097 +f 2274/1913 587/3097 2275/1914 +f 2253/1886 2276/1915 159/3089 +f 2232/1857 159/3089 2276/1915 +f 587/3097 2274/1913 2270/1909 +f 2276/1915 2270/1909 2274/1913 +f 125/3098 1945/1918 2279/1921 +f 2280/1919 2279/1921 1945/1918 +f 2278/1922 2280/1919 590/3099 +f 2277/1917 590/3099 2280/1919 +f 2283/1924 1939/1927 2281/1926 +f 110/3100 2281/1926 1939/1927 +f 590/3099 2277/1917 2282/1923 +f 2283/1924 2282/1923 2277/1917 +f 2206/1826 2286/1929 152/3080 +f 2285/1930 152/3080 2286/1929 +f 2282/1923 2286/1929 590/3099 +f 2284/1928 590/3099 2286/1929 +f 2287/1932 2288/1931 157/3084 +f 2216/1837 157/3084 2288/1931 +f 590/3099 2284/1928 2278/1922 +f 2288/1931 2278/1922 2284/1928 +f 2289/1934 2292/1933 121/3101 +f 1906/1938 121/3101 2292/1933 +f 2291/1939 2292/1933 592/3102 +f 2290/1935 592/3102 2292/1933 +f 2210/1831 2295/1941 155/3082 +f 2294/1942 155/3082 2295/1941 +f 592/3102 2290/1935 2293/1940 +f 2295/1941 2293/1940 2290/1935 +f 2285/1930 2297/1944 152/3080 +f 2203/1823 152/3080 2297/1944 +f 2293/1940 2297/1944 592/3102 +f 2296/1943 592/3102 2297/1944 +f 2281/1926 110/3100 2298/1946 +f 1896/1945 2298/1946 110/3100 +f 2298/1946 2291/1939 2296/1943 +f 592/3102 2296/1943 2291/1939 +f 1874/1949 2302/1950 119/3103 +f 2301/1952 119/3103 2302/1950 +f 2300/1953 2302/1950 594/3104 +f 2299/1948 594/3104 2302/1950 +f 125/3098 2279/1921 1868/1956 +f 2304/1955 1868/1956 2279/1921 +f 594/3104 2299/1948 2303/1954 +f 2304/1955 2303/1954 2299/1948 +f 2217/1839 2306/1958 157/3084 +f 2287/1932 157/3084 2306/1958 +f 2303/1954 2306/1958 594/3104 +f 2305/1957 594/3104 2306/1958 +f 2308/1959 2212/1834 2307/1960 +f 154/3083 2307/1960 2212/1834 +f 594/3104 2305/1957 2300/1953 +f 2308/1959 2300/1953 2305/1957 +f 121/3101 2309/1964 2289/1934 +f 2312/1962 2289/1934 2309/1964 +f 596/3105 2311/1965 2310/1961 +f 2312/1962 2310/1961 2311/1965 +f 119/3103 2301/1952 2314/1968 +f 2315/1967 2314/1968 2301/1952 +f 2310/1961 2315/1967 596/3105 +f 2313/1966 596/3105 2315/1967 +f 2214/1836 2317/1970 154/3083 +f 2307/1960 154/3083 2317/1970 +f 596/3105 2313/1966 2316/1969 +f 2317/1970 2316/1969 2313/1966 +f 2294/1942 2318/1971 155/3082 +f 2208/1830 155/3082 2318/1971 +f 2316/1969 2318/1971 596/3105 +f 2311/1965 596/3105 2318/1971 +f 147/3078 2195/1812 2321/1974 +f 2322/1973 2321/1974 2195/1812 +f 600/3106 2320/1976 2319/1972 +f 2322/1973 2319/1972 2320/1976 +f 2173/1785 2324/1978 146/3073 +f 2189/1806 146/3073 2324/1978 +f 2319/1972 2324/1978 600/3106 +f 2323/1977 600/3106 2324/1978 +f 2327/1980 2168/1780 2325/1982 +f 145/3072 2325/1982 2168/1780 +f 600/3106 2323/1977 2326/1979 +f 2327/1980 2326/1979 2323/1977 +f 2328/1985 2331/1986 162/3107 +f 2330/1987 162/3107 2331/1986 +f 600/3106 2326/1979 2329/1984 +f 2331/1986 2329/1984 2326/1979 +f 160/3108 2332/1989 2333/1990 +f 2334/1988 2333/1990 2332/1989 +f 600/3106 2329/1984 2320/1976 +f 2334/1988 2320/1976 2329/1984 +f 161/3109 2335/1991 2338/1995 +f 2339/1993 2338/1995 2335/1991 +f 2339/1993 2336/1994 2337/1997 +f 605/3110 2337/1997 2336/1994 +f 2343/1999 2342/2002 2340/2001 +f 165/3111 2340/2001 2342/2002 +f 605/3110 2336/1994 2341/1998 +f 2343/1999 2341/1998 2336/1994 +f 2344/2006 2347/2004 166/3112 +f 2346/2007 166/3112 2347/2004 +f 2341/1998 2347/2004 605/3110 +f 2345/2003 605/3110 2347/2004 +f 2349/2010 162/3113 2350/2009 +f 2348/2008 2350/2009 162/3113 +f 2337/1997 605/3110 2350/2009 +f 2345/2003 2350/2009 605/3110 +f 2353/2012 2328/2015 2349/2010 +f 162/3113 2349/2010 2328/2015 +f 608/3114 2352/2013 2351/2011 +f 2353/2012 2351/2011 2352/2013 +f 2354/2018 2356/2019 166/3112 +f 2344/2006 166/3112 2356/2019 +f 2351/2011 2356/2019 608/3114 +f 2355/2017 608/3114 2356/2019 +f 2360/2021 2359/2024 2357/2023 +f 163/3115 2357/2023 2359/2024 +f 608/3114 2355/2017 2358/2020 +f 2360/2021 2358/2020 2355/2017 +f 160/3116 2333/2026 2361/2027 +f 2362/2025 2361/2027 2333/2026 +f 2358/2020 2362/2025 608/3114 +f 2352/2013 608/3114 2362/2025 +f 2366/2029 2365/2030 2359/2024 +f 163/3115 2359/2024 2365/2030 +f 611/3117 2364/2032 2363/2028 +f 2366/2029 2363/2028 2364/2032 +f 2346/2007 2368/2034 166/3112 +f 2354/2018 166/3112 2368/2034 +f 2363/2028 2368/2034 611/3117 +f 2367/2033 611/3117 2368/2034 +f 2369/2038 2371/2036 165/3111 +f 2340/2001 165/3111 2371/2036 +f 611/3117 2367/2033 2370/2035 +f 2371/2036 2370/2035 2367/2033 +f 2373/2041 164/3118 2374/2040 +f 2372/2039 2374/2040 164/3118 +f 2370/2035 2374/2040 611/3117 +f 2364/2032 611/3117 2374/2040 +f 2375/2044 2378/2045 69/3119 +f 1247/2047 69/3119 2378/2045 +f 2377/2048 2378/2045 614/3120 +f 2376/2043 614/3120 2378/2045 +f 131/3051 2051/1639 2380/2051 +f 2381/2050 2380/2051 2051/1639 +f 614/3120 2376/2043 2379/2049 +f 2381/2050 2379/2049 2376/2043 +f 2382/2054 2384/2055 130/3050 +f 2046/1635 130/3050 2384/2055 +f 2379/2049 2384/2055 614/3120 +f 2383/2053 614/3120 2384/2055 +f 76/3121 1254/2057 2385/2058 +f 2386/2056 2385/2058 1254/2057 +f 614/3120 2383/2053 2377/2048 +f 2386/2056 2377/2048 2383/2053 +f 2387/2061 2390/2062 77/3122 +f 1261/2064 77/3122 2390/2062 +f 2388/2060 617/3123 2390/2062 +f 2389/2063 2390/2062 617/3123 +f 142/3054 2093/1690 2392/2068 +f 2393/2067 2392/2068 2093/1690 +f 617/3123 2388/2060 2391/2066 +f 2393/2067 2391/2066 2388/2060 +f 2394/2070 2396/2069 134/3058 +f 2090/1688 134/3058 2396/2069 +f 2391/2066 2396/2069 617/3123 +f 2395/2071 617/3123 2396/2069 +f 2398/2073 2397/2075 1268/2074 +f 80/3124 1268/2074 2397/2075 +f 617/3123 2395/2071 2389/2063 +f 2398/2073 2389/2063 2395/2071 +f 2397/2075 2401/2077 80/3124 +f 1275/2079 80/3124 2401/2077 +f 2399/2076 619/3125 2401/2077 +f 2400/2078 2401/2077 619/3125 +f 134/3058 2078/1673 2394/2070 +f 2403/2081 2394/2070 2078/1673 +f 2403/2081 2402/2082 2399/2076 +f 619/3125 2399/2076 2402/2082 +f 2404/2085 2406/2086 135/3057 +f 2072/1664 135/3057 2406/2086 +f 2405/2084 619/3125 2406/2086 +f 2402/2082 2406/2086 619/3125 +f 2408/2087 2407/2089 1281/2088 +f 81/3126 1281/2088 2407/2089 +f 619/3125 2405/2084 2400/2078 +f 2408/2087 2400/2078 2405/2084 +f 2409/2092 2412/2093 67/3127 +f 1287/2095 67/3127 2412/2093 +f 2411/2096 2412/2093 622/3128 +f 2410/2091 622/3128 2412/2093 +f 2415/2098 2414/2101 2314/2100 +f 119/3014 2314/2100 2414/2101 +f 622/3128 2410/2091 2413/2097 +f 2415/2098 2413/2097 2410/2091 +f 2416/2103 2418/2102 121/3023 +f 2309/2106 121/3023 2418/2102 +f 2417/2104 622/3128 2418/2102 +f 2413/2097 2418/2102 622/3128 +f 2420/2107 2419/2109 1294/2108 +f 68/3129 1294/2108 2419/2109 +f 622/3128 2417/2104 2411/2096 +f 2420/2107 2411/2096 2417/2104 +f 78/3130 2421/2110 1301/2116 +f 2424/2112 1301/2116 2421/2110 +f 2424/2112 2422/2113 2423/2114 +f 625/3131 2423/2114 2422/2113 +f 2250/2119 2427/2120 129/3029 +f 2426/2121 129/3029 2427/2120 +f 2422/2113 2427/2120 625/3131 +f 2425/2118 625/3131 2427/2120 +f 2430/2123 2258/2126 2428/2125 +f 122/3017 2428/2125 2258/2126 +f 625/3131 2425/2118 2429/2122 +f 2430/2123 2429/2122 2425/2118 +f 2431/2129 74/3132 2432/2127 +f 1308/2128 2432/2127 74/3132 +f 2429/2122 2432/2127 625/3131 +f 2423/2114 625/3131 2432/2127 +f 2385/2058 2435/2131 76/3121 +f 1315/2133 76/3121 2435/2131 +f 2434/2132 2435/2131 626/3133 +f 2433/2130 626/3133 2435/2131 +f 130/3050 2063/1654 2382/2054 +f 2437/2135 2382/2054 2063/1654 +f 626/3133 2433/2130 2436/2136 +f 2437/2135 2436/2136 2433/2130 +f 2058/1649 142/3054 2439/2137 +f 2392/2068 2439/2137 142/3054 +f 2436/2136 2439/2137 626/3133 +f 2438/2138 626/3133 2439/2137 +f 2440/2139 2387/2061 1320/2140 +f 77/3122 1320/2140 2387/2061 +f 626/3133 2438/2138 2434/2132 +f 2440/2139 2434/2132 2438/2138 +f 2441/2143 2444/2144 70/3134 +f 1325/2146 70/3134 2444/2144 +f 2443/2147 2444/2144 628/3135 +f 2442/2142 628/3135 2444/2144 +f 143/3067 2156/1762 2446/2150 +f 2447/2148 2446/2150 2156/1762 +f 628/3135 2442/2142 2445/2149 +f 2447/2148 2445/2149 2442/2142 +f 2380/2051 2449/2152 131/3051 +f 2151/1757 131/3051 2449/2152 +f 2445/2149 2449/2152 628/3135 +f 2448/2151 628/3135 2449/2152 +f 69/3119 1331/2153 2375/2044 +f 2450/2154 2375/2044 1331/2153 +f 628/3135 2448/2151 2443/2147 +f 2450/2154 2443/2147 2448/2151 +f 2451/2157 2454/2158 71/2904 +f 1337/746 71/2904 2454/2158 +f 2452/2156 630/3136 2454/2158 +f 2453/2159 2454/2158 630/3136 +f 145/3137 2170/2160 2456/2164 +f 2457/2162 2456/2164 2170/2160 +f 2457/2162 2455/2163 2452/2156 +f 630/3136 2452/2156 2455/2163 +f 2165/2169 143/3138 2459/2165 +f 2446/2166 2459/2165 143/3138 +f 2455/2163 2459/2165 630/3136 +f 2458/2167 630/3136 2459/2165 +f 2460/2170 2441/2171 1343/756 +f 70/2906 1343/756 2441/2171 +f 630/3136 2458/2167 2453/2159 +f 2460/2170 2453/2159 2458/2167 +f 59/2909 2461/2174 1349/766 +f 2464/2175 1349/766 2461/2174 +f 2463/2176 2464/2175 634/3139 +f 2462/2173 634/3139 2464/2175 +f 147/3078 2465/2177 2467/2181 +f 2468/2179 2467/2181 2465/2177 +f 634/3139 2462/2173 2466/2180 +f 2468/2179 2466/2180 2462/2173 +f 2469/2184 2472/2185 148/3140 +f 2471/2186 148/3140 2472/2185 +f 2466/2180 2472/2185 634/3139 +f 2470/2183 634/3139 2472/2185 +f 65/2911 1356/776 2473/2188 +f 2474/2187 2473/2188 1356/776 +f 634/3139 2470/2183 2463/2176 +f 2474/2187 2463/2176 2470/2183 +f 2475/2190 2478/2189 60/2913 +f 1365/785 60/2913 2478/2189 +f 636/3141 2477/2193 2476/2191 +f 2478/2189 2476/2191 2477/2193 +f 2199/1817 2481/2195 151/3079 +f 2480/2196 151/3079 2481/2195 +f 2479/2194 636/3141 2481/2195 +f 2476/2191 2481/2195 636/3141 +f 147/3078 2467/2181 2193/1811 +f 2483/2198 2193/1811 2467/2181 +f 2483/2198 2482/2197 2479/2194 +f 636/3141 2479/2194 2482/2197 +f 2484/2199 2461/2174 1371/794 +f 59/2909 1371/794 2461/2174 +f 2482/2197 2484/2199 636/3141 +f 2477/2193 636/3141 2484/2199 +f 2485/2202 2488/2203 79/3142 +f 1377/2205 79/3142 2488/2203 +f 2486/2201 638/3143 2488/2203 +f 2487/2204 2488/2203 638/3143 +f 128/3030 1934/1501 2490/2209 +f 2491/2208 2490/2209 1934/1501 +f 2491/2208 2489/2207 2486/2201 +f 638/3143 2486/2201 2489/2207 +f 129/3029 2426/2121 1928/1495 +f 2493/2211 1928/1495 2426/2121 +f 2489/2207 2493/2211 638/3143 +f 2492/2210 638/3143 2493/2211 +f 1383/2213 2494/2212 78/3130 +f 2421/2110 78/3130 2494/2212 +f 638/3143 2492/2210 2487/2204 +f 2494/2212 2487/2204 2492/2210 +f 68/3129 2419/2109 1389/2218 +f 2497/2215 1389/2218 2419/2109 +f 640/3144 2496/2216 2495/2214 +f 2497/2215 2495/2214 2496/2216 +f 1907/1467 2499/2220 121/3023 +f 2416/2103 121/3023 2499/2220 +f 2495/2214 2499/2220 640/3144 +f 2498/2219 640/3144 2499/2220 +f 120/3022 2500/2224 1902/1462 +f 2502/2222 1902/1462 2500/2224 +f 640/3144 2498/2219 2501/2221 +f 2502/2222 2501/2221 2498/2219 +f 2503/2227 58/3145 2504/2225 +f 1395/2226 2504/2225 58/3145 +f 2501/2221 2504/2225 640/3144 +f 2496/2216 640/3144 2504/2225 +f 2507/2229 1401/2232 2503/2227 +f 58/3145 2503/2227 1401/2232 +f 642/3146 2506/2230 2505/2228 +f 2507/2229 2505/2228 2506/2230 +f 1919/1482 2509/2234 120/3022 +f 2500/2224 120/3022 2509/2234 +f 2505/2228 2509/2234 642/3146 +f 2508/2233 642/3146 2509/2234 +f 132/3026 2510/2238 1914/1477 +f 2512/2236 1914/1477 2510/2238 +f 642/3146 2508/2233 2511/2235 +f 2512/2236 2511/2235 2508/2233 +f 2513/2241 61/3147 2514/2239 +f 1407/2240 2514/2239 61/3147 +f 2511/2235 2514/2239 642/3146 +f 2506/2230 642/3146 2514/2239 +f 2517/2243 1413/2246 2513/2241 +f 61/3147 2513/2241 1413/2246 +f 644/3148 2516/2244 2515/2242 +f 2517/2243 2515/2242 2516/2244 +f 2149/1751 2519/2247 132/3026 +f 2510/2238 132/3026 2519/2247 +f 2518/2248 644/3148 2519/2247 +f 2515/2242 2519/2247 644/3148 +f 144/3068 2520/2250 2158/1763 +f 2522/2249 2158/1763 2520/2250 +f 2518/2248 2522/2249 644/3148 +f 2521/2251 644/3148 2522/2249 +f 2524/2254 2523/2255 1419/2253 +f 62/3149 1419/2253 2523/2255 +f 644/3148 2521/2251 2516/2244 +f 2524/2254 2516/2244 2521/2251 +f 1425/857 62/2923 2527/2259 +f 2523/2258 2527/2259 62/2923 +f 2526/2260 2527/2259 646/3150 +f 2525/2257 646/3150 2527/2259 +f 144/3069 2177/1788 2520/2263 +f 2529/2262 2520/2263 2177/1788 +f 2529/2262 2528/2261 2525/2257 +f 646/3150 2525/2257 2528/2261 +f 2532/2265 2186/1800 2530/2267 +f 149/3076 2530/2267 2186/1800 +f 2528/2261 2532/2265 646/3150 +f 2531/2264 646/3150 2532/2265 +f 2533/2269 63/2925 2534/2268 +f 1431/866 2534/2268 63/2925 +f 646/3150 2531/2264 2526/2260 +f 2534/2268 2526/2260 2531/2264 +f 2537/2271 1437/875 2533/2269 +f 63/2925 2533/2269 1437/875 +f 648/3151 2536/2272 2535/2270 +f 2537/2271 2535/2270 2536/2272 +f 2187/1802 2539/2274 149/3076 +f 2530/2267 149/3076 2539/2274 +f 2535/2270 2539/2274 648/3151 +f 2538/2273 648/3151 2539/2274 +f 150/3075 2540/2278 2182/1798 +f 2542/2276 2182/1798 2540/2278 +f 648/3151 2538/2273 2541/2275 +f 2542/2276 2541/2275 2538/2273 +f 2543/2280 64/2927 2544/2279 +f 1443/881 2544/2279 64/2927 +f 2541/2275 2544/2279 648/3151 +f 2536/2272 648/3151 2544/2279 +f 2547/2282 1449/887 2543/2280 +f 64/2927 2543/2280 1449/887 +f 2545/2281 649/3152 2547/2282 +f 2546/2283 2547/2282 649/3152 +f 150/3075 2201/1819 2540/2278 +f 2549/2285 2540/2278 2201/1819 +f 2549/2285 2548/2284 2545/2281 +f 649/3152 2545/2281 2548/2284 +f 2480/2196 2551/2287 151/3079 +f 2197/1816 151/3079 2551/2287 +f 2548/2284 2551/2287 649/3152 +f 2550/2286 649/3152 2551/2287 +f 2552/2288 2475/2190 1454/893 +f 60/2913 1454/893 2475/2190 +f 649/3152 2550/2286 2546/2283 +f 2552/2288 2546/2283 2550/2286 +f 1461/899 2555/2289 71/2904 +f 2451/2157 71/2904 2555/2289 +f 651/3153 2554/2291 2553/2290 +f 2555/2289 2553/2290 2554/2291 +f 2558/2293 1470/916 2556/2295 +f 72/2932 2556/2295 1470/916 +f 651/3153 2553/2290 2557/2292 +f 2558/2293 2557/2292 2553/2290 +f 2338/2298 2561/2299 161/3154 +f 2560/2300 161/3154 2561/2299 +f 651/3153 2557/2292 2559/2297 +f 2561/2299 2559/2297 2557/2292 +f 162/3155 2330/2304 2348/2305 +f 2563/2302 2348/2305 2330/2304 +f 651/3153 2559/2297 2562/2301 +f 2563/2302 2562/2301 2559/2297 +f 2456/2164 2564/2306 145/3137 +f 2325/2307 145/3137 2564/2306 +f 651/3153 2562/2301 2554/2291 +f 2564/2306 2554/2291 2562/2301 +f 147/3078 2321/1974 2465/2177 +f 2567/2308 2465/2177 2321/1974 +f 2567/2308 2565/2309 2566/2310 +f 653/3156 2566/2310 2565/2309 +f 2568/2313 2570/2314 160/3108 +f 2332/1989 160/3108 2570/2314 +f 2565/2309 2570/2314 653/3156 +f 2569/2312 653/3156 2570/2314 +f 148/3140 2471/2186 2571/2316 +f 2572/2315 2571/2316 2471/2186 +f 2572/2315 2566/2310 2569/2312 +f 653/3156 2569/2312 2566/2310 +f 2577/2320 2576/2322 2573/2319 +f 170/3157 2573/2319 2576/2322 +f 2575/2323 2577/2320 658/3158 +f 2574/2318 658/3158 2577/2320 +f 2581/2325 2580/2328 2578/2327 +f 167/3159 2578/2327 2580/2328 +f 658/3158 2574/2318 2579/2324 +f 2581/2325 2579/2324 2574/2318 +f 2582/2331 2585/2332 169/3160 +f 2584/2333 169/3160 2585/2332 +f 2579/2324 2585/2332 658/3158 +f 2583/2330 658/3158 2585/2332 +f 2588/2334 2587/2336 2586/2335 +f 168/3161 2586/2335 2587/2336 +f 658/3158 2583/2330 2575/2323 +f 2588/2334 2575/2323 2583/2330 +f 2589/2339 2593/2340 177/3162 +f 2592/2342 177/3162 2593/2340 +f 2590/2338 663/3163 2593/2340 +f 2591/2341 2593/2340 663/3163 +f 178/3164 2594/2346 2596/2348 +f 2597/2347 2596/2348 2594/2346 +f 2597/2347 2595/2345 2590/2338 +f 663/3163 2590/2338 2595/2345 +f 2601/2349 2600/2353 2598/2350 +f 173/3165 2598/2350 2600/2353 +f 2595/2345 2601/2349 663/3163 +f 2599/2351 663/3163 2601/2349 +f 2604/2354 2603/2356 2602/2355 +f 174/3166 2602/2355 2603/2356 +f 663/3163 2599/2351 2591/2341 +f 2604/2354 2591/2341 2599/2351 +f 178/3164 2605/2360 2608/2361 +f 2609/2358 2608/2361 2605/2360 +f 2609/2358 2606/2357 2607/2363 +f 668/3167 2607/2363 2606/2357 +f 2612/2368 179/3168 2613/2364 +f 2610/2365 2613/2364 179/3168 +f 2606/2357 2613/2364 668/3167 +f 2611/2366 668/3167 2613/2364 +f 2617/2370 2616/2373 2614/2372 +f 172/3169 2614/2372 2616/2373 +f 668/3167 2611/2366 2615/2369 +f 2617/2370 2615/2369 2611/2366 +f 2620/2374 2619/2376 2618/2375 +f 171/3170 2618/2375 2619/2376 +f 2607/2363 668/3167 2620/2374 +f 2615/2369 2620/2374 668/3167 +f 174/3166 2603/2356 2623/2380 +f 2624/2377 2623/2380 2603/2356 +f 2622/2381 2624/2377 672/3171 +f 2621/2378 672/3171 2624/2377 +f 2627/2383 2598/2350 2625/2385 +f 173/3165 2625/2385 2598/2350 +f 672/3171 2621/2378 2626/2382 +f 2627/2383 2626/2382 2621/2378 +f 2628/2388 2631/2389 176/3172 +f 2630/2390 176/3172 2631/2389 +f 2629/2387 672/3171 2631/2389 +f 2626/2382 2631/2389 672/3171 +f 2632/2391 2634/2392 175/3173 +f 2633/2393 175/3173 2634/2392 +f 2622/2381 672/3171 2634/2392 +f 2629/2387 2634/2392 672/3171 +f 2637/2397 175/3173 2638/2394 +f 2633/2393 2638/2394 175/3173 +f 2636/2398 2638/2394 675/3174 +f 2635/2395 675/3174 2638/2394 +f 2641/2399 2628/2388 2639/2400 +f 176/3172 2639/2400 2628/2388 +f 2635/2395 2641/2399 675/3174 +f 2640/2401 675/3174 2641/2399 +f 2619/2376 2644/2403 171/3170 +f 2643/2405 171/3170 2644/2403 +f 675/3174 2640/2401 2642/2404 +f 2644/2403 2642/2404 2640/2401 +f 2614/2372 172/3169 2646/2406 +f 2645/2407 2646/2406 172/3169 +f 2642/2404 2646/2406 675/3174 +f 2636/2398 675/3174 2646/2406 +f 177/3162 2647/2410 2589/2339 +f 2650/2411 2589/2339 2647/2410 +f 678/3175 2649/2412 2648/2409 +f 2650/2411 2648/2409 2649/2412 +f 180/3176 2651/2416 2653/2417 +f 2654/2414 2653/2417 2651/2416 +f 678/3175 2648/2409 2652/2413 +f 2654/2414 2652/2413 2648/2409 +f 2656/2420 179/3168 2657/2418 +f 2612/2368 2657/2418 179/3168 +f 2652/2413 2657/2418 678/3175 +f 2655/2419 678/3175 2657/2418 +f 178/3164 2596/2348 2605/2360 +f 2658/2421 2605/2360 2596/2348 +f 2655/2419 2658/2421 678/3175 +f 2649/2412 678/3175 2658/2421 +f 2662/2423 2647/2428 2659/2425 +f 177/3177 2659/2425 2647/2428 +f 681/3178 2661/2426 2660/2422 +f 2662/2423 2660/2422 2661/2426 +f 160/3116 2361/2027 2664/2431 +f 2665/2430 2664/2431 2361/2027 +f 681/3178 2660/2422 2663/2429 +f 2665/2430 2663/2429 2660/2422 +f 2365/2030 2667/2433 163/3115 +f 2357/2023 163/3115 2667/2433 +f 2663/2429 2667/2433 681/3178 +f 2666/2432 681/3178 2667/2433 +f 164/3118 2668/2437 2372/2039 +f 2670/2435 2372/2039 2668/2437 +f 681/3178 2666/2432 2669/2434 +f 2670/2435 2669/2434 2666/2432 +f 2671/2440 180/3179 2672/2439 +f 2653/2438 2672/2439 180/3179 +f 681/3178 2669/2434 2661/2426 +f 2672/2439 2661/2426 2669/2434 +f 179/3180 2656/2441 2675/2445 +f 2676/2443 2675/2445 2656/2441 +f 2676/2443 2673/2444 2674/2447 +f 683/3181 2674/2447 2673/2444 +f 2671/2440 2678/2449 180/3179 +f 2651/2450 180/3179 2678/2449 +f 2677/2448 683/3181 2678/2449 +f 2673/2444 2678/2449 683/3181 +f 2373/2041 2680/2452 164/3118 +f 2668/2437 164/3118 2680/2452 +f 683/3181 2677/2448 2679/2451 +f 2680/2452 2679/2451 2677/2448 +f 2342/2002 2682/2453 165/3111 +f 2369/2038 165/3111 2682/2453 +f 683/3181 2679/2451 2681/2454 +f 2682/2453 2681/2454 2679/2451 +f 2683/2456 2684/2455 161/3109 +f 2335/1991 161/3109 2684/2455 +f 2681/2454 2684/2455 683/3181 +f 2674/2447 683/3181 2684/2455 +f 2616/2459 2688/2460 172/3182 +f 2687/2462 172/3182 2688/2460 +f 685/3183 2686/2463 2685/2458 +f 2688/2460 2685/2458 2686/2463 +f 179/3184 2675/2467 2610/2468 +f 2690/2465 2610/2468 2675/2467 +f 2690/2465 2689/2464 2685/2458 +f 685/3183 2685/2458 2689/2464 +f 2692/2470 2683/2471 2560/2300 +f 161/3154 2560/2300 2683/2471 +f 685/3183 2689/2464 2691/2469 +f 2692/2470 2691/2469 2689/2464 +f 72/2932 1602/1082 2556/2295 +f 2694/2473 2556/2295 1602/1082 +f 685/3183 2691/2469 2693/2472 +f 2694/2473 2693/2472 2691/2469 +f 2696/2474 1597/1077 2695/2475 +f 73/2961 2695/2475 1597/1077 +f 685/3183 2693/2472 2686/2463 +f 2696/2474 2686/2463 2693/2472 +f 1610/1096 2700/2477 66/2963 +f 2699/2478 66/2963 2700/2477 +f 688/3185 2698/2480 2697/2476 +f 2700/2477 2697/2476 2698/2480 +f 2473/2188 2702/2482 65/2911 +f 1621/1110 65/2911 2702/2482 +f 2697/2476 2702/2482 688/3185 +f 2701/2481 688/3185 2702/2482 +f 148/3140 2703/2486 2469/2184 +f 2705/2484 2469/2184 2703/2486 +f 688/3185 2701/2481 2704/2483 +f 2705/2484 2704/2483 2701/2481 +f 2707/2491 174/3186 2708/2488 +f 2623/2490 2708/2488 174/3186 +f 688/3185 2704/2483 2706/2487 +f 2708/2488 2706/2487 2704/2483 +f 2710/2492 2632/2494 2709/2493 +f 175/3187 2709/2493 2632/2494 +f 688/3185 2706/2487 2698/2480 +f 2710/2492 2698/2480 2706/2487 +f 73/2961 1625/1114 2695/2475 +f 2713/2495 2695/2475 1625/1114 +f 2713/2495 2711/2496 2712/2497 +f 689/3188 2712/2497 2711/2496 +f 66/2969 2699/2500 1631/1127 +f 2715/2501 1631/1127 2699/2500 +f 2711/2496 2715/2501 689/3188 +f 2714/2499 689/3188 2715/2501 +f 2717/2503 2709/2506 2637/2505 +f 175/3189 2637/2505 2709/2506 +f 689/3188 2714/2499 2716/2502 +f 2717/2503 2716/2502 2714/2499 +f 172/3182 2687/2462 2645/2508 +f 2718/2507 2645/2508 2687/2462 +f 689/3188 2716/2502 2712/2497 +f 2718/2507 2712/2497 2716/2502 +f 2571/2316 2721/2510 148/3140 +f 2703/2486 148/3140 2721/2510 +f 2720/2511 2721/2510 690/3190 +f 2719/2509 690/3190 2721/2510 +f 160/3108 2664/2512 2568/2313 +f 2723/2514 2568/2313 2664/2512 +f 690/3190 2719/2509 2722/2515 +f 2723/2514 2722/2515 2719/2509 +f 177/3191 2592/2519 2659/2520 +f 2725/2517 2659/2520 2592/2519 +f 690/3190 2722/2515 2724/2516 +f 2725/2517 2724/2516 2722/2515 +f 2726/2521 2602/2522 2707/2491 +f 174/3186 2707/2491 2602/2522 +f 690/3190 2724/2516 2720/2511 +f 2726/2521 2720/2511 2724/2516 +f 2600/2353 2730/2524 173/3165 +f 2729/2526 173/3165 2730/2524 +f 2727/2523 693/3192 2730/2524 +f 2728/2525 2730/2524 693/3192 +f 178/3164 2731/2528 2594/2346 +f 2733/2530 2594/2346 2731/2528 +f 693/3192 2727/2523 2732/2531 +f 2733/2530 2732/2531 2727/2523 +f 2576/2322 2736/2533 170/3157 +f 2735/2534 170/3157 2736/2533 +f 2732/2531 2736/2533 693/3192 +f 2734/2532 693/3192 2736/2533 +f 2737/2535 2738/2536 168/3161 +f 2586/2335 168/3161 2738/2536 +f 2728/2525 693/3192 2738/2536 +f 2734/2532 2738/2536 693/3192 +f 176/3172 2630/2390 2741/2539 +f 2742/2538 2741/2539 2630/2390 +f 2742/2538 2739/2537 2740/2541 +f 695/3193 2740/2541 2739/2537 +f 2625/2385 173/3165 2744/2542 +f 2729/2526 2744/2542 173/3165 +f 2744/2542 2743/2543 2739/2537 +f 695/3193 2739/2537 2743/2543 +f 2587/2336 2746/2545 168/3161 +f 2737/2535 168/3161 2746/2545 +f 2743/2543 2746/2545 695/3193 +f 2745/2544 695/3193 2746/2545 +f 2747/2546 2748/2547 169/3160 +f 2582/2331 169/3160 2748/2547 +f 2740/2541 695/3193 2748/2547 +f 2745/2544 2748/2547 695/3193 +f 171/3170 2643/2405 2751/2551 +f 2752/2549 2751/2551 2643/2405 +f 2749/2548 697/3194 2752/2549 +f 2750/2550 2752/2549 697/3194 +f 176/3172 2741/2539 2639/2400 +f 2754/2553 2639/2400 2741/2539 +f 2754/2553 2753/2554 2749/2548 +f 697/3194 2749/2548 2753/2554 +f 2584/2333 2756/2556 169/3160 +f 2747/2546 169/3160 2756/2556 +f 2753/2554 2756/2556 697/3194 +f 2755/2555 697/3194 2756/2556 +f 2757/2557 2758/2558 167/3159 +f 2578/2327 167/3159 2758/2558 +f 2750/2550 697/3194 2758/2558 +f 2755/2555 2758/2558 697/3194 +f 178/3164 2608/2361 2731/2528 +f 2761/2560 2731/2528 2608/2361 +f 698/3195 2760/2561 2759/2559 +f 2761/2560 2759/2559 2760/2561 +f 2751/2551 2763/2562 171/3170 +f 2618/2375 171/3170 2763/2562 +f 2759/2559 2763/2562 698/3195 +f 2762/2563 698/3195 2763/2562 +f 2580/2328 2765/2565 167/3159 +f 2757/2557 167/3159 2765/2565 +f 2762/2563 2765/2565 698/3195 +f 2764/2564 698/3195 2765/2565 +f 2735/2534 2766/2566 170/3157 +f 2573/2319 170/3157 2766/2566 +f 2764/2564 2766/2566 698/3195 +f 2760/2561 698/3195 2766/2566 +f 123/3196 2767/2567 1883/2573 +f 2770/2569 1883/2573 2767/2567 +f 2770/2569 2768/2570 2769/2571 +f 702/3197 2769/2571 2768/2570 +f 2773/2578 183/3198 2774/2574 +f 2771/2575 2774/2574 183/3198 +f 2768/2570 2774/2574 702/3197 +f 2772/2576 702/3197 2774/2574 +f 2777/2583 182/3199 2778/2579 +f 2775/2580 2778/2579 182/3199 +f 2772/2576 2778/2579 702/3197 +f 2776/2581 702/3197 2778/2579 +f 2780/2584 2779/2586 1888/2585 +f 122/3200 1888/2585 2779/2586 +f 702/3197 2776/2581 2769/2571 +f 2780/2584 2769/2571 2776/2581 +f 2779/2586 2783/2588 122/3200 +f 2428/2590 122/3200 2783/2588 +f 2782/2591 2783/2588 704/3201 +f 2781/2587 704/3201 2783/2588 +f 182/3199 2784/2595 2775/2580 +f 2786/2593 2775/2580 2784/2595 +f 704/3201 2781/2587 2785/2592 +f 2786/2593 2785/2592 2781/2587 +f 1703/1221 2789/2597 100/2983 +f 2788/2598 100/2983 2789/2597 +f 2785/2592 2789/2597 704/3201 +f 2787/2596 704/3201 2789/2597 +f 2790/2599 1698/1215 2431/2600 +f 74/2982 2431/2600 1698/1215 +f 704/3201 2787/2596 2782/2591 +f 2790/2599 2782/2591 2787/2596 +f 67/2984 1709/1228 2409/2603 +f 2793/2602 2409/2603 1709/1228 +f 707/3202 2792/2605 2791/2601 +f 2793/2602 2791/2601 2792/2605 +f 2794/2608 2796/2609 99/2988 +f 1718/1241 99/2988 2796/2609 +f 2791/2601 2796/2609 707/3202 +f 2795/2607 707/3202 2796/2609 +f 181/3203 2797/2610 2799/2614 +f 2800/2612 2799/2614 2797/2610 +f 707/3202 2795/2607 2798/2613 +f 2800/2612 2798/2613 2795/2607 +f 2801/2617 119/3204 2802/2616 +f 2414/2615 2802/2616 119/3204 +f 2798/2613 2802/2616 707/3202 +f 2792/2605 707/3202 2802/2616 +f 119/3204 2801/2617 1872/2621 +f 2805/2619 1872/2621 2801/2617 +f 2804/2620 2805/2619 709/3205 +f 2803/2618 709/3205 2805/2619 +f 2806/2626 2808/2624 181/3203 +f 2797/2610 181/3203 2808/2624 +f 709/3205 2803/2618 2807/2623 +f 2808/2624 2807/2623 2803/2618 +f 2773/2578 2811/2628 183/3198 +f 2810/2629 183/3198 2811/2628 +f 2809/2627 709/3205 2811/2628 +f 2807/2623 2811/2628 709/3205 +f 1877/2631 2812/2630 123/3196 +f 2767/2567 123/3196 2812/2630 +f 2812/2630 2804/2620 2809/2627 +f 709/3205 2809/2627 2804/2620 +f 2815/2633 1731/1260 2788/2598 +f 100/2983 2788/2598 1731/1260 +f 711/3206 2814/2634 2813/2632 +f 2815/2633 2813/2632 2814/2634 +f 2777/2583 2817/2636 182/3199 +f 2784/2595 182/3199 2817/2636 +f 2813/2632 2817/2636 711/3206 +f 2816/2635 711/3206 2817/2636 +f 183/3198 2818/2640 2771/2575 +f 2820/2638 2771/2575 2818/2640 +f 711/3206 2816/2635 2819/2637 +f 2820/2638 2819/2637 2816/2635 +f 75/2991 1737/1267 2821/2642 +f 2822/2641 2821/2642 1737/1267 +f 2819/2637 2822/2641 711/3206 +f 2814/2634 711/3206 2822/2641 +f 75/2991 2821/2642 1743/1273 +f 2825/2644 1743/1273 2821/2642 +f 2824/2645 2825/2644 712/3207 +f 2823/2643 712/3207 2825/2644 +f 183/3198 2810/2629 2818/2640 +f 2827/2647 2818/2640 2810/2629 +f 712/3207 2823/2643 2826/2646 +f 2827/2647 2826/2646 2823/2643 +f 2806/2626 181/3203 2829/2649 +f 2799/2614 2829/2649 181/3203 +f 2826/2646 2829/2649 712/3207 +f 2828/2648 712/3207 2829/2649 +f 2830/2650 2794/2608 1748/1279 +f 99/2988 1748/1279 2794/2608 +f 712/3207 2828/2648 2824/2645 +f 2830/2650 2824/2645 2828/2648 +f 2835/2652 2834/2655 2831/2654 +f 184/3208 2831/2654 2834/2655 +f 2835/2652 2832/2651 2833/2657 +f 716/3209 2833/2657 2832/2651 +f 2838/2662 186/3210 2839/2660 +f 2836/2658 2839/2660 186/3210 +f 2832/2651 2839/2660 716/3209 +f 2837/2661 716/3209 2839/2660 +f 2840/2663 2842/2664 185/3211 +f 2841/2665 185/3211 2842/2664 +f 2837/2661 2842/2664 716/3209 +f 2833/2657 716/3209 2842/2664 +f 2843/2669 2846/2667 184/3208 +f 2831/2654 184/3208 2846/2667 +f 719/3212 2845/2670 2844/2666 +f 2846/2667 2844/2666 2845/2670 +f 2006/1585 2849/2672 117/3042 +f 2848/2673 117/3042 2849/2672 +f 719/3212 2844/2666 2847/2671 +f 2849/2672 2847/2671 2844/2666 +f 136/3031 1937/1504 2015/1596 +f 2851/2675 2015/1596 1937/1504 +f 719/3212 2847/2671 2850/2674 +f 2851/2675 2850/2674 2847/2671 +f 2852/2678 2854/2679 128/3030 +f 1932/1500 128/3030 2854/2679 +f 2850/2674 2854/2679 719/3212 +f 2853/2677 719/3212 2854/2679 +f 186/3210 2838/2662 2855/2681 +f 2856/2680 2855/2681 2838/2662 +f 719/3212 2853/2677 2845/2670 +f 2856/2680 2845/2670 2853/2677 +f 2834/2655 2859/2683 184/3208 +f 2843/2669 184/3208 2859/2683 +f 721/3213 2858/2684 2857/2682 +f 2859/2683 2857/2682 2858/2684 +f 185/3211 2860/2688 2840/2663 +f 2862/2686 2840/2663 2860/2688 +f 721/3213 2857/2682 2861/2685 +f 2862/2686 2861/2685 2857/2682 +f 135/3057 2074/1668 2864/2691 +f 2865/2690 2864/2691 2074/1668 +f 721/3213 2861/2685 2863/2689 +f 2865/2690 2863/2689 2861/2685 +f 2115/1716 2867/2693 113/3055 +f 2067/1659 113/3055 2867/2693 +f 721/3213 2863/2689 2866/2692 +f 2867/2693 2866/2692 2863/2689 +f 117/3042 2848/2673 2111/1711 +f 2868/2694 2111/1711 2848/2673 +f 721/3213 2866/2692 2858/2684 +f 2868/2694 2858/2684 2866/2692 +f 2872/2696 2871/2699 1794/2698 +f 104/3214 1794/2698 2871/2699 +f 723/3215 2870/2701 2869/2695 +f 2872/2696 2869/2695 2870/2701 +f 2407/2089 2874/2703 81/3126 +f 1801/2704 81/3126 2874/2703 +f 2873/2702 723/3215 2874/2703 +f 2869/2695 2874/2703 723/3215 +f 2864/2691 2876/2705 135/3057 +f 2404/2085 135/3057 2876/2705 +f 2876/2705 2875/2706 2873/2702 +f 723/3215 2873/2702 2875/2706 +f 2877/2707 2878/2708 185/3211 +f 2860/2688 185/3211 2878/2708 +f 2875/2706 2878/2708 723/3215 +f 2870/2701 723/3215 2878/2708 +f 1805/2711 2881/2712 79/3142 +f 2485/2202 79/3142 2881/2712 +f 2880/2713 2881/2712 725/3216 +f 2879/2710 725/3216 2881/2712 +f 2884/2715 1812/2718 2882/2717 +f 105/3217 2882/2717 1812/2718 +f 725/3216 2879/2710 2883/2714 +f 2884/2715 2883/2714 2879/2710 +f 2855/2681 2887/2720 186/3210 +f 2886/2721 186/3210 2887/2720 +f 2883/2714 2887/2720 725/3216 +f 2885/2719 725/3216 2887/2720 +f 128/3030 2490/2209 2852/2678 +f 2888/2722 2852/2678 2490/2209 +f 725/3216 2885/2719 2880/2713 +f 2888/2722 2880/2713 2885/2719 +f 2836/2658 186/3210 2892/2726 +f 2889/2725 2892/2726 186/3210 +f 2891/2727 2892/2726 729/3218 +f 2890/2724 729/3218 2892/2726 +f 2896/2729 2895/2732 2893/2731 +f 188/3219 2893/2731 2895/2732 +f 2896/2729 2894/2728 2890/2724 +f 729/3218 2890/2724 2894/2728 +f 2900/2734 2899/2737 2897/2736 +f 187/3220 2897/2736 2899/2737 +f 729/3218 2894/2728 2898/2733 +f 2900/2734 2898/2733 2894/2728 +f 185/3211 2841/2665 2901/2739 +f 2902/2738 2901/2739 2841/2665 +f 2902/2738 2891/2727 2898/2733 +f 729/3218 2898/2733 2891/2727 +f 185/3211 2901/2739 2877/2707 +f 2905/2740 2877/2707 2901/2739 +f 731/3221 2904/2742 2903/2741 +f 2905/2740 2903/2741 2904/2742 +f 2906/2745 2908/2746 187/3220 +f 2897/2736 187/3220 2908/2746 +f 2903/2741 2908/2746 731/3221 +f 2907/2744 731/3221 2908/2746 +f 108/3222 1837/2750 2910/2751 +f 2911/2748 2910/2751 1837/2750 +f 731/3221 2907/2744 2909/2747 +f 2911/2748 2909/2747 2907/2744 +f 2871/2699 2912/2752 104/3214 +f 1832/2753 104/3214 2912/2752 +f 2909/2747 2912/2752 731/3221 +f 2904/2742 731/3221 2912/2752 +f 1843/2756 2915/2757 105/3217 +f 2882/2717 105/3217 2915/2757 +f 2913/2755 733/3223 2915/2757 +f 2914/2758 2915/2757 733/3223 +f 109/3224 2916/2762 1850/2763 +f 2918/2760 1850/2763 2916/2762 +f 2918/2760 2917/2759 2913/2755 +f 733/3223 2913/2755 2917/2759 +f 2920/2766 188/3219 2921/2764 +f 2895/2732 2921/2764 188/3219 +f 2917/2759 2921/2764 733/3223 +f 2919/2765 733/3223 2921/2764 +f 2922/2767 2889/2725 2886/2721 +f 186/3210 2886/2721 2889/2725 +f 733/3223 2919/2765 2914/2758 +f 2922/2767 2914/2758 2919/2765 +f 2925/2769 2906/2745 2899/2737 +f 187/3220 2899/2737 2906/2745 +f 734/3225 2924/2770 2923/2768 +f 2925/2769 2923/2768 2924/2770 +f 2927/2772 2893/2731 2920/2766 +f 188/3219 2920/2766 2893/2731 +f 734/3225 2923/2768 2926/2771 +f 2927/2772 2926/2771 2923/2768 +f 1860/2775 2929/2776 109/3224 +f 2916/2762 109/3224 2929/2776 +f 2926/2771 2929/2776 734/3225 +f 2928/2774 734/3225 2929/2776 +f 2910/2751 2930/2777 108/3222 +f 1856/2778 108/3222 2930/2777 +f 2928/2774 2930/2777 734/3225 +f 2924/2770 734/3225 2930/2777 diff --git a/docs/tutorials/data/cow_mesh/cow_texture.png b/docs/tutorials/data/cow_mesh/cow_texture.png new file mode 100755 index 00000000..63094487 Binary files /dev/null and b/docs/tutorials/data/cow_mesh/cow_texture.png differ diff --git a/docs/tutorials/data/teapot.obj b/docs/tutorials/data/teapot.obj new file mode 100644 index 00000000..c861018b --- /dev/null +++ b/docs/tutorials/data/teapot.obj @@ -0,0 +1,5046 @@ +v -0.498530 0.712498 -0.039883 +v -0.501666 0.699221 -0.063813 +v -0.501255 0.717792 0.000000 +v -0.624036 0.711938 -0.039883 +v -0.526706 0.651362 -0.039883 +v -0.508714 0.682112 -0.071712 +v -0.622039 0.698704 -0.063813 +v -0.624834 0.717232 0.000000 +v -0.498530 0.712498 0.039883 +v -0.638129 0.287158 0.000000 +v -0.517593 0.664661 -0.063813 +v -0.534329 0.646030 0.000000 +v -0.614850 0.651067 -0.039883 +v -0.616848 0.664299 -0.063813 +v -0.619445 0.681503 -0.071790 +v -0.741245 0.707456 -0.039883 +v -0.744483 0.712577 0.000000 +v -0.624036 0.711938 0.039883 +v -0.501667 0.699221 0.063813 +v -0.622039 0.698704 0.063813 +v -0.712095 0.661370 -0.063813 +v -0.733150 0.694655 -0.063813 +v -0.741245 0.707456 0.039883 +v -0.733150 0.694655 0.063813 +v -0.631184 0.277569 -0.039883 +v -0.526706 0.651362 0.039883 +v -0.614053 0.645774 0.000000 +v -0.704000 0.648569 -0.039883 +v -0.722621 0.678012 -0.071790 +v -0.832523 0.695296 -0.039883 +v -0.837545 0.699948 0.000000 +v -0.832523 0.695296 0.039883 +v -0.619445 0.681503 0.071790 +v -0.508714 0.682112 0.071712 +v -0.722621 0.678012 0.071790 +v -0.517593 0.664661 0.063813 +v -0.619922 0.238069 -0.071790 +v -0.624826 0.259599 -0.063813 +v -0.710066 0.328372 0.000000 +v -0.614850 0.651067 0.039883 +v -0.787321 0.653419 -0.063813 +v -0.803644 0.668539 -0.071790 +v -0.819967 0.683663 -0.063813 +v -0.819967 0.683663 0.063813 +v -0.803644 0.668539 0.071790 +v -0.711425 0.307332 -0.063813 +v -0.615553 0.216807 -0.063813 +v -0.712688 0.287795 -0.071790 +v -0.631184 0.277569 0.039883 +v -0.710455 0.322361 -0.039883 +v -0.710455 0.322361 0.039883 +v -0.700762 0.643448 0.000000 +v -0.774766 0.641786 -0.039883 +v -0.897800 0.671612 -0.039883 +v -0.904015 0.675354 0.000000 +v -0.897800 0.671612 0.039883 +v -0.882265 0.662257 0.063813 +v -0.712095 0.661370 0.063813 +v -0.787321 0.653419 0.063813 +v -0.608884 0.198682 -0.039883 +v -0.624828 0.259599 0.063813 +v -0.766936 0.377559 0.000000 +v -0.769651 0.372307 0.039883 +v -0.616848 0.664299 0.063813 +v -0.704000 0.648569 0.039883 +v -0.841868 0.637931 -0.063813 +v -0.862065 0.650094 -0.071790 +v -0.882265 0.662257 -0.063813 +v -0.862065 0.650094 0.071790 +v -0.841868 0.637931 0.063813 +v -0.611709 0.194244 0.000000 +v -0.776434 0.359177 -0.063813 +v -0.769651 0.372307 -0.039883 +v -0.713952 0.268259 -0.063813 +v -0.711425 0.307332 0.063813 +v -0.776434 0.359177 0.063813 +v -0.769743 0.637131 0.000000 +v -0.826329 0.628576 -0.039883 +v -0.937016 0.632565 -0.039883 +v -0.943899 0.634805 0.000000 +v -0.937016 0.632565 0.039883 +v -0.919812 0.626965 0.063813 +v -0.897443 0.619684 0.071790 +v -0.774766 0.641786 0.039883 +v -0.826329 0.628576 0.039883 +v -0.714922 0.253231 -0.039883 +v -0.608883 0.198681 0.039883 +v -0.715311 0.247220 0.000000 +v -0.785253 0.342107 -0.071790 +v -0.619922 0.238069 0.071790 +v -0.712688 0.287795 0.071790 +v -0.809626 0.430737 0.000000 +v -0.814205 0.426194 0.039883 +v -0.825653 0.414838 0.063813 +v -0.875076 0.612403 -0.063813 +v -0.897443 0.619684 -0.071790 +v -0.919812 0.626965 -0.063813 +v -0.875076 0.612403 0.063813 +v -0.857869 0.606800 0.039883 +v -0.794072 0.325038 -0.063813 +v -0.800855 0.311909 -0.039883 +v -0.825653 0.414838 -0.063813 +v -0.814205 0.426194 -0.039883 +v -0.615480 0.216617 0.063578 +v -0.785253 0.342107 0.071790 +v -0.840534 0.400078 0.071790 +v -0.820114 0.624834 0.000000 +v -0.857869 0.606800 -0.039883 +v -0.950104 0.574316 -0.039883 +v -0.957194 0.574316 0.000000 +v -0.950104 0.574316 0.039883 +v -0.932377 0.574316 0.063813 +v -0.909334 0.574316 0.071790 +v -0.886292 0.574316 0.063813 +v -0.850987 0.604560 0.000000 +v -0.714922 0.253231 0.039883 +v -0.803571 0.306656 0.000000 +v -0.840534 0.400078 -0.071790 +v -0.713952 0.268259 0.063813 +v -0.794072 0.325038 0.063813 +v -0.839022 0.483916 0.000000 +v -0.844976 0.480304 0.039883 +v -0.859854 0.471278 0.063813 +v -0.879202 0.459542 0.071790 +v -0.886292 0.574316 -0.063813 +v -0.909334 0.574316 -0.071790 +v -0.932377 0.574316 -0.063813 +v -0.868564 0.574316 0.039883 +v -0.861474 0.574316 0.000000 +v -0.855419 0.385315 -0.063813 +v -0.866867 0.373960 -0.039883 +v -0.859854 0.471278 -0.063813 +v -0.844976 0.480304 -0.039883 +v -0.855419 0.385315 0.063813 +v -0.898547 0.447807 0.063813 +v -0.868564 0.574316 -0.039883 +v -0.941014 0.505765 -0.039883 +v -0.947813 0.503580 0.000000 +v -0.941014 0.505765 0.039883 +v -0.924011 0.511234 0.063813 +v -0.901913 0.518343 0.071790 +v -0.879811 0.525448 0.063813 +v -0.862808 0.530917 0.039883 +v -0.800855 0.311909 0.039883 +v -0.871445 0.369416 0.000000 +v -0.879202 0.459542 -0.071790 +v -0.866867 0.373960 0.039883 +v -0.856009 0.533103 0.000000 +v -0.879811 0.525448 -0.063813 +v -0.901913 0.518343 -0.071790 +v -0.924011 0.511234 -0.063813 +v -0.862808 0.530917 -0.039883 +v -0.898547 0.447807 -0.063813 +v -0.913428 0.438781 -0.039883 +v -0.913428 0.438781 0.039883 +v -0.919378 0.435169 0.000000 +v 0.600960 0.444810 0.085753 +v 0.605956 0.463769 0.000000 +v 0.600959 0.444810 -0.085753 +v 0.656890 0.471064 0.000000 +v 0.661223 0.454734 -0.083705 +v 0.730696 0.501576 -0.073611 +v 0.661223 0.454734 0.083705 +v 0.605101 0.399712 -0.137265 +v 0.746455 0.470391 -0.117778 +v 0.724395 0.514048 0.000000 +v 0.605100 0.399712 0.137265 +v 0.672055 0.413907 -0.133928 +v 0.613258 0.341675 -0.154354 +v 0.786583 0.544847 -0.096783 +v 0.768856 0.565896 -0.060489 +v 0.672055 0.413907 0.133928 +v 0.730696 0.501576 0.073611 +v 0.686135 0.360830 -0.150669 +v 0.809626 0.517481 -0.108881 +v 0.766935 0.429850 -0.132501 +v 0.761767 0.574316 0.000000 +v 0.613258 0.341675 0.154354 +v 0.813417 0.626247 -0.075788 +v 0.839021 0.611098 -0.085261 +v 0.793721 0.637899 -0.047367 +v 0.686135 0.360830 0.150669 +v 0.768856 0.565896 0.060489 +v 0.746455 0.470391 0.117778 +v 0.619427 0.283145 -0.137236 +v 0.864627 0.595949 -0.075788 +v 0.832669 0.490118 -0.096783 +v 0.787419 0.389310 -0.117778 +v 0.785843 0.642561 0.000000 +v 0.619427 0.283145 0.137236 +v 0.700219 0.307756 -0.133928 +v 0.847933 0.703560 -0.059638 +v 0.879938 0.698065 -0.067092 +v 0.911944 0.692571 -0.059638 +v 0.823314 0.707784 -0.037273 +v 0.766935 0.429850 0.132501 +v 0.793721 0.637899 0.047367 +v 0.786583 0.544847 0.096783 +v 0.700219 0.307756 0.133928 +v 0.617684 0.235930 -0.085941 +v 0.936563 0.688344 -0.037273 +v 0.884319 0.584297 -0.047367 +v 0.850396 0.469070 -0.060489 +v 0.803175 0.358128 -0.073611 +v 0.813468 0.709475 0.000000 +v 0.617684 0.235930 0.085941 +v 0.625577 0.219883 0.000000 +v 0.711051 0.266929 -0.083705 +v 0.911107 0.765755 -0.053178 +v 0.957193 0.765755 -0.059825 +v 1.003279 0.765755 -0.053178 +v 1.038733 0.765755 -0.033236 +v 0.875654 0.765755 -0.033236 +v 0.809626 0.517481 0.108881 +v 0.787419 0.389310 0.117778 +v 0.823314 0.707784 0.037273 +v 0.813417 0.626247 0.075788 +v 0.711051 0.266929 0.083705 +v 0.715384 0.250599 0.000000 +v 1.052913 0.765755 0.000000 +v 0.946409 0.686653 0.000000 +v 0.892200 0.579635 0.000000 +v 0.857486 0.460650 0.000000 +v 0.809479 0.345652 0.000000 +v 0.861474 0.765755 0.000000 +v 0.929990 0.776479 -0.051602 +v 0.979075 0.777181 -0.058052 +v 1.028157 0.777879 -0.051602 +v 1.065915 0.778419 -0.032251 +v 1.081016 0.778632 0.000000 +v 0.892235 0.775943 -0.032251 +v 0.839021 0.611098 0.085261 +v 0.832669 0.490118 0.096783 +v 0.803175 0.358128 0.073611 +v 0.875654 0.765755 0.033236 +v 0.847933 0.703560 0.059638 +v 1.065915 0.778419 0.032174 +v 1.038733 0.765755 0.033236 +v 0.936563 0.688344 0.037273 +v 0.884319 0.584297 0.047367 +v 0.850396 0.469070 0.060489 +v 0.877131 0.775726 0.000000 +v 0.943713 0.783087 -0.047663 +v 0.992645 0.784366 -0.053621 +v 1.041577 0.785649 -0.047663 +v 1.079216 0.786631 -0.029789 +v 1.094273 0.787027 0.000000 +v 1.079216 0.786631 0.029174 +v 0.906073 0.782101 -0.029789 +v 0.879938 0.698065 0.067092 +v 0.864627 0.595949 0.075788 +v 0.892235 0.775943 0.032236 +v 0.911107 0.765755 0.053178 +v 1.041577 0.785649 0.046875 +v 1.028157 0.777879 0.051503 +v 1.003279 0.765755 0.053178 +v 0.911944 0.692571 0.059638 +v 0.891016 0.781708 0.000000 +v 0.951249 0.785448 -0.042542 +v 0.997575 0.787068 -0.047860 +v 1.043903 0.788686 -0.042542 +v 1.079539 0.789934 -0.026589 +v 1.093795 0.790431 0.000000 +v 1.079539 0.789934 0.024511 +v 1.043903 0.788686 0.039883 +v 0.915613 0.784200 -0.026589 +v 0.957193 0.765755 0.059825 +v 0.906073 0.782101 0.029666 +v 0.929990 0.776479 0.051553 +v 0.997575 0.787068 0.045616 +v 0.992645 0.784366 0.052956 +v 0.979075 0.777181 0.057969 +v 0.901357 0.783702 0.000000 +v 0.951569 0.783431 -0.037421 +v 0.993532 0.785033 -0.042099 +v 1.035492 0.786631 -0.037421 +v 1.067772 0.787863 -0.023388 +v 1.080684 0.788354 0.000000 +v 1.067772 0.787863 0.018464 +v 1.035492 0.786631 0.031119 +v 0.993532 0.785033 0.036781 +v 0.919292 0.782200 -0.023388 +v 0.915613 0.784200 0.026173 +v 0.943713 0.783087 0.047269 +v 0.951569 0.783431 0.034270 +v 0.951249 0.785448 0.041213 +v 0.906379 0.781708 0.000000 +v 0.943653 0.776909 -0.033482 +v 0.980182 0.778010 -0.037667 +v 1.016712 0.779111 -0.033482 +v 1.044812 0.779957 -0.020926 +v 1.056052 0.780295 0.000000 +v 1.044812 0.779957 0.011310 +v 1.016712 0.779111 0.021172 +v 0.980182 0.778010 0.027281 +v 0.943653 0.776909 0.027327 +v 0.915553 0.776064 -0.020926 +v 0.919292 0.782200 0.022403 +v 0.915553 0.776064 0.019003 +v 0.904312 0.775726 0.000000 +v 0.926468 0.765755 -0.031906 +v 0.957193 0.765755 -0.035895 +v 0.987920 0.765755 -0.031906 +v 1.011552 0.765755 -0.019942 +v 1.021006 0.765755 0.000000 +v 1.011552 0.765755 0.003324 +v 0.987920 0.765755 0.010635 +v 0.957193 0.765755 0.017947 +v 0.926468 0.765755 0.021271 +v 0.902834 0.765755 0.016618 +v 0.902834 0.765755 -0.019942 +v 0.893380 0.765755 0.000000 +v 0.886428 0.750924 -0.019014 +v 0.908324 0.750924 -0.030099 +v 0.936793 0.750924 -0.033795 +v 0.965261 0.750924 -0.030099 +v 0.987158 0.750924 -0.019014 +v 0.995918 0.750924 -0.000537 +v 0.987158 0.750924 0.002542 +v 0.965261 0.750924 0.009317 +v 0.936793 0.750924 0.016092 +v 0.908324 0.750924 0.019171 +v 0.886428 0.750924 0.014860 +v 0.877668 0.750924 -0.000537 +v 0.936793 0.750924 -0.007312 +v 0.440746 0.783205 0.000000 +v 0.446690 0.765755 0.000000 +v 0.430973 0.765755 0.119945 +v 0.425236 0.783205 0.118348 +v 0.425236 0.783205 -0.118348 +v 0.453011 0.750009 0.000000 +v 0.437073 0.750009 0.121642 +v 0.441668 0.793673 0.000000 +v 0.386470 0.765755 0.226985 +v 0.430973 0.765755 -0.119945 +v 0.426127 0.793673 -0.118596 +v 0.437073 0.750009 -0.121642 +v 0.426127 0.793673 0.118596 +v 0.381327 0.783205 0.223964 +v 0.381327 0.783205 -0.223964 +v 0.382124 0.793673 -0.224433 +v 0.317150 0.765755 0.317150 +v 0.391939 0.750009 0.230197 +v 0.321638 0.750009 0.321639 +v 0.386470 0.765755 -0.226985 +v 0.391939 0.750009 -0.230197 +v 0.447686 0.797164 0.000000 +v 0.431936 0.797164 -0.120212 +v 0.387332 0.797164 -0.227491 +v 0.230197 0.750009 0.391940 +v 0.226984 0.765755 0.386470 +v 0.317150 0.765755 -0.317150 +v 0.321638 0.750009 -0.321639 +v 0.431936 0.797164 0.120212 +v 0.382124 0.793673 0.224433 +v 0.312929 0.783205 0.312929 +v 0.313584 0.793673 -0.313584 +v 0.312929 0.783205 -0.312929 +v 0.317858 0.797164 -0.317858 +v 0.121642 0.750009 0.437072 +v 0.119944 0.765755 0.430973 +v 0.226984 0.765755 -0.386470 +v 0.230197 0.750009 -0.391940 +v 0.457031 0.793673 0.000000 +v 0.440950 0.793673 -0.122721 +v 0.395416 0.793673 -0.232239 +v 0.324491 0.793673 -0.324492 +v -0.000000 0.750009 0.453012 +v -0.000000 0.765755 0.446690 +v 0.223963 0.783205 0.381327 +v 0.223963 0.783205 -0.381327 +v 0.119944 0.765755 -0.430973 +v 0.121642 0.750009 -0.437072 +v 0.440950 0.793673 0.122721 +v 0.387332 0.797164 0.227491 +v 0.313584 0.793673 0.313584 +v 0.227491 0.797164 -0.387332 +v 0.224433 0.793673 -0.382125 +v 0.232239 0.793673 -0.395417 +v -0.119945 0.765755 0.430973 +v -0.121642 0.750009 0.437072 +v 0.118348 0.783205 0.425237 +v 0.118348 0.783205 -0.425237 +v -0.000000 0.750009 -0.453012 +v -0.000000 0.765755 -0.446690 +v 0.467924 0.783205 0.000000 +v 0.451460 0.783205 -0.125646 +v 0.404842 0.783205 -0.237775 +v 0.332226 0.783205 -0.332226 +v 0.237775 0.783205 -0.404842 +v -0.226985 0.765755 0.386470 +v -0.000000 0.783205 0.440746 +v 0.224433 0.793673 0.382125 +v 0.118596 0.793673 -0.426127 +v -0.000000 0.783205 -0.440746 +v -0.119945 0.765755 -0.430973 +v -0.121642 0.750009 -0.437072 +v 0.451460 0.783205 0.125646 +v 0.395416 0.793673 0.232239 +v 0.317858 0.797164 0.317858 +v 0.122721 0.793673 -0.440950 +v 0.120212 0.797164 -0.431937 +v 0.125646 0.783205 -0.451460 +v -0.317150 0.765755 0.317150 +v -0.230198 0.750009 0.391939 +v -0.321639 0.750009 0.321639 +v -0.118348 0.783205 0.425237 +v 0.118596 0.793673 0.426127 +v -0.000000 0.793673 -0.441668 +v -0.118348 0.783205 -0.425237 +v -0.226985 0.765755 -0.386470 +v 0.478596 0.765755 0.000000 +v 0.461756 0.765755 -0.128512 +v 0.414076 0.765755 -0.243198 +v 0.339803 0.765755 -0.339804 +v 0.243198 0.765755 -0.414076 +v 0.128512 0.765755 -0.461757 +v -0.391940 0.750009 0.230197 +v -0.386470 0.765755 0.226985 +v -0.223964 0.783205 0.381327 +v -0.000000 0.793673 0.441668 +v 0.227491 0.797164 0.387332 +v -0.000000 0.797164 -0.447686 +v -0.118596 0.793673 -0.426127 +v -0.223964 0.783205 -0.381327 +v -0.317150 0.765755 -0.317150 +v -0.230198 0.750009 -0.391939 +v -0.321639 0.750009 -0.321639 +v 0.461756 0.765755 0.128512 +v 0.404842 0.783205 0.237775 +v 0.324491 0.793673 0.324492 +v -0.000000 0.783205 -0.467924 +v -0.000000 0.793673 -0.457031 +v -0.000000 0.765755 -0.478597 +v -0.437073 0.750009 0.121642 +v -0.430974 0.765755 0.119945 +v -0.312929 0.783205 0.312929 +v -0.118596 0.793673 0.426127 +v 0.120212 0.797164 0.431937 +v -0.120212 0.797164 -0.431937 +v -0.224433 0.793673 -0.382125 +v -0.312929 0.783205 -0.312929 +v -0.386470 0.765755 -0.226985 +v -0.391940 0.750009 -0.230197 +v 0.518110 0.682112 0.000000 +v 0.499881 0.682112 -0.139122 +v 0.448260 0.682112 -0.263277 +v 0.367859 0.682112 -0.367859 +v 0.263277 0.682112 -0.448260 +v 0.139122 0.682112 -0.499882 +v -0.000000 0.682112 -0.518110 +v -0.453012 0.750009 0.000000 +v -0.446690 0.765755 0.000000 +v -0.381327 0.783205 0.223964 +v -0.224433 0.793673 0.382125 +v -0.000000 0.797164 0.447686 +v 0.232239 0.793673 0.395417 +v -0.122721 0.793673 -0.440950 +v -0.227491 0.797164 -0.387332 +v -0.313584 0.793673 -0.313584 +v -0.381327 0.783205 -0.223964 +v -0.430974 0.765755 -0.119945 +v 0.499881 0.682112 0.139122 +v 0.414076 0.765755 0.243198 +v 0.332226 0.783205 0.332226 +v -0.128513 0.765755 -0.461757 +v -0.125646 0.783205 -0.451460 +v -0.139123 0.682112 -0.499882 +v -0.437073 0.750009 -0.121642 +v -0.425237 0.783205 0.118348 +v -0.313584 0.793673 0.313584 +v -0.120212 0.797164 0.431937 +v 0.122721 0.793673 0.440950 +v -0.232240 0.793673 -0.395417 +v -0.317859 0.797164 -0.317858 +v -0.382125 0.793673 -0.224433 +v -0.425237 0.783205 -0.118348 +v 0.555408 0.599133 0.000000 +v 0.535865 0.599133 -0.149137 +v 0.480530 0.599133 -0.282230 +v 0.394341 0.599133 -0.394341 +v 0.282230 0.599133 -0.480530 +v 0.149137 0.599133 -0.535866 +v -0.000000 0.599133 -0.555408 +v -0.149138 0.599133 -0.535866 +v -0.440746 0.783205 0.000000 +v -0.382125 0.793673 0.224433 +v -0.227491 0.797164 0.387332 +v -0.000000 0.793673 0.457031 +v 0.237775 0.783205 0.404842 +v -0.237775 0.783205 -0.404842 +v -0.324492 0.793673 -0.324492 +v -0.387332 0.797164 -0.227491 +v -0.426127 0.793673 -0.118596 +v 0.535865 0.599133 0.149137 +v 0.448260 0.682112 0.263277 +v 0.339803 0.765755 0.339804 +v -0.263278 0.682112 -0.448260 +v -0.243198 0.765755 -0.414076 +v -0.282230 0.599133 -0.480530 +v -0.426127 0.793673 0.118596 +v -0.317859 0.797164 0.317858 +v -0.122721 0.793673 0.440950 +v 0.125646 0.783205 0.451460 +v -0.332226 0.783205 -0.332226 +v -0.395417 0.793673 -0.232239 +v -0.431937 0.797164 -0.120212 +v -0.441668 0.793673 0.000000 +v 0.588275 0.517481 0.000000 +v 0.567578 0.517481 -0.157963 +v 0.508969 0.517485 -0.298931 +v 0.417675 0.517481 -0.417675 +v 0.298931 0.517485 -0.508969 +v 0.157963 0.517485 -0.567578 +v -0.000000 0.517481 -0.588275 +v -0.157963 0.517481 -0.567578 +v -0.298931 0.517485 -0.508969 +v -0.387332 0.797164 0.227491 +v -0.232240 0.793673 0.395417 +v -0.000000 0.783205 0.467924 +v 0.243198 0.765755 0.414076 +v -0.339804 0.765755 -0.339804 +v -0.404842 0.783205 -0.237775 +v -0.440950 0.793673 -0.122721 +v -0.447686 0.797164 0.000000 +v 0.567578 0.517485 0.157963 +v 0.480530 0.599133 0.282230 +v 0.367859 0.682112 0.367859 +v -0.394341 0.599133 -0.394341 +v -0.367859 0.682112 -0.367859 +v -0.417675 0.517481 -0.417675 +v -0.431937 0.797164 0.120212 +v -0.324492 0.793673 0.324492 +v -0.125646 0.783205 0.451460 +v 0.128512 0.765755 0.461757 +v -0.414076 0.765755 -0.243198 +v -0.451461 0.783205 -0.125646 +v -0.457031 0.793673 0.000000 +v 0.592873 0.437827 -0.165003 +v 0.531651 0.437827 -0.312254 +v 0.436292 0.437827 -0.436292 +v 0.312254 0.437827 -0.531651 +v 0.165003 0.437827 -0.592873 +v -0.000000 0.437827 -0.614496 +v -0.165004 0.437827 -0.592873 +v -0.312255 0.437827 -0.531651 +v -0.436292 0.437827 -0.436292 +v -0.395417 0.793673 0.232239 +v -0.237775 0.783205 0.404842 +v -0.000000 0.765755 0.478597 +v 0.263277 0.682112 0.448260 +v -0.448260 0.682112 -0.263277 +v -0.461757 0.765755 -0.128512 +v -0.467924 0.783205 0.000000 +v -0.440950 0.793673 0.122721 +v 0.592873 0.437827 0.165003 +v 0.508969 0.517485 0.298931 +v 0.394341 0.599133 0.394341 +v -0.508969 0.517485 -0.298931 +v -0.480530 0.599133 -0.282230 +v -0.531651 0.437827 -0.312254 +v -0.332226 0.783205 0.332226 +v -0.128513 0.765755 0.461757 +v 0.139122 0.682112 0.499882 +v -0.499882 0.682112 -0.139122 +v -0.478597 0.765755 0.000000 +v -0.451461 0.783205 0.125646 +v 0.546669 0.360830 -0.321075 +v 0.448614 0.360830 -0.448614 +v 0.321074 0.360830 -0.546669 +v 0.169664 0.360830 -0.609621 +v -0.000000 0.360830 -0.631850 +v -0.169664 0.360830 -0.609621 +v -0.321075 0.360830 -0.546669 +v -0.448615 0.360830 -0.448614 +v -0.546669 0.360830 -0.321075 +v -0.404842 0.783205 0.237775 +v -0.243198 0.765755 0.414076 +v -0.000000 0.682112 0.518110 +v 0.282230 0.599133 0.480530 +v -0.535866 0.599133 -0.149137 +v -0.461757 0.765755 0.128512 +v 0.531651 0.437827 0.312254 +v 0.417675 0.517481 0.417675 +v 0.609621 0.360830 -0.169664 +v -0.592873 0.437827 -0.165003 +v -0.567578 0.517485 -0.157963 +v -0.609621 0.360830 -0.169664 +v -0.339804 0.765755 0.339804 +v -0.139123 0.682112 0.499882 +v 0.149137 0.599133 0.535866 +v -0.555408 0.599133 0.000000 +v -0.499882 0.682112 0.139122 +v -0.414076 0.765755 0.243198 +v 0.609621 0.360830 0.169664 +v 0.552100 0.287158 -0.324265 +v 0.453072 0.287158 -0.453072 +v 0.324265 0.287158 -0.552100 +v 0.171349 0.287158 -0.615677 +v -0.000000 0.287158 -0.638129 +v -0.171350 0.287158 -0.615677 +v -0.324265 0.287158 -0.552100 +v -0.453072 0.287158 -0.453072 +v -0.552100 0.287158 -0.324265 +v -0.615677 0.287158 -0.171349 +v -0.263278 0.682112 0.448260 +v -0.000000 0.599133 0.555408 +v 0.298931 0.517485 0.508969 +v -0.588275 0.517481 0.000000 +v -0.448260 0.682112 0.263277 +v 0.546669 0.360830 0.321075 +v 0.436292 0.437827 0.436292 +v 0.615677 0.287158 -0.171349 +v -0.631850 0.360830 0.000000 +v -0.614496 0.437827 0.000000 +v -0.367859 0.682112 0.367859 +v -0.149138 0.599133 0.535866 +v 0.157963 0.517481 0.567578 +v -0.567578 0.517481 0.157963 +v -0.480530 0.599133 0.282230 +v 0.615677 0.287158 0.171349 +v 0.541877 0.221240 -0.318259 +v 0.444680 0.221240 -0.444680 +v 0.318259 0.221240 -0.541877 +v 0.168176 0.221240 -0.604276 +v -0.000000 0.221240 -0.626311 +v -0.168177 0.221240 -0.604276 +v -0.318259 0.221240 -0.541877 +v -0.444680 0.221240 -0.444680 +v -0.541877 0.221240 -0.318259 +v -0.604277 0.221240 -0.168176 +v -0.282230 0.599133 0.480530 +v -0.000000 0.517481 0.588275 +v 0.312254 0.437827 0.531651 +v -0.592873 0.437827 0.165003 +v -0.535866 0.599133 0.149137 +v -0.394341 0.599133 0.394341 +v 0.552100 0.287158 0.324265 +v 0.448614 0.360830 0.448614 +v 0.604276 0.221240 -0.168176 +v -0.615677 0.287158 0.171349 +v -0.609621 0.360830 0.169664 +v -0.157963 0.517485 0.567578 +v 0.165003 0.437827 0.592873 +v -0.531651 0.437827 0.312254 +v -0.508969 0.517485 0.298931 +v -0.417675 0.517481 0.417675 +v 0.604276 0.221240 0.168176 +v 0.516317 0.166623 -0.303247 +v 0.423705 0.166623 -0.423705 +v 0.303247 0.166623 -0.516317 +v 0.160243 0.166623 -0.575771 +v -0.000000 0.166623 -0.596769 +v -0.160244 0.166623 -0.575771 +v -0.303247 0.166623 -0.516317 +v -0.423705 0.166623 -0.423705 +v -0.516317 0.166623 -0.303247 +v -0.575771 0.166623 -0.160243 +v -0.298931 0.517485 0.508969 +v -0.000000 0.437827 0.614496 +v 0.321074 0.360830 0.546669 +v -0.546669 0.360830 0.321075 +v 0.541877 0.221240 0.318259 +v 0.453072 0.287158 0.453072 +v 0.575771 0.166623 -0.160243 +v -0.596769 0.166623 0.000000 +v -0.604277 0.221240 0.168176 +v -0.552100 0.287158 0.324265 +v -0.165004 0.437827 0.592873 +v 0.169664 0.360830 0.609621 +v -0.448615 0.360830 0.448614 +v -0.436292 0.437827 0.436292 +v -0.312255 0.437827 0.531651 +v 0.575771 0.166623 0.160243 +v 0.483086 0.122640 -0.283731 +v 0.396438 0.122640 -0.396438 +v 0.283731 0.122640 -0.483086 +v 0.149931 0.122640 -0.538718 +v -0.000000 0.122640 -0.558363 +v -0.149931 0.122640 -0.538718 +v -0.283731 0.122640 -0.483086 +v -0.396438 0.122640 -0.396438 +v -0.483087 0.122640 -0.283731 +v -0.538718 0.122640 -0.149931 +v -0.558363 0.122640 0.000000 +v -0.541877 0.221240 0.318259 +v -0.000000 0.360830 0.631850 +v 0.324265 0.287158 0.552100 +v -0.453072 0.287158 0.453072 +v 0.516317 0.166623 0.303247 +v 0.596768 0.166623 0.000000 +v 0.444680 0.221240 0.444680 +v 0.538718 0.122640 -0.149931 +v -0.538718 0.122640 0.149931 +v -0.516317 0.166623 0.303247 +v -0.444680 0.221240 0.444680 +v -0.169664 0.360830 0.609621 +v 0.171349 0.287158 0.615677 +v -0.324265 0.287158 0.552100 +v -0.321075 0.360830 0.546669 +v 0.538718 0.122640 0.149931 +v 0.558363 0.122640 0.000000 +v 0.449858 0.088629 -0.264215 +v 0.369171 0.088629 -0.369171 +v 0.264215 0.088629 -0.449859 +v 0.139618 0.088629 -0.501662 +v -0.000000 0.088629 -0.519957 +v -0.139618 0.088629 -0.501662 +v -0.264215 0.088629 -0.449859 +v -0.369171 0.088629 -0.369171 +v -0.449859 0.088629 -0.264215 +v -0.501662 0.088629 -0.139618 +v -0.519957 0.088629 0.000000 +v -0.501662 0.088629 0.139618 +v -0.575771 0.166623 0.160243 +v -0.423705 0.166623 0.423705 +v -0.000000 0.287158 0.638129 +v 0.318259 0.221240 0.541877 +v -0.318259 0.221240 0.541877 +v 0.483086 0.122640 0.283731 +v 0.423705 0.166623 0.423705 +v 0.501662 0.088629 -0.139618 +v -0.449859 0.088629 0.264215 +v -0.483087 0.122640 0.283731 +v -0.396438 0.122640 0.396438 +v -0.303247 0.166623 0.516317 +v -0.171350 0.287158 0.615677 +v 0.168176 0.221240 0.604276 +v -0.168177 0.221240 0.604276 +v 0.501662 0.088629 0.139618 +v 0.519957 0.088629 0.000000 +v 0.424299 0.063924 -0.249203 +v 0.348195 0.063924 -0.348195 +v 0.249203 0.063924 -0.424298 +v 0.131685 0.063924 -0.473160 +v -0.000000 0.063924 -0.490415 +v -0.131686 0.063924 -0.473160 +v -0.249203 0.063924 -0.424298 +v -0.348196 0.063924 -0.348195 +v -0.424299 0.063924 -0.249203 +v -0.473160 0.063924 -0.131685 +v -0.490415 0.063924 0.000000 +v -0.473160 0.063924 0.131685 +v -0.424299 0.063924 0.249203 +v -0.283731 0.122640 0.483086 +v -0.000000 0.221240 0.626311 +v 0.303247 0.166623 0.516317 +v -0.160244 0.166623 0.575771 +v 0.449858 0.088629 0.264215 +v 0.396438 0.122640 0.396438 +v 0.473160 0.063924 -0.131685 +v -0.348196 0.063924 0.348195 +v -0.369171 0.088629 0.369171 +v -0.264215 0.088629 0.449859 +v -0.149931 0.122640 0.538718 +v 0.160243 0.166623 0.575771 +v -0.000000 0.166623 0.596769 +v 0.473160 0.063924 0.131685 +v 0.490415 0.063924 0.000000 +v 0.414076 0.047860 -0.243198 +v 0.339803 0.047860 -0.339804 +v 0.243198 0.047860 -0.414076 +v 0.128512 0.047860 -0.461757 +v -0.000000 0.047860 -0.478597 +v -0.128513 0.047860 -0.461757 +v -0.243198 0.047860 -0.414076 +v -0.339804 0.047860 -0.339804 +v -0.414076 0.047860 -0.243198 +v -0.461757 0.047860 -0.128512 +v -0.478597 0.047860 0.000000 +v -0.461757 0.047860 0.128512 +v -0.414076 0.047860 0.243198 +v -0.339804 0.047860 0.339804 +v -0.139618 0.088629 0.501662 +v 0.283731 0.122640 0.483086 +v -0.000000 0.122640 0.558363 +v 0.424299 0.063924 0.249203 +v 0.369171 0.088629 0.369171 +v 0.461756 0.047860 -0.128512 +v -0.243198 0.047860 0.414076 +v -0.249203 0.063924 0.424298 +v -0.131686 0.063924 0.473160 +v -0.000000 0.088629 0.519957 +v 0.149931 0.122640 0.538718 +v 0.461756 0.047860 0.128512 +v 0.478596 0.047860 0.000000 +v 0.410719 0.036005 -0.241228 +v 0.337050 0.036005 -0.337050 +v 0.241227 0.036005 -0.410719 +v 0.127471 0.036005 -0.458017 +v -0.000000 0.036005 -0.474720 +v -0.127471 0.036005 -0.458017 +v -0.241228 0.036005 -0.410719 +v -0.337051 0.036005 -0.337050 +v -0.410719 0.036005 -0.241228 +v -0.458017 0.036005 -0.127471 +v -0.474721 0.036005 0.000000 +v -0.458017 0.036005 0.127471 +v -0.410719 0.036005 0.241228 +v -0.337051 0.036005 0.337050 +v -0.241228 0.036005 0.410719 +v -0.000000 0.063924 0.490415 +v 0.264215 0.088629 0.449859 +v 0.139618 0.088629 0.501662 +v 0.414076 0.047860 0.243198 +v 0.348195 0.063924 0.348195 +v 0.458017 0.036005 -0.127471 +v -0.127471 0.036005 0.458017 +v -0.128513 0.047860 0.461757 +v -0.000000 0.047860 0.478597 +v 0.131685 0.063924 0.473160 +v 0.458017 0.036005 0.127471 +v 0.474720 0.036005 0.000000 +v 0.394137 0.024816 -0.231489 +v 0.323442 0.024816 -0.323442 +v 0.231489 0.024816 -0.394137 +v 0.122324 0.024816 -0.439524 +v -0.000000 0.024816 -0.455554 +v -0.122325 0.024816 -0.439524 +v -0.231489 0.024816 -0.394137 +v -0.323442 0.024816 -0.323442 +v -0.394137 0.024816 -0.231489 +v -0.439524 0.024816 -0.122325 +v -0.455554 0.024816 0.000000 +v -0.439524 0.024816 0.122325 +v -0.394137 0.024816 0.231489 +v -0.323442 0.024816 0.323442 +v -0.231489 0.024816 0.394137 +v -0.122325 0.024816 0.439524 +v 0.128512 0.047860 0.461757 +v 0.249203 0.063924 0.424298 +v 0.410719 0.036005 0.241228 +v 0.339803 0.047860 0.339804 +v 0.439524 0.024816 -0.122325 +v -0.000000 0.036005 0.474720 +v -0.000000 0.024816 0.455554 +v 0.127471 0.036005 0.458017 +v 0.243198 0.047860 0.414076 +v 0.439524 0.024816 0.122325 +v 0.455554 0.024816 0.000000 +v 0.354551 0.014956 -0.208238 +v 0.290957 0.014956 -0.290957 +v 0.208238 0.014956 -0.354551 +v 0.110038 0.014956 -0.395378 +v -0.000000 0.014956 -0.409797 +v -0.110038 0.014956 -0.395378 +v -0.208239 0.014956 -0.354551 +v -0.290957 0.014956 -0.290957 +v -0.354551 0.014956 -0.208238 +v -0.395378 0.014956 -0.110038 +v -0.409797 0.014956 0.000000 +v -0.395378 0.014956 0.110038 +v -0.354551 0.014956 0.208238 +v -0.290957 0.014956 0.290957 +v -0.208239 0.014956 0.354551 +v -0.110038 0.014956 0.395378 +v -0.000000 0.014956 0.409797 +v 0.241227 0.036005 0.410719 +v 0.337050 0.036005 0.337050 +v 0.394137 0.024816 0.231489 +v 0.395378 0.014956 -0.110038 +v 0.122324 0.024816 0.439524 +v 0.110038 0.014956 0.395378 +v 0.231489 0.024816 0.394137 +v 0.395378 0.014956 0.110038 +v 0.409797 0.014956 0.000000 +v 0.282184 0.007090 -0.165735 +v 0.231570 0.007090 -0.231570 +v 0.165735 0.007090 -0.282185 +v 0.087579 0.007090 -0.314679 +v -0.000000 0.007090 -0.326154 +v -0.087579 0.007090 -0.314679 +v -0.165735 0.007090 -0.282185 +v -0.231570 0.007090 -0.231570 +v -0.282184 0.007090 -0.165735 +v -0.314679 0.007090 -0.087579 +v -0.326155 0.007090 0.000000 +v -0.314679 0.007090 0.087579 +v -0.282184 0.007090 0.165735 +v -0.231570 0.007090 0.231570 +v -0.165735 0.007090 0.282185 +v -0.087579 0.007090 0.314679 +v -0.000000 0.007090 0.326154 +v 0.087579 0.007090 0.314679 +v 0.323442 0.024816 0.323442 +v 0.354551 0.014956 0.208238 +v 0.314679 0.007090 -0.087579 +v 0.208238 0.014956 0.354551 +v 0.165735 0.007090 0.282185 +v 0.290957 0.014956 0.290957 +v 0.314679 0.007090 0.087579 +v 0.326154 0.007090 0.000000 +v 0.167259 0.001883 -0.098236 +v 0.137258 0.001883 -0.137259 +v 0.098236 0.001883 -0.167259 +v 0.051910 0.001883 -0.186520 +v -0.000000 0.001883 -0.193322 +v -0.051911 0.001883 -0.186520 +v -0.098237 0.001883 -0.167259 +v -0.137259 0.001883 -0.137259 +v -0.167259 0.001883 -0.098236 +v -0.186520 0.001883 -0.051911 +v -0.193323 0.001883 0.000000 +v -0.186520 0.001883 0.051911 +v -0.167259 0.001883 0.098236 +v -0.137259 0.001883 0.137259 +v -0.098237 0.001883 0.167259 +v -0.051911 0.001883 0.186520 +v -0.000000 0.001883 0.193322 +v 0.051910 0.001883 0.186520 +v 0.098236 0.001883 0.167259 +v 0.282184 0.007090 0.165735 +v 0.186520 0.001883 -0.051911 +v 0.231570 0.007090 0.231570 +v 0.137258 0.001883 0.137259 +v 0.186520 0.001883 0.051911 +v 0.193322 0.001883 0.000000 +v -0.000000 0.000000 0.000000 +v 0.167259 0.001883 0.098236 +v 0.063813 0.861474 0.000000 +v 0.054654 0.888729 0.000000 +v 0.052734 0.888729 0.014691 +v 0.061568 0.861474 0.017135 +v 0.061568 0.861474 -0.017135 +v 0.072979 0.919969 0.020357 +v 0.111968 0.841089 0.000000 +v 0.047296 0.888729 0.027792 +v 0.052734 0.888729 -0.014691 +v 0.108028 0.841089 -0.030065 +v 0.075630 0.919969 0.000000 +v 0.065466 0.919969 0.038494 +v 0.108028 0.841089 0.030065 +v 0.055210 0.861474 0.032427 +v 0.055210 0.861474 -0.032427 +v 0.096873 0.841089 -0.056896 +v 0.100064 0.951211 0.027927 +v 0.089769 0.951211 0.052799 +v 0.183167 0.826023 0.000000 +v 0.176722 0.826023 -0.049184 +v 0.038821 0.888729 0.038821 +v 0.053751 0.919969 0.053751 +v 0.047296 0.888729 -0.027792 +v 0.072979 0.919969 -0.020357 +v 0.158473 0.826023 -0.093076 +v 0.103696 0.951211 0.000000 +v 0.073714 0.951211 0.073714 +v 0.176722 0.826023 0.049184 +v 0.096873 0.841089 0.056896 +v 0.045307 0.861474 0.045307 +v 0.079497 0.841089 -0.079497 +v 0.045307 0.861474 -0.045307 +v 0.130048 0.826023 -0.130048 +v 0.111754 0.978466 0.031195 +v 0.100259 0.978466 0.058974 +v 0.082330 0.978466 0.082330 +v 0.263228 0.813615 0.000000 +v 0.253966 0.813615 -0.070682 +v 0.227741 0.813615 -0.133759 +v 0.027792 0.888729 0.047296 +v 0.038494 0.919969 0.065466 +v 0.052799 0.951211 0.089769 +v 0.038821 0.888729 -0.038821 +v 0.065466 0.919969 -0.038494 +v 0.100064 0.951211 -0.027927 +v 0.186892 0.813615 -0.186892 +v 0.115809 0.978466 0.000000 +v 0.058974 0.978466 0.100259 +v 0.253966 0.813615 0.070682 +v 0.158473 0.826023 0.093076 +v 0.079497 0.841089 0.079497 +v 0.032426 0.861474 0.055210 +v 0.093076 0.826023 -0.158473 +v 0.056896 0.841089 -0.096873 +v 0.032426 0.861474 -0.055210 +v 0.133759 0.813615 -0.227741 +v 0.085811 0.997741 0.023955 +v 0.076985 0.997741 0.045285 +v 0.063219 0.997741 0.063219 +v 0.045285 0.997741 0.076986 +v 0.337972 0.801206 0.000000 +v 0.326081 0.801206 -0.090752 +v 0.292408 0.801206 -0.171740 +v 0.239960 0.801206 -0.239960 +v 0.014691 0.888729 0.052735 +v 0.020357 0.919969 0.072979 +v 0.027927 0.951211 0.100064 +v 0.031195 0.978466 0.111754 +v 0.027792 0.888729 -0.047296 +v 0.053751 0.919969 -0.053751 +v 0.089769 0.951211 -0.052799 +v 0.111754 0.978466 -0.031195 +v 0.171740 0.801206 -0.292408 +v 0.088924 0.997741 0.000000 +v 0.023955 0.997741 0.085811 +v 0.326081 0.801206 0.090752 +v 0.227741 0.813615 0.133759 +v 0.130048 0.826023 0.130048 +v 0.056896 0.841089 0.096873 +v 0.017135 0.861474 0.061568 +v 0.070682 0.813615 -0.253966 +v 0.049184 0.826023 -0.176722 +v 0.030065 0.841089 -0.108029 +v 0.017135 0.861474 -0.061568 +v 0.090752 0.801206 -0.326081 +v -0.000000 1.005054 0.000000 +v 0.393218 0.786140 0.000000 +v 0.379380 0.786140 -0.105586 +v 0.340206 0.786140 -0.199813 +v 0.279184 0.786140 -0.279184 +v 0.199813 0.786140 -0.340206 +v -0.000000 0.888729 0.054654 +v -0.000000 0.919969 0.075630 +v -0.000000 0.951211 0.103696 +v -0.000000 0.978466 0.115809 +v -0.000000 0.997741 0.088925 +v 0.014691 0.888729 -0.052735 +v 0.038494 0.919969 -0.065466 +v 0.073714 0.951211 -0.073714 +v 0.100259 0.978466 -0.058974 +v 0.085811 0.997741 -0.023955 +v 0.105586 0.786140 -0.379381 +v 0.379380 0.786140 0.105586 +v 0.292408 0.801206 0.171740 +v 0.186892 0.813615 0.186892 +v 0.093076 0.826023 0.158473 +v 0.030065 0.841089 0.108029 +v -0.000000 0.861474 0.063813 +v -0.000000 0.801206 -0.337972 +v -0.000000 0.813615 -0.263228 +v -0.000000 0.826023 -0.183167 +v -0.000000 0.841089 -0.111968 +v -0.000000 0.861474 -0.063813 +v -0.000000 0.786140 -0.393218 +v 0.076985 0.997741 -0.045285 +v -0.023955 0.997741 0.085811 +v 0.414784 0.765755 0.000000 +v 0.400190 0.765755 -0.111377 +v 0.358865 0.765755 -0.210772 +v 0.294497 0.765755 -0.294497 +v 0.210772 0.765755 -0.358865 +v 0.111377 0.765755 -0.400190 +v -0.014691 0.888729 0.052735 +v -0.020357 0.919969 0.072979 +v -0.027927 0.951211 0.100064 +v -0.031195 0.978466 0.111754 +v -0.000000 0.888729 -0.054654 +v 0.020357 0.919969 -0.072979 +v 0.052799 0.951211 -0.089769 +v 0.082330 0.978466 -0.082330 +v -0.000000 0.765755 -0.414784 +v 0.063219 0.997741 -0.063219 +v -0.045285 0.997741 0.076986 +v 0.400190 0.765755 0.111377 +v 0.340206 0.786140 0.199813 +v 0.239960 0.801206 0.239960 +v 0.133759 0.813615 0.227741 +v 0.049184 0.826023 0.176722 +v -0.000000 0.841089 0.111968 +v -0.017135 0.861474 0.061568 +v -0.105586 0.786140 -0.379381 +v -0.090752 0.801206 -0.326081 +v -0.070682 0.813615 -0.253966 +v -0.049184 0.826023 -0.176722 +v -0.030066 0.841089 -0.108029 +v -0.017135 0.861474 -0.061568 +v -0.111377 0.765755 -0.400190 +v 0.045285 0.997741 -0.076986 +v -0.063220 0.997741 0.063219 +v 0.414952 0.750806 0.115486 +v 0.430085 0.750806 0.000000 +v 0.414952 0.750806 -0.115486 +v 0.372103 0.750806 -0.218547 +v 0.305360 0.750806 -0.305360 +v 0.218547 0.750806 -0.372103 +v 0.115486 0.750806 -0.414952 +v -0.000000 0.750806 -0.430085 +v -0.027793 0.888729 0.047296 +v -0.038494 0.919969 0.065466 +v -0.052799 0.951211 0.089769 +v -0.058974 0.978466 0.100259 +v -0.014691 0.888729 -0.052735 +v -0.000000 0.919969 -0.075630 +v 0.027927 0.951211 -0.100064 +v 0.058974 0.978466 -0.100259 +v -0.115486 0.750806 -0.414952 +v 0.023955 0.997741 -0.085811 +v -0.076986 0.997741 0.045285 +v 0.372103 0.750806 0.218547 +v 0.358865 0.765755 0.210772 +v 0.279184 0.786140 0.279184 +v 0.171740 0.801206 0.292408 +v 0.070682 0.813615 0.253966 +v -0.000000 0.826023 0.183167 +v -0.030066 0.841089 0.108029 +v -0.032427 0.861474 0.055210 +v -0.210772 0.765755 -0.358865 +v -0.199813 0.786140 -0.340206 +v -0.171740 0.801206 -0.292408 +v -0.133759 0.813615 -0.227741 +v -0.093076 0.826023 -0.158473 +v -0.056896 0.841089 -0.096873 +v -0.032427 0.861474 -0.055210 +v -0.218547 0.750806 -0.372103 +v 0.031195 0.978466 -0.111754 +v -0.000000 0.997741 -0.088925 +v -0.082331 0.978466 0.082330 +v -0.085811 0.997741 0.023955 +v 0.305360 0.750806 0.305360 +v 0.294497 0.765755 0.294497 +v -0.038821 0.888729 0.038821 +v -0.053751 0.919969 0.053751 +v -0.073714 0.951211 0.073714 +v -0.027793 0.888729 -0.047296 +v -0.020357 0.919969 -0.072979 +v -0.000000 0.951211 -0.103696 +v -0.305360 0.750806 -0.305360 +v -0.294497 0.765755 -0.294497 +v -0.000000 0.978466 -0.115809 +v -0.023955 0.997741 -0.085811 +v -0.100259 0.978466 0.058974 +v -0.088925 0.997741 0.000000 +v 0.210772 0.765755 0.358865 +v 0.218547 0.750806 0.372103 +v 0.199813 0.786140 0.340206 +v 0.090752 0.801206 0.326081 +v -0.000000 0.813615 0.263228 +v -0.049184 0.826023 0.176722 +v -0.056896 0.841089 0.096873 +v -0.045307 0.861474 0.045307 +v -0.279185 0.786140 -0.279184 +v -0.239960 0.801206 -0.239960 +v -0.186892 0.813615 -0.186892 +v -0.130049 0.826023 -0.130048 +v -0.079497 0.841089 -0.079497 +v -0.045307 0.861474 -0.045307 +v -0.372103 0.750806 -0.218547 +v -0.358865 0.765755 -0.210772 +v -0.031195 0.978466 -0.111754 +v -0.045285 0.997741 -0.076986 +v -0.111754 0.978466 0.031195 +v -0.085811 0.997741 -0.023955 +v 0.111377 0.765755 0.400190 +v 0.115486 0.750806 0.414952 +v -0.047296 0.888729 0.027792 +v -0.065466 0.919969 0.038494 +v -0.089770 0.951211 0.052799 +v -0.038821 0.888729 -0.038821 +v -0.038494 0.919969 -0.065466 +v -0.027927 0.951211 -0.100064 +v -0.414952 0.750806 -0.115486 +v -0.400190 0.765755 -0.111377 +v -0.058974 0.978466 -0.100259 +v -0.063220 0.997741 -0.063219 +v -0.115809 0.978466 0.000000 +v -0.076986 0.997741 -0.045285 +v 0.105586 0.786140 0.379381 +v -0.000000 0.765755 0.414784 +v -0.000000 0.750806 0.430085 +v -0.000000 0.801206 0.337972 +v -0.070682 0.813615 0.253966 +v -0.093076 0.826023 0.158473 +v -0.079497 0.841089 0.079497 +v -0.055210 0.861474 0.032427 +v -0.340206 0.786140 -0.199813 +v -0.292408 0.801206 -0.171740 +v -0.227741 0.813615 -0.133759 +v -0.158473 0.826023 -0.093076 +v -0.096873 0.841089 -0.056896 +v -0.055210 0.861474 -0.032427 +v -0.430085 0.750806 0.000000 +v -0.414784 0.765755 0.000000 +v -0.052799 0.951211 -0.089769 +v -0.082331 0.978466 -0.082330 +v -0.100064 0.951211 0.027927 +v -0.111754 0.978466 -0.031195 +v -0.000000 0.786140 0.393218 +v -0.115486 0.750806 0.414952 +v -0.111377 0.765755 0.400190 +v -0.052735 0.888729 0.014691 +v -0.072979 0.919969 0.020357 +v -0.047296 0.888729 -0.027792 +v -0.053751 0.919969 -0.053751 +v -0.414952 0.750806 0.115486 +v -0.400190 0.765755 0.111377 +v -0.379381 0.786140 -0.105586 +v -0.073714 0.951211 -0.073714 +v -0.100259 0.978466 -0.058974 +v -0.103696 0.951211 0.000000 +v -0.105586 0.786140 0.379381 +v -0.218547 0.750806 0.372103 +v -0.210772 0.765755 0.358865 +v -0.090752 0.801206 0.326081 +v -0.133759 0.813615 0.227741 +v -0.130049 0.826023 0.130048 +v -0.096873 0.841089 0.056896 +v -0.061568 0.861474 0.017135 +v -0.326081 0.801206 -0.090752 +v -0.253966 0.813615 -0.070682 +v -0.176722 0.826023 -0.049184 +v -0.108029 0.841089 -0.030065 +v -0.061568 0.861474 -0.017135 +v -0.372103 0.750806 0.218547 +v -0.358865 0.765755 0.210772 +v -0.393219 0.786140 0.000000 +v -0.089770 0.951211 -0.052799 +v -0.100064 0.951211 -0.027927 +v -0.199813 0.786140 0.340206 +v -0.305360 0.750806 0.305360 +v -0.294497 0.765755 0.294497 +v -0.054655 0.888729 0.000000 +v -0.075630 0.919969 0.000000 +v -0.052735 0.888729 -0.014691 +v -0.065466 0.919969 -0.038494 +v -0.379381 0.786140 0.105586 +v -0.171740 0.801206 0.292408 +v -0.279185 0.786140 0.279184 +v -0.186892 0.813615 0.186892 +v -0.158473 0.826023 0.093076 +v -0.108029 0.841089 0.030065 +v -0.063813 0.861474 0.000000 +v -0.337972 0.801206 0.000000 +v -0.263228 0.813615 0.000000 +v -0.183167 0.826023 0.000000 +v -0.111968 0.841089 0.000000 +v -0.340206 0.786140 0.199813 +v -0.072979 0.919969 -0.020357 +v -0.239960 0.801206 0.239960 +v -0.326081 0.801206 0.090752 +v -0.292408 0.801206 0.171740 +v -0.227741 0.813615 0.133759 +v -0.176722 0.826023 0.049184 +v -0.253966 0.813615 0.070682 +v -0.526706 0.651362 -0.039883 +v -0.534329 0.646030 0.000000 +v -0.619922 0.238069 -0.071790 +v -0.624826 0.259599 -0.063813 +v -0.638129 0.287158 0.000000 +v -0.631184 0.277569 0.039883 +v -0.501666 0.699221 -0.063813 +v -0.508714 0.682112 -0.071712 +v -0.611709 0.194244 0.000000 +v -0.608883 0.198681 0.039883 +v -0.517593 0.664661 0.063813 +v -0.508714 0.682112 0.071712 +v -0.631184 0.277569 -0.039883 +v -0.624828 0.259599 0.063813 +v -0.615480 0.216617 0.063578 +v -0.615553 0.216807 -0.063813 +v -0.517593 0.664661 -0.063813 +v -0.498530 0.712498 -0.039883 +v -0.619922 0.238069 0.071790 +v -0.526706 0.651362 0.039883 +v -0.608884 0.198682 -0.039883 +v 0.605100 0.399712 0.137265 +v 0.613258 0.341675 0.154354 +v 0.605956 0.463769 0.000000 +v 0.600959 0.444810 -0.085753 +v 0.613258 0.341675 -0.154354 +v 0.605101 0.399712 -0.137265 +v 0.600960 0.444810 0.085753 +v 0.121642 0.750009 -0.437072 +v -0.000000 0.750009 -0.453012 +v 0.453011 0.750009 0.000000 +v 0.437073 0.750009 -0.121642 +v -0.453012 0.750009 0.000000 +v -0.437073 0.750009 -0.121642 +v -0.230198 0.750009 0.391939 +v -0.321639 0.750009 0.321639 +v -0.391940 0.750009 0.230197 +v -0.437073 0.750009 0.121642 +v 0.121642 0.750009 0.437072 +v -0.000000 0.750009 0.453012 +v -0.121642 0.750009 0.437072 +v 0.437073 0.750009 0.121642 +v 0.391939 0.750009 0.230197 +v 0.321638 0.750009 -0.321639 +v 0.230197 0.750009 -0.391940 +v -0.121642 0.750009 -0.437072 +v 0.391939 0.750009 -0.230197 +v 0.321638 0.750009 0.321639 +v 0.230197 0.750009 0.391940 +v -0.230198 0.750009 -0.391939 +v -0.501255 0.717792 0.000000 +v 0.617684 0.235930 0.085941 +v 0.625577 0.219883 0.000000 +v -0.321639 0.750009 -0.321639 +v -0.391940 0.750009 -0.230197 +v -0.498530 0.712498 0.039883 +v -0.501667 0.699221 0.063813 +v 0.617684 0.235930 -0.085941 +v 0.619427 0.283145 -0.137236 +v 0.619427 0.283145 0.137236 +vn -0.901883 0.415418 0.118168 +vn -0.905637 0.407056 0.118656 +vn -0.877041 0.418744 0.235298 +vn 0.058443 -0.998260 0.000732 +vn 0.015107 -0.999878 0.000183 +vn 0.014557 -0.949278 0.314035 +vn 0.056703 -0.947539 0.314524 +vn 0.162053 -0.986755 0.002014 +vn 0.157933 -0.933592 0.321604 +vn 0.392376 -0.919767 0.004334 +vn 0.378307 -0.856655 0.350688 +vn 0.783776 -0.620991 0.005249 +vn 0.726829 -0.553880 0.406079 +vn 0.994812 -0.101627 0.001984 +vn 0.908139 -0.082766 0.410321 +vn 0.003082 -0.939787 0.341685 +vn 0.002167 -0.619495 0.784967 +vn 0.011536 -0.679403 0.733634 +vn 0.044679 -0.675588 0.735923 +vn 0.123325 -0.652272 0.747856 +vn 0.275399 -0.556871 0.783593 +vn 0.460067 -0.316263 0.829615 +vn 0.563036 -0.041200 0.825373 +vn -0.000427 0.122166 0.992492 +vn 0.000397 0.003632 0.999969 +vn 0.002869 0.011841 0.999908 +vn 0.004852 0.029298 0.999542 +vn -0.008179 0.053499 0.998505 +vn -0.046510 0.041536 0.998047 +vn -0.039155 0.003113 0.999207 +vn -0.850551 0.473769 -0.228217 +vn -0.897885 0.424177 -0.117649 +vn -0.880886 0.473281 0.000000 +vn -0.013611 0.682394 0.730827 +vn -0.053896 0.680441 0.730796 +vn -0.147557 0.656789 0.739464 +vn -0.325968 0.560564 0.761223 +vn -0.537645 0.315806 0.781762 +vn -0.611530 0.029939 0.790613 +vn -0.904172 0.427137 0.000000 +vn -0.897885 0.424146 0.117618 +vn -0.020112 0.949461 0.313150 +vn -0.081820 0.945433 0.315287 +vn -0.227699 0.916379 0.329173 +vn -0.504196 0.785302 0.359203 +vn -0.810633 0.443220 0.382611 +vn -0.921232 0.039705 0.386944 +vn -0.020569 0.949400 -0.313334 +vn -0.021729 0.999756 -0.000092 +vn -0.004242 0.950468 -0.310770 +vn -0.088260 0.996094 -0.000488 +vn -0.246895 0.969024 -0.001343 +vn -0.549730 0.835322 -0.002350 +vn -0.880673 0.473647 -0.001984 +vn -0.999084 0.042146 -0.000610 +vn -0.877041 0.418744 -0.235298 +vn -0.920286 0.391156 0.000000 +vn -0.905637 0.407056 -0.118656 +vn -0.083132 0.945006 -0.316202 +vn -0.230201 0.914823 -0.331797 +vn -0.505570 0.782800 -0.362743 +vn -0.808710 0.444960 -0.384625 +vn -0.920835 0.042055 -0.387646 +vn -0.897885 0.424146 -0.117618 +vn -0.901883 0.415448 -0.118168 +vn -0.014161 0.682394 -0.730796 +vn -0.055361 0.680074 -0.731010 +vn -0.150029 0.655660 -0.739982 +vn -0.327616 0.560594 -0.760491 +vn -0.537431 0.320933 -0.779809 +vn -0.611988 0.033387 -0.790155 +vn 0.015168 -0.949339 -0.313852 +vn 0.011902 -0.679403 -0.733634 +vn 0.003265 -0.939817 -0.341594 +vn 0.000183 0.004212 -0.999969 +vn 0.003510 0.014008 -0.999878 +vn 0.005921 0.035951 -0.999329 +vn -0.010132 0.064333 -0.997864 +vn -0.051576 0.048463 -0.997467 +vn -0.041597 0.003998 -0.999115 +vn 0.003082 -0.620106 -0.784478 +vn -0.000031 0.122440 -0.992462 +vn -0.897885 0.424177 0.117649 +vn 0.046449 -0.674398 -0.736869 +vn 0.125980 -0.648946 -0.750298 +vn 0.275430 -0.552477 -0.786676 +vn 0.455519 -0.320536 -0.830500 +vn 0.561693 -0.046480 -0.826014 +vn -0.888668 0.391644 0.238441 +vn 0.058046 -0.947630 -0.314005 +vn 0.159948 -0.933836 -0.319865 +vn 0.380169 -0.857753 -0.345927 +vn 0.725547 -0.560930 -0.398602 +vn 0.908597 -0.089236 -0.407971 +vn 0.003235 -0.999969 0.000031 +vn 0.973144 0.230110 0.000824 +vn 0.890896 0.211737 0.401776 +vn 0.912900 0.408094 0.002533 +vn 0.836970 0.380932 0.392834 +vn 0.829035 0.559160 0.003784 +vn 0.764519 0.528550 0.368969 +vn 0.718650 0.695334 0.003937 +vn 0.668294 0.663717 0.335917 +vn 0.579577 0.814905 0.002838 +vn 0.542650 0.779687 0.312357 +vn 0.495163 0.868770 0.002258 +vn 0.458052 0.820643 0.341624 +vn 0.561205 0.137028 0.816218 +vn 0.532029 0.253456 0.807886 +vn 0.497543 0.363445 0.787591 +vn 0.449538 0.472060 0.758293 +vn 0.373669 0.563555 0.736686 +vn 0.289041 0.531114 0.796442 +vn -0.023225 -0.005249 0.999695 +vn -0.016785 -0.010254 0.999786 +vn -0.011444 -0.012940 0.999847 +vn -0.009796 -0.013276 0.999847 +vn -0.014801 -0.013916 0.999786 +vn -0.089755 -0.176122 0.980255 +vn -0.585772 -0.152379 0.795984 +vn -0.538896 -0.288766 0.791314 +vn -0.484146 -0.407910 0.774071 +vn -0.424635 -0.509781 0.748161 +vn -0.355907 -0.584765 0.728935 +vn -0.889828 -0.237159 0.389782 +vn -0.808740 -0.446852 0.382366 +vn -0.702475 -0.613269 0.361095 +vn -0.590625 -0.734855 0.333293 +vn -0.483291 -0.816767 0.315104 +vn -0.912076 0.409955 0.000000 +vn -0.965606 -0.259987 -0.000458 +vn -0.872433 -0.488693 -0.001465 +vn -0.748436 -0.663167 -0.002197 +vn -0.621601 -0.783288 -0.002136 +vn -0.507065 -0.861873 -0.001251 +vn -0.438215 -0.854366 0.279183 +vn -0.456130 -0.889889 -0.000732 +vn -0.889126 -0.238868 -0.390332 +vn -0.807001 -0.448531 -0.384075 +vn -0.700980 -0.613392 -0.363750 +vn -0.590442 -0.733757 -0.336039 +vn -0.484787 -0.815332 -0.316477 +vn -0.440962 -0.852931 -0.279305 +vn -0.359691 -0.584185 -0.727531 +vn -0.358074 -0.682241 -0.637410 +vn -0.585467 -0.154668 -0.795770 +vn -0.538499 -0.291696 -0.790490 +vn -0.484512 -0.409772 -0.772851 +vn -0.426496 -0.510056 -0.746910 +vn -0.909543 -0.399274 -0.115207 +vn -0.971191 -0.204688 -0.121891 +vn -0.912931 -0.326609 -0.244606 +vn -0.020478 -0.017853 -0.999603 +vn -0.024537 -0.005737 -0.999664 +vn -0.020844 -0.012207 -0.999695 +vn -0.017548 -0.016846 -0.999695 +vn -0.016724 -0.018097 -0.999695 +vn -0.909116 -0.400311 0.115055 +vn -0.873775 -0.472610 0.114475 +vn -0.795892 -0.566485 0.213538 +vn -0.353069 -0.684103 0.638203 +vn 0.559679 0.139714 -0.816828 +vn 0.528581 0.255501 -0.809473 +vn 0.494217 0.362987 -0.789911 +vn 0.449049 0.469283 -0.760308 +vn 0.378246 0.560869 -0.736412 +vn -0.091983 -0.174383 -0.980346 +vn 0.295267 0.530625 -0.794488 +vn 0.890500 0.214759 -0.401044 +vn 0.836634 0.384075 -0.390515 +vn 0.765191 0.530198 -0.365123 +vn 0.671041 0.663228 -0.331339 +vn 0.547929 0.777642 -0.308206 +vn 0.464522 0.818842 -0.337199 +vn 0.931486 0.265572 -0.248543 +vn 0.939543 0.342357 0.000000 +vn 0.947539 0.295114 -0.122684 +vn -0.351421 0.936186 0.001953 +vn -0.144444 0.989502 0.003174 +vn -0.126743 0.878811 0.459975 +vn -0.716758 0.697287 -0.000946 +vn -0.299997 0.838313 0.455214 +vn -0.621876 0.660207 0.421155 +vn -0.901822 0.432081 -0.004517 +vn -0.807031 0.443434 0.389904 +vn -0.930204 0.366863 -0.008484 +vn -0.824549 0.383312 0.416059 +vn -0.850673 0.525529 -0.011628 +vn -0.722465 0.508988 0.467910 +vn -0.668447 0.743645 -0.011139 +vn -0.531449 0.686514 0.496170 +vn -0.116459 0.505448 0.854946 +vn -0.258400 0.470656 0.843593 +vn -0.407605 0.396985 0.822321 +vn -0.450270 0.352367 0.820399 +vn -0.385876 0.395734 0.833338 +vn -0.270669 0.487838 0.829890 +vn 0.141606 -0.001190 0.989898 +vn -0.067690 0.525346 0.848170 +vn 0.989593 0.100253 0.103122 +vn 0.970244 0.213324 0.114475 +vn 0.960418 0.152654 0.232917 +vn 0.241829 0.092502 0.965880 +vn 0.209296 0.170660 0.962828 +vn 0.096194 0.178625 0.979186 +vn 0.009552 0.154332 0.987945 +vn -0.000122 0.151952 0.988372 +vn 0.361248 -0.477279 0.801019 +vn 0.607929 -0.282540 0.741997 +vn 0.679220 -0.106754 0.726096 +vn 0.583911 -0.078524 0.807978 +vn 0.402722 -0.205237 0.891995 +vn 0.279519 -0.338694 0.898404 +vn 0.488601 -0.768700 0.412671 +vn 0.784570 -0.501511 0.364544 +vn 0.893918 -0.279611 0.350291 +vn 0.861415 -0.285287 0.420179 +vn 0.679373 -0.540452 0.496323 +vn 0.458327 -0.754540 0.469588 +vn 0.524155 -0.851588 -0.000153 +vn 0.827143 -0.561968 0.001679 +vn 0.943205 -0.332133 0.003479 +vn 0.933256 -0.359081 0.005737 +vn 0.756859 -0.653493 0.006470 +vn 0.492843 -0.870083 0.004120 +vn 0.322489 -0.946562 -0.001129 +vn 0.912839 -0.326609 0.244942 +vn 0.824396 -0.565996 0.000000 +vn 0.894162 -0.447676 0.000000 +vn 0.486557 -0.770501 -0.411756 +vn 0.783990 -0.504074 -0.362285 +vn 0.895199 -0.281899 -0.345134 +vn 0.863735 -0.289010 -0.412824 +vn 0.682119 -0.544267 -0.488296 +vn 0.461928 -0.758202 -0.460128 +vn 0.357463 -0.479141 -0.801599 +vn 0.605884 -0.285867 -0.742393 +vn 0.679739 -0.108646 -0.725333 +vn 0.583636 -0.077883 -0.808222 +vn 0.401440 -0.199225 -0.893918 +vn 0.281961 -0.330638 -0.900632 +vn 0.135228 -0.002380 -0.990783 +vn 0.235755 0.091128 -0.967498 +vn 0.200720 0.170629 -0.964660 +vn 0.086123 0.184576 -0.979003 +vn 0.000671 0.174322 -0.984680 +vn -0.007141 0.169012 -0.985565 +vn 0.966613 -0.042848 -0.252602 +vn 0.960418 0.152654 -0.232917 +vn 0.989593 0.100223 -0.103092 +vn -0.119297 0.503342 -0.855770 +vn -0.261269 0.472793 -0.841517 +vn -0.414075 0.399792 -0.817713 +vn -0.459700 0.357036 -0.813105 +vn -0.394024 0.408490 -0.823298 +vn -0.277871 0.487381 -0.827754 +vn -0.072207 0.520127 -0.851009 +vn -0.298654 0.840297 -0.452376 +vn -0.617512 0.663961 -0.421613 +vn -0.801324 0.450209 -0.393872 +vn -0.819422 0.389691 -0.420270 +vn -0.721274 0.506912 -0.471969 +vn -0.538347 0.670644 -0.510239 +vn -0.482009 0.876125 -0.005127 +vn -0.394635 0.815363 0.423536 +vn -0.321909 0.946745 -0.002594 +vn -0.255287 0.921995 0.291086 +vn 0.004242 0.999969 0.000397 +vn -0.002960 0.999939 -0.010102 +vn 0.853450 0.521073 -0.007050 +vn 0.392041 0.688986 -0.609546 +vn 0.805170 -0.592517 -0.023621 +vn 0.588763 -0.206122 -0.781579 +vn 0.681478 -0.731040 -0.033296 +vn 0.485031 -0.441237 -0.754967 +vn -0.206824 0.638203 0.741539 +vn -0.129490 0.862056 0.489944 +vn -0.033418 0.999176 0.022340 +vn 0.047700 0.864040 -0.501114 +vn 0.099307 0.538743 -0.836573 +vn 0.053560 0.251839 -0.966277 +vn 0.020112 0.322611 0.946287 +vn 0.021943 0.748894 0.662282 +vn -0.025941 0.995605 0.089908 +vn -0.059175 0.930876 -0.360424 +vn -0.080172 0.784448 -0.614948 +vn -0.142582 0.557604 -0.817743 +vn 0.281747 -0.174993 0.943388 +vn 0.303903 0.444136 0.842830 +vn 0.034333 0.983764 0.175970 +vn -0.113865 0.956420 -0.268777 +vn -0.155339 0.858852 -0.488021 +vn -0.207404 0.641865 -0.738182 +vn 0.467238 -0.683187 0.561144 +vn 0.699515 0.004364 0.714560 +vn 0.355296 0.891934 0.279641 +vn -0.170354 0.971465 -0.164861 +vn -0.245552 0.901181 -0.357097 +vn -0.248726 0.651082 -0.717063 +vn 0.494430 -0.869167 0.006317 +vn 0.933134 -0.358898 0.019868 +vn 0.703146 0.710685 0.021790 +vn -0.203650 0.978942 -0.012574 +vn -0.326456 0.942869 -0.066073 +vn -0.397595 0.857082 -0.327525 +vn 0.460616 -0.712546 -0.529221 +vn 0.695486 -0.098544 -0.711722 +vn 0.397534 0.853816 -0.336070 +vn -0.198248 0.963439 0.180151 +vn -0.306833 0.888516 0.341075 +vn -0.393689 0.807672 0.438887 +vn 0.276559 -0.211951 -0.937315 +vn 0.294626 0.366161 -0.882656 +vn 0.046632 0.973235 -0.224982 +vn -0.146733 0.912168 0.382611 +vn -0.202643 0.700797 0.683950 +vn -0.232673 0.506485 0.830226 +vn 0.011689 0.309397 -0.950835 +vn 0.013245 0.708640 -0.705435 +vn -0.027589 0.995758 -0.087680 +vn -0.047395 0.829371 0.556658 +vn -0.015259 0.386608 0.922086 +vn 0.004639 0.119510 0.992798 +vn -0.211035 0.631001 -0.746513 +vn -0.138768 0.848781 -0.510147 +vn -0.024995 0.999664 -0.001190 +vn 0.120426 0.724570 0.678579 +vn 0.260750 0.006531 0.965361 +vn 0.272500 -0.255898 0.927488 +vn -0.395581 0.809961 -0.432905 +vn -0.258827 0.918851 -0.297800 +vn 0.004730 0.999878 0.013031 +vn 0.466628 0.599780 0.649983 +vn 0.621937 -0.400861 0.672628 +vn 0.551042 -0.592181 0.587878 +vn 0.649068 0.384991 -0.656087 +vn 0.055971 0.691214 0.720450 +vn -0.115940 0.804590 0.582354 +vn -0.262185 0.897946 0.353435 +vn -0.341655 0.885006 -0.316263 +vn -0.081423 0.793085 -0.603626 +vn -0.155675 0.857753 -0.489883 +vn 0.728690 0.365978 0.578784 +vn 0.318674 0.539384 0.779382 +vn 0.953551 0.300150 -0.024415 +vn -0.133976 0.836818 -0.530808 +vn 0.095401 0.667959 -0.738029 +vn 0.000000 0.999969 0.000000 +vn -0.992523 -0.122013 0.000000 +vn -0.937346 -0.348338 0.000000 +vn -0.905148 -0.348827 -0.242836 +vn -0.958617 -0.122227 -0.257057 +vn -0.832057 0.554674 0.000000 +vn -0.803217 0.555376 -0.215339 +vn -0.048616 0.998810 0.000000 +vn -0.046236 0.998840 -0.012726 +vn 0.544267 0.838893 0.000000 +vn 0.525376 0.839106 0.140843 +vn 0.783471 0.621387 0.000000 +vn 0.756371 0.621845 0.202918 +vn 0.880886 0.473281 0.000000 +vn 0.850551 0.473769 0.228217 +vn -0.810907 -0.349376 -0.469375 +vn -0.859004 -0.122410 -0.497085 +vn -0.719657 0.555559 -0.416425 +vn -0.041749 0.998810 -0.024415 +vn 0.470077 0.839625 0.272011 +vn 0.677236 0.622608 0.391980 +vn 0.761803 0.474471 0.440962 +vn -0.662465 -0.349620 -0.662465 +vn -0.701773 -0.122440 -0.701773 +vn -0.587878 0.555650 -0.587878 +vn -0.034272 0.998810 -0.034272 +vn 0.383831 0.839808 0.383831 +vn 0.553148 0.622913 0.553148 +vn 0.622303 0.474776 0.622303 +vn -0.469375 -0.349376 -0.810907 +vn -0.497085 -0.122379 -0.859004 +vn -0.416425 0.555559 -0.719657 +vn -0.024415 0.998810 -0.041749 +vn 0.272011 0.839625 0.470077 +vn 0.391980 0.622608 0.677236 +vn 0.440962 0.474471 0.761834 +vn -0.242836 -0.348827 -0.905148 +vn -0.257057 -0.122227 -0.958617 +vn -0.215339 0.555376 -0.803217 +vn -0.012726 0.998840 -0.046205 +vn 0.140843 0.839106 0.525376 +vn 0.202918 0.621845 0.756371 +vn 0.228217 0.473769 0.850551 +vn 0.000000 -0.348338 -0.937346 +vn 0.000000 -0.122013 -0.992523 +vn 0.000000 0.554674 -0.832057 +vn 0.000000 0.998810 -0.048616 +vn 0.000000 0.838893 0.544267 +vn 0.000000 0.621387 0.783471 +vn 0.000000 0.473281 0.880886 +vn 0.242836 -0.348827 -0.905148 +vn 0.257057 -0.122227 -0.958617 +vn 0.215308 0.555376 -0.803217 +vn 0.012726 0.998840 -0.046205 +vn -0.140843 0.839106 0.525376 +vn -0.202918 0.621845 0.756340 +vn -0.228217 0.473769 0.850551 +vn 0.469375 -0.349376 -0.810907 +vn 0.497085 -0.122379 -0.859004 +vn 0.416425 0.555559 -0.719657 +vn 0.024415 0.998810 -0.041749 +vn -0.272011 0.839625 0.470077 +vn -0.391980 0.622608 0.677236 +vn -0.440962 0.474502 0.761803 +vn 0.662465 -0.349620 -0.662465 +vn 0.701773 -0.122471 -0.701773 +vn 0.587878 0.555650 -0.587878 +vn 0.034272 0.998810 -0.034272 +vn -0.383831 0.839808 0.383831 +vn -0.553148 0.622913 0.553148 +vn -0.622303 0.474776 0.622303 +vn 0.810907 -0.349406 -0.469375 +vn 0.859004 -0.122379 -0.497085 +vn 0.719657 0.555559 -0.416425 +vn 0.041749 0.998810 -0.024415 +vn -0.470077 0.839625 0.272011 +vn -0.677236 0.622608 0.391980 +vn -0.761803 0.474471 0.440962 +vn 0.905148 -0.348827 -0.242836 +vn 0.958617 -0.122227 -0.257057 +vn 0.803217 0.555376 -0.215339 +vn 0.046205 0.998840 -0.012726 +vn -0.525376 0.839106 0.140843 +vn -0.756340 0.621876 0.202918 +vn -0.850551 0.473769 0.228217 +vn 0.937346 -0.348338 0.000000 +vn 0.992523 -0.122013 0.000000 +vn 0.832026 0.554674 0.000000 +vn 0.048616 0.998810 0.000000 +vn -0.544267 0.838893 0.000000 +vn -0.783471 0.621387 0.000000 +vn 0.905148 -0.348827 0.242836 +vn 0.958617 -0.122227 0.257057 +vn 0.803217 0.555376 0.215308 +vn 0.046205 0.998840 0.012726 +vn -0.525376 0.839106 -0.140843 +vn -0.756340 0.621876 -0.202918 +vn 0.810907 -0.349406 0.469375 +vn 0.859004 -0.122379 0.497085 +vn 0.719657 0.555559 0.416425 +vn 0.041749 0.998810 0.024415 +vn -0.470077 0.839625 -0.272011 +vn -0.677236 0.622608 -0.391980 +vn -0.761803 0.474471 -0.440962 +vn 0.662465 -0.349620 0.662465 +vn 0.701773 -0.122471 0.701773 +vn 0.587878 0.555650 0.587878 +vn 0.034272 0.998810 0.034272 +vn -0.383831 0.839808 -0.383831 +vn -0.553148 0.622913 -0.553148 +vn -0.622303 0.474776 -0.622303 +vn 0.469375 -0.349376 0.810907 +vn 0.497085 -0.122379 0.859004 +vn 0.416425 0.555559 0.719657 +vn 0.024415 0.998810 0.041749 +vn -0.272011 0.839625 -0.470077 +vn -0.391980 0.622608 -0.677236 +vn -0.440962 0.474471 -0.761803 +vn 0.242836 -0.348827 0.905148 +vn 0.257057 -0.122227 0.958617 +vn 0.215339 0.555376 0.803217 +vn 0.012726 0.998840 0.046205 +vn -0.140843 0.839106 -0.525376 +vn -0.202918 0.621845 -0.756371 +vn -0.228217 0.473769 -0.850551 +vn 0.000000 -0.348338 0.937346 +vn 0.000000 -0.122013 0.992523 +vn 0.000000 0.554674 0.832057 +vn 0.000000 0.998810 0.048616 +vn 0.000000 0.838893 -0.544267 +vn 0.000000 0.621387 -0.783471 +vn 0.000000 0.473281 -0.880886 +vn -0.242836 -0.348827 0.905148 +vn -0.257057 -0.122227 0.958617 +vn -0.215308 0.555376 0.803217 +vn -0.012726 0.998840 0.046205 +vn 0.140843 0.839106 -0.525376 +vn 0.202918 0.621845 -0.756371 +vn 0.228217 0.473769 -0.850551 +vn -0.469375 -0.349376 0.810907 +vn -0.497085 -0.122379 0.859004 +vn -0.416425 0.555559 0.719657 +vn -0.024415 0.998810 0.041749 +vn 0.272011 0.839625 -0.470077 +vn 0.391980 0.622608 -0.677236 +vn 0.440962 0.474471 -0.761803 +vn -0.662465 -0.349620 0.662465 +vn -0.701773 -0.122440 0.701773 +vn -0.587878 0.555650 0.587878 +vn -0.034272 0.998810 0.034272 +vn 0.383831 0.839808 -0.383831 +vn 0.553148 0.622913 -0.553148 +vn 0.622303 0.474776 -0.622303 +vn -0.810907 -0.349376 0.469375 +vn -0.859004 -0.122410 0.497085 +vn -0.719657 0.555528 0.416425 +vn -0.041749 0.998810 0.024415 +vn 0.470077 0.839625 -0.272011 +vn 0.677236 0.622639 -0.391980 +vn 0.761803 0.474471 -0.440962 +vn -0.905148 -0.348827 0.242836 +vn -0.958617 -0.122227 0.257057 +vn -0.803217 0.555376 0.215339 +vn -0.046236 0.998840 0.012726 +vn 0.525376 0.839106 -0.140843 +vn 0.756371 0.621845 -0.202918 +vn 0.850551 0.473769 -0.228217 +vn 0.908292 0.418256 0.000000 +vn 0.877041 0.418744 0.235298 +vn 0.920286 0.391156 0.000000 +vn 0.888668 0.391644 0.238441 +vn 0.907315 0.342753 0.243446 +vn 0.785638 0.419416 0.454756 +vn 0.796075 0.392285 0.460799 +vn 0.812830 0.343333 0.470504 +vn 0.931486 0.265542 0.248543 +vn 0.834162 0.266366 0.482864 +vn 0.855312 0.152379 0.495132 +vn 0.966613 -0.042848 0.252602 +vn 0.864498 -0.045808 0.500504 +vn 0.641804 0.419691 0.641804 +vn 0.650349 0.392499 0.650349 +vn 0.664052 0.343577 0.664052 +vn 0.681509 0.266579 0.681509 +vn 0.698813 0.152501 0.698813 +vn 0.706351 -0.045869 0.706351 +vn 0.454756 0.419416 0.785638 +vn 0.460799 0.392285 0.796075 +vn 0.470504 0.343333 0.812830 +vn 0.482864 0.266366 0.834162 +vn 0.495132 0.152409 0.855312 +vn 0.500504 -0.045808 0.864498 +vn 0.235298 0.418744 0.877041 +vn 0.238441 0.391644 0.888668 +vn 0.243446 0.342753 0.907315 +vn 0.249855 0.265908 0.931028 +vn 0.256172 0.152104 0.954558 +vn 0.258980 -0.045717 0.964782 +vn 0.000000 0.418256 0.908292 +vn 0.000000 0.391156 0.920286 +vn 0.000000 0.342357 0.939543 +vn 0.000000 0.265542 0.964080 +vn 0.000000 0.151891 0.988372 +vn 0.000000 -0.045656 0.998932 +vn -0.235298 0.418744 0.877041 +vn -0.238441 0.391644 0.888668 +vn -0.243446 0.342753 0.907315 +vn -0.249855 0.265877 0.931028 +vn -0.256172 0.152104 0.954558 +vn -0.258980 -0.045717 0.964782 +vn -0.454756 0.419416 0.785638 +vn -0.460799 0.392285 0.796075 +vn -0.470504 0.343333 0.812830 +vn -0.482864 0.266366 0.834162 +vn -0.495132 0.152379 0.855312 +vn -0.500504 -0.045808 0.864498 +vn -0.641804 0.419691 0.641804 +vn -0.650349 0.392499 0.650349 +vn -0.664052 0.343577 0.664052 +vn -0.681509 0.266579 0.681509 +vn -0.698813 0.152501 0.698813 +vn -0.706351 -0.045869 0.706351 +vn -0.785638 0.419416 0.454756 +vn -0.796075 0.392285 0.460799 +vn -0.812830 0.343364 0.470504 +vn -0.834162 0.266366 0.482864 +vn -0.855312 0.152379 0.495132 +vn -0.864498 -0.045808 0.500504 +vn -0.907315 0.342753 0.243446 +vn -0.931028 0.265908 0.249855 +vn -0.954558 0.152104 0.256172 +vn -0.964782 -0.045717 0.258980 +vn -0.939543 0.342357 0.000000 +vn -0.964080 0.265542 0.000000 +vn -0.988372 0.151891 0.000000 +vn -0.888668 0.391644 -0.238441 +vn -0.907315 0.342753 -0.243446 +vn -0.931028 0.265877 -0.249855 +vn -0.954558 0.152104 -0.256172 +vn -0.785638 0.419416 -0.454756 +vn -0.796075 0.392285 -0.460799 +vn -0.812830 0.343333 -0.470504 +vn -0.834162 0.266366 -0.482864 +vn -0.855312 0.152379 -0.495132 +vn -0.964782 -0.045717 -0.258980 +vn -0.864498 -0.045808 -0.500504 +vn -0.641804 0.419691 -0.641804 +vn -0.650349 0.392499 -0.650349 +vn -0.664052 0.343577 -0.664052 +vn -0.681509 0.266579 -0.681509 +vn -0.698813 0.152501 -0.698813 +vn -0.706351 -0.045869 -0.706351 +vn -0.454756 0.419416 -0.785638 +vn -0.460799 0.392285 -0.796075 +vn -0.470504 0.343333 -0.812830 +vn -0.482864 0.266366 -0.834162 +vn -0.495132 0.152379 -0.855312 +vn -0.500504 -0.045808 -0.864498 +vn -0.235298 0.418744 -0.877041 +vn -0.238441 0.391644 -0.888668 +vn -0.243446 0.342753 -0.907315 +vn -0.249855 0.265908 -0.931028 +vn -0.256172 0.152104 -0.954558 +vn -0.258980 -0.045717 -0.964782 +vn 0.000000 0.418256 -0.908292 +vn 0.000000 0.391156 -0.920286 +vn 0.000000 0.342357 -0.939543 +vn 0.000000 0.265542 -0.964080 +vn 0.000000 0.151891 -0.988372 +vn 0.000000 -0.045656 -0.998932 +vn 0.235298 0.418744 -0.877041 +vn 0.238441 0.391644 -0.888668 +vn 0.243446 0.342753 -0.907315 +vn 0.249855 0.265877 -0.931028 +vn 0.256172 0.152104 -0.954558 +vn 0.258980 -0.045717 -0.964782 +vn 0.454756 0.419416 -0.785638 +vn 0.460799 0.392285 -0.796075 +vn 0.470504 0.343333 -0.812830 +vn 0.482864 0.266366 -0.834162 +vn 0.495132 0.152379 -0.855312 +vn 0.500504 -0.045808 -0.864498 +vn 0.641804 0.419691 -0.641804 +vn 0.650349 0.392499 -0.650349 +vn 0.664052 0.343577 -0.664052 +vn 0.681509 0.266579 -0.681509 +vn 0.698813 0.152501 -0.698813 +vn 0.706351 -0.045869 -0.706351 +vn 0.785638 0.419416 -0.454756 +vn 0.796075 0.392285 -0.460799 +vn 0.812830 0.343364 -0.470504 +vn 0.834162 0.266366 -0.482864 +vn 0.855312 0.152379 -0.495132 +vn 0.864498 -0.045808 -0.500504 +vn 0.877041 0.418744 -0.235298 +vn 0.888668 0.391644 -0.238441 +vn 0.907315 0.342753 -0.243446 +vn 0.795892 -0.566485 0.213538 +vn 0.712180 -0.701987 0.000000 +vn 0.687399 -0.702445 0.184393 +vn 0.652974 -0.757347 0.000000 +vn 0.630146 -0.757805 0.169012 +vn 0.724021 -0.689749 0.000000 +vn 0.698752 -0.690329 0.187414 +vn 0.886410 -0.462874 0.000000 +vn 0.855861 -0.463454 0.229530 +vn 0.817774 -0.327158 0.473434 +vn 0.712729 -0.567248 0.412549 +vn 0.615345 -0.703146 0.356151 +vn 0.564043 -0.758446 0.326456 +vn 0.625660 -0.690939 0.362102 +vn 0.766625 -0.464125 0.443678 +vn 0.668111 -0.327403 0.668111 +vn 0.582171 -0.567522 0.582171 +vn 0.502579 -0.703421 0.502579 +vn 0.460646 -0.758660 0.460646 +vn 0.510971 -0.691183 0.510971 +vn 0.626209 -0.464370 0.626240 +vn 0.473434 -0.327158 0.817774 +vn 0.412549 -0.567248 0.712729 +vn 0.356151 -0.703146 0.615375 +vn 0.326456 -0.758446 0.564043 +vn 0.362102 -0.690939 0.625660 +vn 0.443678 -0.464125 0.766625 +vn 0.245003 -0.326609 0.912839 +vn 0.213538 -0.566485 0.795892 +vn 0.184393 -0.702445 0.687399 +vn 0.169012 -0.757805 0.630146 +vn 0.187414 -0.690329 0.698752 +vn 0.229530 -0.463454 0.855831 +vn 0.000000 -0.326243 0.945250 +vn 0.000000 -0.565996 0.824396 +vn 0.000000 -0.701987 0.712180 +vn 0.000000 -0.757347 0.652974 +vn 0.000000 -0.689749 0.724021 +vn 0.000000 -0.462905 0.886380 +vn -0.245003 -0.326609 0.912839 +vn -0.213538 -0.566485 0.795892 +vn -0.184393 -0.702445 0.687399 +vn -0.169012 -0.757805 0.630146 +vn -0.187414 -0.690329 0.698752 +vn -0.229530 -0.463454 0.855861 +vn -0.473434 -0.327158 0.817774 +vn -0.412549 -0.567248 0.712729 +vn -0.356151 -0.703146 0.615375 +vn -0.326456 -0.758446 0.564043 +vn -0.362102 -0.690939 0.625660 +vn -0.443678 -0.464125 0.766625 +vn -0.668111 -0.327403 0.668111 +vn -0.582171 -0.567522 0.582171 +vn -0.502579 -0.703421 0.502579 +vn -0.460646 -0.758660 0.460646 +vn -0.510971 -0.691183 0.510971 +vn -0.626209 -0.464370 0.626209 +vn -0.817774 -0.327158 0.473434 +vn -0.712729 -0.567248 0.412549 +vn -0.615375 -0.703146 0.356151 +vn -0.564043 -0.758446 0.326456 +vn -0.625660 -0.690939 0.362102 +vn -0.766625 -0.464125 0.443678 +vn -0.912931 -0.326609 0.244575 +vn -0.687399 -0.702445 0.184393 +vn -0.630146 -0.757805 0.169012 +vn -0.698752 -0.690329 0.187414 +vn -0.855831 -0.463485 0.229530 +vn -0.824396 -0.565996 0.000000 +vn -0.712180 -0.701987 0.000000 +vn -0.652974 -0.757347 0.000000 +vn -0.724021 -0.689749 0.000000 +vn -0.886410 -0.462874 0.000000 +vn -0.795892 -0.566485 -0.213538 +vn -0.687399 -0.702445 -0.184393 +vn -0.630146 -0.757805 -0.169012 +vn -0.698752 -0.690329 -0.187414 +vn -0.855831 -0.463454 -0.229530 +vn -0.817774 -0.327158 -0.473434 +vn -0.712729 -0.567217 -0.412549 +vn -0.615375 -0.703146 -0.356151 +vn -0.564043 -0.758446 -0.326456 +vn -0.625660 -0.690939 -0.362102 +vn -0.766625 -0.464125 -0.443678 +vn -0.668111 -0.327403 -0.668111 +vn -0.582171 -0.567522 -0.582171 +vn -0.502579 -0.703421 -0.502579 +vn -0.460646 -0.758660 -0.460646 +vn -0.510971 -0.691183 -0.510971 +vn -0.626209 -0.464370 -0.626209 +vn -0.473434 -0.327158 -0.817774 +vn -0.412549 -0.567248 -0.712729 +vn -0.356151 -0.703146 -0.615375 +vn -0.326456 -0.758446 -0.564043 +vn -0.362102 -0.690939 -0.625660 +vn -0.443678 -0.464125 -0.766625 +vn -0.245003 -0.326609 -0.912839 +vn -0.213538 -0.566485 -0.795892 +vn -0.184393 -0.702445 -0.687399 +vn -0.169012 -0.757805 -0.630146 +vn -0.187414 -0.690329 -0.698752 +vn -0.229530 -0.463454 -0.855831 +vn 0.000000 -0.326243 -0.945250 +vn 0.000000 -0.565996 -0.824396 +vn 0.000000 -0.701987 -0.712180 +vn 0.000000 -0.757347 -0.652974 +vn 0.000000 -0.689749 -0.724021 +vn 0.000000 -0.462905 -0.886380 +vn 0.245003 -0.326609 -0.912839 +vn 0.213538 -0.566485 -0.795892 +vn 0.184393 -0.702445 -0.687399 +vn 0.169012 -0.757805 -0.630146 +vn 0.187445 -0.690329 -0.698752 +vn 0.229530 -0.463454 -0.855861 +vn 0.473434 -0.327158 -0.817774 +vn 0.412549 -0.567248 -0.712729 +vn 0.356151 -0.703146 -0.615375 +vn 0.326456 -0.758446 -0.564043 +vn 0.362102 -0.690939 -0.625660 +vn 0.443678 -0.464125 -0.766625 +vn 0.668111 -0.327403 -0.668111 +vn 0.582171 -0.567522 -0.582171 +vn 0.502579 -0.703421 -0.502579 +vn 0.460646 -0.758660 -0.460646 +vn 0.510971 -0.691183 -0.510971 +vn 0.626209 -0.464370 -0.626209 +vn 0.817774 -0.327158 -0.473434 +vn 0.712729 -0.567248 -0.412549 +vn 0.615375 -0.703146 -0.356151 +vn 0.564043 -0.758446 -0.326456 +vn 0.625660 -0.690939 -0.362102 +vn 0.766625 -0.464125 -0.443678 +vn 0.912839 -0.326609 -0.244942 +vn 0.795892 -0.566485 -0.213538 +vn 0.687399 -0.702445 -0.184393 +vn 0.630146 -0.757805 -0.169012 +vn 0.698752 -0.690329 -0.187414 +vn 0.855861 -0.463454 -0.229530 +vn 0.025666 -0.999664 0.000000 +vn 0.000000 -1.000000 0.000000 +vn 0.024781 -0.999664 -0.006623 +vn 0.068667 -0.997620 0.000000 +vn 0.066256 -0.997620 -0.017731 +vn 0.157170 -0.987548 0.000000 +vn 0.151677 -0.987579 -0.040620 +vn 0.373150 -0.927763 0.000000 +vn 0.360118 -0.927885 -0.096469 +vn 0.789148 -0.614154 0.000000 +vn 0.762017 -0.614399 -0.204505 +vn 0.022156 -0.999664 -0.012787 +vn 0.059236 -0.997650 -0.034272 +vn 0.135624 -0.987640 -0.078463 +vn 0.322153 -0.928129 -0.186377 +vn 0.682333 -0.615131 -0.394971 +vn 0.018067 -0.999664 -0.018067 +vn 0.048341 -0.997650 -0.048341 +vn 0.110691 -0.987640 -0.110691 +vn 0.262947 -0.928251 -0.262947 +vn 0.557329 -0.615375 -0.557329 +vn 0.012787 -0.999664 -0.022156 +vn 0.034272 -0.997650 -0.059236 +vn 0.078463 -0.987640 -0.135624 +vn 0.186377 -0.928129 -0.322153 +vn 0.394971 -0.615131 -0.682302 +vn 0.006623 -0.999664 -0.024781 +vn 0.017731 -0.997620 -0.066256 +vn 0.040620 -0.987579 -0.151677 +vn 0.096469 -0.927885 -0.360118 +vn 0.204474 -0.614399 -0.762017 +vn 0.000000 -0.999664 -0.025666 +vn 0.000000 -0.997620 -0.068667 +vn 0.000000 -0.987548 -0.157170 +vn 0.000000 -0.927763 -0.373150 +vn 0.000000 -0.614154 -0.789148 +vn -0.006623 -0.999664 -0.024781 +vn -0.017731 -0.997620 -0.066256 +vn -0.040620 -0.987579 -0.151677 +vn -0.096469 -0.927885 -0.360118 +vn -0.204474 -0.614399 -0.762017 +vn -0.012787 -0.999664 -0.022156 +vn -0.034272 -0.997650 -0.059236 +vn -0.078463 -0.987640 -0.135624 +vn -0.186377 -0.928129 -0.322153 +vn -0.394971 -0.615131 -0.682333 +vn -0.018067 -0.999664 -0.018067 +vn -0.048341 -0.997650 -0.048341 +vn -0.110691 -0.987640 -0.110691 +vn -0.262947 -0.928251 -0.262947 +vn -0.557329 -0.615375 -0.557329 +vn -0.022156 -0.999664 -0.012787 +vn -0.059236 -0.997650 -0.034272 +vn -0.135624 -0.987640 -0.078463 +vn -0.322153 -0.928129 -0.186377 +vn -0.682302 -0.615131 -0.394971 +vn -0.024781 -0.999664 -0.006623 +vn -0.066256 -0.997620 -0.017731 +vn -0.151677 -0.987579 -0.040620 +vn -0.360118 -0.927885 -0.096469 +vn -0.762017 -0.614399 -0.204474 +vn -0.025666 -0.999664 0.000000 +vn -0.068667 -0.997620 0.000000 +vn -0.157170 -0.987548 0.000000 +vn -0.373150 -0.927763 0.000000 +vn -0.789148 -0.614154 0.000000 +vn -0.024781 -0.999664 0.006623 +vn -0.066256 -0.997620 0.017731 +vn -0.151677 -0.987579 0.040620 +vn -0.360149 -0.927885 0.096469 +vn -0.762017 -0.614399 0.204474 +vn -0.022156 -0.999664 0.012787 +vn -0.059236 -0.997650 0.034272 +vn -0.135624 -0.987640 0.078463 +vn -0.322153 -0.928129 0.186377 +vn -0.682333 -0.615131 0.394971 +vn -0.018067 -0.999664 0.018067 +vn -0.048341 -0.997650 0.048341 +vn -0.110691 -0.987640 0.110691 +vn -0.262947 -0.928251 0.262947 +vn -0.557329 -0.615375 0.557329 +vn -0.012787 -0.999664 0.022156 +vn -0.034272 -0.997650 0.059236 +vn -0.078463 -0.987640 0.135624 +vn -0.186377 -0.928129 0.322153 +vn -0.394971 -0.615131 0.682302 +vn -0.006623 -0.999664 0.024781 +vn -0.017731 -0.997620 0.066256 +vn -0.040620 -0.987579 0.151677 +vn -0.096469 -0.927885 0.360118 +vn -0.204474 -0.614399 0.762017 +vn 0.000000 -0.999664 0.025666 +vn 0.000000 -0.997620 0.068667 +vn 0.000000 -0.987548 0.157170 +vn 0.000000 -0.927763 0.373150 +vn 0.000000 -0.614154 0.789148 +vn 0.006623 -0.999664 0.024781 +vn 0.017731 -0.997620 0.066256 +vn 0.040620 -0.987579 0.151677 +vn 0.096469 -0.927885 0.360149 +vn 0.204474 -0.614399 0.762017 +vn 0.012787 -0.999664 0.022156 +vn 0.034272 -0.997650 0.059236 +vn 0.078463 -0.987640 0.135624 +vn 0.186377 -0.928129 0.322153 +vn 0.394971 -0.615131 0.682333 +vn 0.018067 -0.999664 0.018067 +vn 0.048341 -0.997650 0.048341 +vn 0.110691 -0.987640 0.110691 +vn 0.262947 -0.928251 0.262947 +vn 0.557329 -0.615375 0.557329 +vn 0.022156 -0.999664 0.012787 +vn 0.059236 -0.997650 0.034272 +vn 0.135624 -0.987640 0.078463 +vn 0.322153 -0.928129 0.186346 +vn 0.682302 -0.615131 0.394971 +vn 0.024781 -0.999664 0.006623 +vn 0.066256 -0.997620 0.017731 +vn 0.151677 -0.987579 0.040620 +vn 0.360118 -0.927885 0.096469 +vn 0.762017 -0.614399 0.204474 +vn 0.464827 -0.373638 -0.802667 +vn 0.655812 -0.373882 -0.655812 +vn 0.000000 -0.372539 0.927976 +vn -0.240699 -0.373028 0.896023 +vn -0.802667 -0.373608 0.464827 +vn 0.896023 -0.372997 -0.240699 +vn -0.927976 -0.372539 0.000000 +vn 0.927976 -0.372539 0.000000 +vn 0.717063 0.696982 0.000000 +vn 0.990387 -0.138310 -0.000061 +vn 0.956694 -0.138737 0.255806 +vn 0.692129 0.697470 0.185583 +vn 0.857326 -0.139317 0.495529 +vn 0.620045 0.697653 0.358837 +vn 0.700125 -0.139531 0.700217 +vn 0.506516 0.697714 0.506546 +vn 0.495468 -0.139286 0.857356 +vn 0.358776 0.697714 0.620014 +vn 0.255867 -0.138737 0.956694 +vn 0.185583 0.697531 0.692068 +vn 0.000061 -0.138310 0.990387 +vn 0.000000 0.696982 0.717063 +vn -0.255806 -0.138737 0.956694 +vn -0.185583 0.697470 0.692129 +vn -0.495529 -0.139317 0.857326 +vn -0.358837 0.697653 0.620045 +vn -0.700217 -0.139531 0.700156 +vn -0.506546 0.697714 0.506516 +vn -0.857356 -0.139286 0.495468 +vn -0.620014 0.697714 0.358776 +vn -0.956694 -0.138737 0.255867 +vn -0.692068 0.697531 0.185583 +vn -0.990387 -0.138310 0.000061 +vn -0.717063 0.696982 0.000000 +vn -0.956694 -0.138737 -0.255806 +vn -0.692129 0.697470 -0.185583 +vn -0.857326 -0.139317 -0.495529 +vn -0.620045 0.697653 -0.358837 +vn -0.700125 -0.139531 -0.700217 +vn -0.506516 0.697714 -0.506546 +vn -0.495468 -0.139286 -0.857356 +vn -0.358776 0.697714 -0.620014 +vn -0.255867 -0.138737 -0.956694 +vn -0.185583 0.697531 -0.692068 +vn -0.000061 -0.138310 -0.990387 +vn 0.000000 0.696982 -0.717063 +vn 0.255806 -0.138737 -0.956694 +vn 0.185583 0.697470 -0.692129 +vn 0.495529 -0.139317 -0.857326 +vn 0.358837 0.697653 -0.620045 +vn 0.700217 -0.139531 -0.700156 +vn 0.506546 0.697714 -0.506516 +vn 0.857356 -0.139286 -0.495468 +vn 0.620014 0.697714 -0.358776 +vn 0.956694 -0.138737 -0.255867 +vn 0.692068 0.697531 -0.185583 +vn 0.292520 0.956236 0.000000 +vn 0.282083 0.956389 0.075686 +vn 0.177953 0.984008 0.000000 +vn 0.171606 0.984069 0.046022 +vn 0.158879 0.987274 0.000000 +vn 0.153264 0.987304 0.041078 +vn 0.217719 0.975982 0.000000 +vn 0.210059 0.976043 0.056276 +vn 0.504715 0.863277 0.000000 +vn 0.487197 0.863460 0.130558 +vn 0.693258 0.720664 0.000000 +vn 0.669057 0.721183 0.179449 +vn 0.252388 0.956511 0.146092 +vn 0.153508 0.984130 0.088839 +vn 0.137059 0.987365 0.079318 +vn 0.187872 0.976135 0.108676 +vn 0.435926 0.863887 0.252205 +vn 0.598956 0.721824 0.346660 +vn 0.206091 0.956572 0.206091 +vn 0.125340 0.984161 0.125340 +vn 0.111911 0.987396 0.111911 +vn 0.153356 0.976196 0.153356 +vn 0.355907 0.864071 0.355907 +vn 0.489151 0.722098 0.489151 +vn 0.146092 0.956511 0.252388 +vn 0.088839 0.984130 0.153508 +vn 0.079318 0.987365 0.137059 +vn 0.108676 0.976135 0.187872 +vn 0.252205 0.863887 0.435926 +vn 0.346660 0.721824 0.598956 +vn 0.075686 0.956389 0.282083 +vn 0.046022 0.984069 0.171606 +vn 0.041078 0.987304 0.153264 +vn 0.056276 0.976043 0.210059 +vn 0.130558 0.863460 0.487197 +vn 0.179449 0.721183 0.669057 +vn 0.000000 0.956236 0.292520 +vn 0.000000 0.984008 0.177953 +vn 0.000000 0.987274 0.158879 +vn 0.000000 0.975982 0.217719 +vn 0.000000 0.863277 0.504715 +vn 0.000000 0.720664 0.693258 +vn -0.075686 0.956389 0.282083 +vn -0.046022 0.984069 0.171606 +vn -0.041078 0.987304 0.153264 +vn -0.056276 0.976043 0.210059 +vn -0.130558 0.863460 0.487197 +vn -0.179449 0.721183 0.669057 +vn -0.146092 0.956511 0.252388 +vn -0.088839 0.984130 0.153508 +vn -0.079318 0.987365 0.137059 +vn -0.108676 0.976135 0.187872 +vn -0.252205 0.863887 0.435926 +vn -0.346660 0.721824 0.598956 +vn -0.206091 0.956572 0.206091 +vn -0.125340 0.984161 0.125340 +vn -0.111911 0.987396 0.111911 +vn -0.153356 0.976196 0.153356 +vn -0.355907 0.864071 0.355907 +vn -0.489151 0.722098 0.489151 +vn -0.252388 0.956511 0.146092 +vn -0.153508 0.984130 0.088839 +vn -0.137059 0.987365 0.079318 +vn -0.187872 0.976135 0.108676 +vn -0.435926 0.863887 0.252205 +vn -0.598956 0.721824 0.346660 +vn -0.282083 0.956389 0.075686 +vn -0.171606 0.984069 0.046022 +vn -0.153264 0.987304 0.041078 +vn -0.210059 0.976043 0.056276 +vn -0.487197 0.863460 0.130558 +vn -0.669057 0.721183 0.179449 +vn -0.292520 0.956236 0.000000 +vn -0.177953 0.984008 0.000000 +vn -0.158879 0.987274 0.000000 +vn -0.217719 0.975982 0.000000 +vn -0.504715 0.863277 0.000000 +vn -0.693258 0.720664 0.000000 +vn -0.282083 0.956389 -0.075686 +vn -0.171606 0.984069 -0.046022 +vn -0.153264 0.987304 -0.041078 +vn -0.210059 0.976043 -0.056276 +vn -0.487197 0.863460 -0.130558 +vn -0.669057 0.721183 -0.179449 +vn -0.252388 0.956511 -0.146092 +vn -0.153508 0.984130 -0.088839 +vn -0.137059 0.987365 -0.079318 +vn -0.187872 0.976135 -0.108676 +vn -0.435926 0.863887 -0.252205 +vn -0.598956 0.721824 -0.346660 +vn -0.206091 0.956572 -0.206091 +vn -0.125340 0.984161 -0.125340 +vn -0.111911 0.987396 -0.111911 +vn -0.153356 0.976196 -0.153356 +vn -0.355907 0.864071 -0.355907 +vn -0.489151 0.722098 -0.489151 +vn -0.146092 0.956511 -0.252388 +vn -0.088839 0.984130 -0.153508 +vn -0.079318 0.987365 -0.137059 +vn -0.108676 0.976135 -0.187872 +vn -0.252205 0.863887 -0.435926 +vn -0.346660 0.721824 -0.598956 +vn -0.075686 0.956389 -0.282083 +vn -0.046022 0.984069 -0.171606 +vn -0.041078 0.987304 -0.153264 +vn -0.056276 0.976043 -0.210059 +vn -0.130558 0.863460 -0.487197 +vn -0.179449 0.721183 -0.669057 +vn 0.000000 0.956236 -0.292520 +vn 0.000000 0.984008 -0.177953 +vn 0.000000 0.987274 -0.158879 +vn 0.000000 0.975982 -0.217719 +vn 0.000000 0.863277 -0.504715 +vn 0.000000 0.720664 -0.693258 +vn 0.075686 0.956389 -0.282083 +vn 0.046022 0.984069 -0.171606 +vn 0.041078 0.987304 -0.153264 +vn 0.056276 0.976043 -0.210059 +vn 0.130558 0.863460 -0.487197 +vn 0.179449 0.721183 -0.669057 +vn 0.146092 0.956511 -0.252388 +vn 0.088839 0.984130 -0.153508 +vn 0.079318 0.987365 -0.137059 +vn 0.108676 0.976135 -0.187872 +vn 0.252205 0.863887 -0.435926 +vn 0.346660 0.721824 -0.598956 +vn 0.206091 0.956572 -0.206091 +vn 0.125340 0.984161 -0.125340 +vn 0.111911 0.987396 -0.111911 +vn 0.153356 0.976196 -0.153356 +vn 0.355907 0.864071 -0.355907 +vn 0.489151 0.722098 -0.489151 +vn 0.252388 0.956511 -0.146092 +vn 0.153508 0.984130 -0.088839 +vn 0.137059 0.987365 -0.079318 +vn 0.187872 0.976135 -0.108676 +vn 0.435926 0.863887 -0.252205 +vn 0.598956 0.721824 -0.346660 +vn 0.282083 0.956389 -0.075686 +vn 0.171606 0.984069 -0.046022 +vn 0.153264 0.987304 -0.041078 +vn 0.210059 0.976043 -0.056276 +vn 0.487197 0.863460 -0.130558 +vn 0.669057 0.721183 -0.179449 +vn 0.363842 0.931455 0.000000 +vn 0.000000 1.000000 0.000000 +vn 0.351451 0.931516 0.093509 +vn 0.968261 0.249916 0.000000 +vn 0.935423 0.249763 0.250130 +vn 0.842860 -0.538102 0.000000 +vn 0.813959 -0.538713 0.217292 +vn 0.786767 -0.617206 -0.000031 +vn 0.759514 -0.618000 0.202857 +vn 0.314432 0.931791 0.181280 +vn 0.838404 0.249855 0.484359 +vn 0.729026 -0.539720 0.420911 +vn 0.680013 -0.619068 0.392743 +vn 0.256386 0.931913 0.256417 +vn 0.684652 0.249886 0.684652 +vn 0.595050 -0.540147 0.595050 +vn 0.555010 -0.619526 0.555040 +vn 0.181280 0.931791 0.314432 +vn 0.484359 0.249825 0.838404 +vn 0.420881 -0.539720 0.729026 +vn 0.392712 -0.619098 0.680013 +vn 0.093509 0.931516 0.351451 +vn 0.250160 0.249763 0.935423 +vn 0.217322 -0.538713 0.813959 +vn 0.202887 -0.618030 0.759484 +vn 0.000000 0.931455 0.363842 +vn 0.000000 0.249916 0.968261 +vn 0.000000 -0.538102 0.842860 +vn 0.000031 -0.617206 0.786767 +vn -0.093509 0.931516 0.351451 +vn -0.250130 0.249763 0.935423 +vn -0.217292 -0.538682 0.813959 +vn -0.202857 -0.618000 0.759514 +vn -0.181280 0.931791 0.314432 +vn -0.484359 0.249855 0.838404 +vn -0.420911 -0.539720 0.729026 +vn -0.392743 -0.619068 0.680013 +vn -0.256417 0.931913 0.256386 +vn -0.684652 0.249886 0.684652 +vn -0.595050 -0.540147 0.595050 +vn -0.555040 -0.619526 0.555010 +vn -0.314432 0.931791 0.181280 +vn -0.838404 0.249825 0.484359 +vn -0.729026 -0.539720 0.420881 +vn -0.680013 -0.619098 0.392712 +vn -0.351451 0.931516 0.093509 +vn -0.935423 0.249763 0.250160 +vn -0.813959 -0.538713 0.217292 +vn -0.759484 -0.618030 0.202887 +vn -0.363842 0.931455 0.000000 +vn -0.968261 0.249916 0.000000 +vn -0.842860 -0.538102 0.000000 +vn -0.786767 -0.617206 0.000031 +vn -0.351451 0.931516 -0.093509 +vn -0.935423 0.249763 -0.250130 +vn -0.813959 -0.538713 -0.217292 +vn -0.759514 -0.618000 -0.202857 +vn -0.314432 0.931791 -0.181280 +vn -0.838404 0.249855 -0.484359 +vn -0.729026 -0.539720 -0.420911 +vn -0.680013 -0.619068 -0.392743 +vn -0.256386 0.931913 -0.256417 +vn -0.684652 0.249886 -0.684652 +vn -0.595050 -0.540147 -0.595050 +vn -0.555010 -0.619526 -0.555040 +vn -0.181280 0.931791 -0.314432 +vn -0.484359 0.249825 -0.838404 +vn -0.420881 -0.539720 -0.729026 +vn -0.392712 -0.619098 -0.680013 +vn -0.093509 0.931516 -0.351451 +vn -0.250160 0.249763 -0.935423 +vn -0.217322 -0.538713 -0.813959 +vn -0.202887 -0.618030 -0.759484 +vn 0.000000 0.931455 -0.363842 +vn 0.000000 0.249916 -0.968261 +vn 0.000000 -0.538102 -0.842860 +vn -0.000031 -0.617206 -0.786767 +vn 0.093509 0.931516 -0.351451 +vn 0.250130 0.249763 -0.935423 +vn 0.217292 -0.538682 -0.813959 +vn 0.202857 -0.618000 -0.759514 +vn 0.181280 0.931791 -0.314432 +vn 0.484359 0.249855 -0.838404 +vn 0.420911 -0.539720 -0.729026 +vn 0.392743 -0.619068 -0.680013 +vn 0.256417 0.931913 -0.256386 +vn 0.684652 0.249886 -0.684652 +vn 0.595050 -0.540147 -0.595050 +vn 0.555040 -0.619526 -0.555010 +vn 0.314432 0.931791 -0.181280 +vn 0.838404 0.249825 -0.484359 +vn 0.729026 -0.539720 -0.420881 +vn 0.680013 -0.619098 -0.392712 +vn 0.351451 0.931516 -0.093509 +vn 0.935423 0.249763 -0.250160 +vn 0.813959 -0.538713 -0.217292 +vn 0.759484 -0.618030 -0.202887 +vn -0.354198 0.930296 -0.095187 +vn 0.095187 0.930296 0.354198 +vn 0.354198 0.930296 0.095187 +vn 0.183721 0.930387 0.317179 +vn -0.183721 0.930387 -0.317179 +vn -0.367443 0.930021 0.000000 +vn -0.183721 0.930387 0.317179 +vn 0.367412 0.930021 0.000000 +vn -0.317179 0.930387 0.183721 +vn -0.095187 0.930296 -0.354198 +vn 0.000000 0.930021 -0.367443 +vn -0.354198 0.930296 0.095187 +vn 0.095187 0.930296 -0.354198 +vn 0.000000 0.930021 0.367443 +vn -0.317179 0.930387 -0.183721 +vn 0.317179 0.930387 -0.183721 +vn -0.095187 0.930296 0.354198 +vn 0.317179 0.930387 0.183721 +vn 0.354198 0.930296 -0.095187 +vn 0.183721 0.930387 -0.317179 +vn -0.034730 0.999390 0.000000 +vn 0.033479 0.999390 -0.009003 +vn 0.034730 0.999390 0.000000 +vn 0.009003 0.999390 -0.033479 +vn 0.000000 0.999390 -0.034730 +vn -0.259163 0.930387 0.259163 +vn -0.017335 0.999390 0.029939 +vn 0.947539 0.295083 0.122654 +vn -0.004486 0.999969 0.000000 +vn -0.004151 0.950468 0.310739 +vn -0.003021 0.719291 0.694662 +vn -0.998688 0.050722 0.000000 +vn -0.003143 0.719321 -0.694632 +vn 0.970214 0.213324 -0.114505 +vn -0.136235 0.879482 -0.455947 +vn 0.949858 0.312662 0.000000 +vn 0.055757 -0.017579 -0.998260 +vn 0.201300 -0.540880 -0.816645 +vn 0.974456 -0.186071 -0.125645 +vn 0.988098 -0.096286 0.119938 +vn 0.974456 -0.186041 0.125614 +vn -0.879574 -0.475723 0.000000 +vn -0.873775 -0.472610 -0.114475 +vn 0.988067 -0.096286 -0.119938 +vn 0.295480 -0.855464 -0.425214 +vn -0.976196 -0.174993 -0.127903 +vn -0.971007 -0.205725 0.121677 +vn -0.976196 -0.174963 0.127903 +vn -0.976196 -0.174993 0.127903 +vn 0.896054 -0.372997 0.240699 +vn -0.802667 -0.373638 -0.464827 +vn -0.655812 -0.373852 -0.655812 +vn -0.240699 -0.373028 -0.896023 +vn -0.464827 -0.373638 -0.802667 +vn -0.896023 -0.373028 0.240699 +vn 0.000000 -0.372539 -0.927976 +vn -0.655812 -0.373852 0.655812 +vn 0.240699 -0.373028 0.896023 +vn -0.896023 -0.373028 -0.240699 +vn 0.802667 -0.373638 -0.464827 +vn 0.655812 -0.373882 0.655812 +vn 0.464827 -0.373638 0.802667 +vn -0.464827 -0.373638 0.802667 +vn 0.240699 -0.373028 -0.896023 +vn 0.802667 -0.373638 0.464827 +vn -0.033479 0.999390 0.009003 +vn -0.259163 0.930387 -0.259163 +vn -0.024445 0.999390 -0.024445 +vn -0.029939 0.999390 -0.017335 +vn 0.259163 0.930387 -0.259163 +vn 0.024445 0.999390 -0.024445 +vn 0.017335 0.999390 -0.029939 +vn 0.029939 0.999390 -0.017335 +vn 0.033479 0.999390 0.009003 +vn -0.009003 0.999390 0.033479 +vn 0.000000 0.999390 0.034730 +vn -0.017335 0.999390 -0.029939 +vn 0.259163 0.930387 0.259163 +vn 0.029939 0.999390 0.017335 +vn -0.009003 0.999390 -0.033479 +vn 0.024445 0.999390 0.024445 +vn 0.017335 0.999390 0.029939 +vn 0.009003 0.999390 0.033479 +vn -0.033479 0.999390 -0.009003 +vn -0.024445 0.999390 0.024445 +vn -0.029939 0.999390 0.017335 +vn 0.055757 -0.017579 0.998260 +vn 0.294198 -0.855403 0.426252 +vn 0.201300 -0.540880 0.816614 +s 1 +f 34//1 1243//2 593//3 +f 52//4 27//5 40//6 +f 52//4 40//6 65//7 +f 77//8 52//4 65//7 +f 77//8 65//7 84//9 +f 107//10 77//8 84//9 +f 107//10 84//9 85//11 +f 115//12 107//10 85//11 +f 115//12 85//11 99//13 +f 129//14 115//12 99//13 +f 129//14 99//13 128//15 +f 1252//16 36//17 40//6 +f 65//7 40//6 64//18 +f 65//7 64//18 58//19 +f 84//9 65//7 58//19 +f 84//9 58//19 59//20 +f 85//11 84//9 59//20 +f 85//11 59//20 70//21 +f 99//13 85//11 70//21 +f 99//13 70//21 98//22 +f 128//15 99//13 98//22 +f 128//15 98//22 114//23 +f 1244//24 33//25 64//18 +f 58//19 64//18 33//25 +f 58//19 33//25 35//26 +f 59//20 58//19 35//26 +f 59//20 35//26 45//27 +f 70//21 59//20 45//27 +f 70//21 45//27 69//28 +f 98//22 70//21 69//28 +f 98//22 69//28 83//29 +f 114//23 98//22 83//29 +f 114//23 83//29 113//30 +f 553//31 1//32 566//33 +f 35//26 33//25 20//34 +f 35//26 20//34 24//35 +f 45//27 35//26 24//35 +f 45//27 24//35 44//36 +f 69//28 45//27 44//36 +f 69//28 44//36 57//37 +f 83//29 69//28 57//37 +f 83//29 57//37 82//38 +f 113//30 83//29 82//38 +f 113//30 82//38 112//39 +f 566//33 1283//40 9//41 +f 24//35 20//34 18//42 +f 24//35 18//42 23//43 +f 44//36 24//35 23//43 +f 44//36 23//43 32//44 +f 57//37 44//36 32//44 +f 57//37 32//44 56//45 +f 82//38 57//37 56//45 +f 82//38 56//45 81//46 +f 112//39 82//38 81//46 +f 112//39 81//46 111//47 +f 4//48 8//49 1250//50 +f 23//43 18//42 8//49 +f 23//43 8//49 17//51 +f 32//44 23//43 17//51 +f 32//44 17//51 31//52 +f 56//45 32//44 31//52 +f 56//45 31//52 55//53 +f 81//46 56//45 55//53 +f 81//46 55//53 80//54 +f 111//47 81//46 80//54 +f 111//47 80//54 110//55 +f 565//56 592//57 1233//58 +f 17//51 8//49 4//48 +f 17//51 4//48 16//59 +f 31//52 17//51 16//59 +f 31//52 16//59 30//60 +f 55//53 31//52 30//60 +f 55//53 30//60 54//61 +f 80//54 55//53 54//61 +f 80//54 54//61 79//62 +f 110//55 80//54 79//62 +f 110//55 79//62 109//63 +f 1//32 565//56 2//64 +f 6//65 2//64 565//56 +f 16//59 4//48 7//66 +f 16//59 7//66 22//67 +f 30//60 16//59 22//67 +f 30//60 22//67 43//68 +f 54//61 30//60 43//68 +f 54//61 43//68 68//69 +f 79//62 54//61 68//69 +f 79//62 68//69 97//70 +f 109//63 79//62 97//70 +f 109//63 97//70 127//71 +f 565//56 1233//58 1249//58 +f 13//72 14//73 5//74 +f 22//67 7//66 15//75 +f 22//67 15//75 29//76 +f 43//68 22//67 29//76 +f 43//68 29//76 42//77 +f 68//69 43//68 42//77 +f 68//69 42//77 67//78 +f 97//70 68//69 67//78 +f 97//70 67//78 96//79 +f 127//71 97//70 96//79 +f 127//71 96//79 126//80 +f 11//81 15//75 1240//82 +f 1289//83 34//1 593//3 +f 29//76 15//75 14//73 +f 29//76 14//73 21//84 +f 42//77 29//76 21//84 +f 42//77 21//84 41//85 +f 67//78 42//77 41//85 +f 67//78 41//85 66//86 +f 96//79 67//78 66//86 +f 96//79 66//86 95//87 +f 126//80 96//79 95//87 +f 126//80 95//87 125//88 +f 636//89 1243//2 26//2 +f 636//89 26//2 592//57 +f 21//84 14//73 13//72 +f 21//84 13//72 28//90 +f 41//85 21//84 28//90 +f 41//85 28//90 53//91 +f 66//86 41//85 53//91 +f 66//86 53//91 78//92 +f 95//87 66//86 78//92 +f 95//87 78//92 108//93 +f 125//88 95//87 108//93 +f 125//88 108//93 136//94 +f 12//95 13//72 5//74 +f 28//90 13//72 27//5 +f 28//90 27//5 52//4 +f 53//91 28//90 52//4 +f 53//91 52//4 77//8 +f 78//92 53//91 77//8 +f 78//92 77//8 107//10 +f 108//93 78//92 107//10 +f 108//93 107//10 115//12 +f 136//94 108//93 115//12 +f 136//94 115//12 129//14 +f 148//96 129//14 128//15 +f 148//96 128//15 143//97 +f 121//98 148//96 143//97 +f 121//98 143//97 122//99 +f 92//100 121//98 122//99 +f 92//100 122//99 93//101 +f 62//102 92//100 93//101 +f 62//102 93//101 63//103 +f 39//104 62//102 63//103 +f 39//104 63//103 51//105 +f 10//106 39//104 51//105 +f 10//106 51//105 49//107 +f 143//97 128//15 114//23 +f 143//97 114//23 142//108 +f 122//99 143//97 142//108 +f 122//99 142//108 123//109 +f 93//101 122//99 123//109 +f 93//101 123//109 94//110 +f 63//103 93//101 94//110 +f 63//103 94//110 76//111 +f 51//105 63//103 76//111 +f 51//105 76//111 75//112 +f 49//107 51//105 75//112 +f 49//107 75//112 61//113 +f 142//108 114//23 113//30 +f 142//108 113//30 141//114 +f 123//109 142//108 141//114 +f 123//109 141//114 124//115 +f 94//110 123//109 124//115 +f 94//110 124//115 106//116 +f 76//111 94//110 106//116 +f 76//111 106//116 105//117 +f 75//112 76//111 105//117 +f 75//112 105//117 91//118 +f 61//113 75//112 91//118 +f 61//113 91//118 90//119 +f 141//114 113//30 112//39 +f 141//114 112//39 140//120 +f 124//115 141//114 140//120 +f 124//115 140//120 135//121 +f 106//116 124//115 135//121 +f 106//116 135//121 134//122 +f 105//117 106//116 134//122 +f 105//117 134//122 120//123 +f 91//118 105//117 120//123 +f 91//118 120//123 119//124 +f 90//119 91//118 119//124 +f 140//120 112//39 111//47 +f 140//120 111//47 139//125 +f 135//121 140//120 139//125 +f 135//121 139//125 155//126 +f 134//122 135//121 155//126 +f 134//122 155//126 147//127 +f 120//123 134//122 147//127 +f 120//123 147//127 144//128 +f 119//124 120//123 144//128 +f 119//124 144//128 116//129 +f 26//2 1234//130 592//57 +f 139//125 111//47 110//55 +f 139//125 110//55 138//131 +f 155//126 139//125 138//131 +f 155//126 138//131 156//132 +f 147//127 155//126 156//132 +f 147//127 156//132 145//133 +f 144//128 147//127 145//133 +f 144//128 145//133 117//134 +f 116//129 144//128 117//134 +f 116//129 117//134 88//135 +f 27//5 13//72 12//95 +f 1242//136 88//135 71//137 +f 138//131 110//55 109//63 +f 138//131 109//63 137//138 +f 156//132 138//131 137//138 +f 156//132 137//138 154//139 +f 145//133 156//132 154//139 +f 145//133 154//139 131//140 +f 117//134 145//133 131//140 +f 117//134 131//140 101//141 +f 88//135 117//134 101//141 +f 88//135 101//141 86//142 +f 60//143 74//144 1248//145 +f 137//138 109//63 127//71 +f 137//138 127//71 151//146 +f 154//139 137//138 151//146 +f 154//139 151//146 153//147 +f 131//140 154//139 153//147 +f 131//140 153//147 130//148 +f 101//141 131//140 130//148 +f 101//141 130//148 100//149 +f 86//142 101//141 100//149 +f 86//142 100//149 74//144 +f 47//150 1235//151 631//152 +f 74//144 48//153 1248//145 +f 151//146 127//71 126//80 +f 151//146 126//80 150//154 +f 153//147 151//146 150//154 +f 153//147 150//154 146//155 +f 130//148 153//147 146//155 +f 130//148 146//155 118//156 +f 100//149 130//148 118//156 +f 100//149 118//156 89//157 +f 74//144 100//149 89//157 +f 74//144 89//157 48//153 +f 1247//158 87//159 715//160 +f 104//161 116//129 1242//136 +f 150//154 126//80 125//88 +f 150//154 125//88 149//162 +f 146//155 150//154 149//162 +f 146//155 149//162 132//163 +f 118//156 146//155 132//163 +f 118//156 132//163 102//164 +f 89//157 118//156 102//164 +f 89//157 102//164 72//165 +f 48//153 89//157 72//165 +f 48//153 72//165 46//166 +f 37//167 48//153 46//166 +f 37//167 46//166 38//168 +f 149//162 125//88 136//94 +f 149//162 136//94 152//169 +f 132//163 149//162 152//169 +f 132//163 152//169 133//170 +f 102//164 132//163 133//170 +f 102//164 133//170 103//171 +f 72//165 102//164 103//171 +f 72//165 103//171 73//172 +f 46//166 72//165 73//172 +f 46//166 73//172 50//173 +f 38//168 46//166 50//173 +f 38//168 50//173 25//174 +f 152//169 136//94 129//14 +f 152//169 129//14 148//96 +f 133//170 152//169 148//96 +f 133//170 148//96 121//98 +f 103//171 133//170 121//98 +f 103//171 121//98 92//100 +f 73//172 103//171 92//100 +f 73//172 92//100 62//102 +f 50//173 73//172 62//102 +f 50//173 62//102 39//104 +f 25//174 50//173 39//104 +f 39//104 10//106 25//174 +f 539//175 509//176 159//177 +f 160//178 158//179 157//180 +f 166//181 160//178 163//182 +f 166//181 163//182 173//183 +f 177//184 166//181 173//183 +f 177//184 173//183 183//185 +f 189//186 177//184 183//185 +f 189//186 183//185 197//187 +f 205//188 189//186 197//187 +f 205//188 197//187 216//189 +f 225//190 205//188 216//189 +f 225//190 216//189 235//191 +f 173//183 163//182 172//192 +f 173//183 172//192 184//193 +f 183//185 173//183 184//193 +f 183//185 184//193 198//194 +f 197//187 183//185 198//194 +f 197//187 198//194 217//195 +f 216//189 197//187 217//195 +f 216//189 217//195 236//196 +f 235//191 216//189 236//196 +f 235//191 236//196 253//197 +f 182//198 172//192 1254//199 +f 1255//200 167//201 595//202 +f 184//193 172//192 182//198 +f 184//193 182//198 196//203 +f 198//194 184//193 196//203 +f 198//194 196//203 214//204 +f 217//195 198//194 214//204 +f 217//195 214//204 232//205 +f 236//196 217//195 232//205 +f 236//196 232//205 250//206 +f 253//197 236//196 250//206 +f 253//197 250//206 267//207 +f 196//203 182//198 199//208 +f 196//203 199//208 215//209 +f 214//204 196//203 215//209 +f 214//204 215//209 233//210 +f 232//205 214//204 233//210 +f 232//205 233//210 251//211 +f 250//206 232//205 251//211 +f 250//206 251//211 257//212 +f 267//207 250//206 257//212 +f 267//207 257//212 256//213 +f 215//209 199//208 218//214 +f 215//209 218//214 234//215 +f 233//210 215//209 234//215 +f 233//210 234//215 241//216 +f 251//211 233//210 241//216 +f 251//211 241//216 240//217 +f 257//212 251//211 240//217 +f 257//212 240//217 239//218 +f 256//213 257//212 239//218 +f 256//213 239//218 238//219 +f 234//215 218//214 219//220 +f 234//215 219//220 224//221 +f 241//216 234//215 224//221 +f 241//216 224//221 223//222 +f 240//217 241//216 223//222 +f 240//217 223//222 222//223 +f 239//218 240//217 222//223 +f 239//218 222//223 221//224 +f 238//219 239//218 221//224 +f 238//219 221//224 220//225 +f 219//220 218//214 1285//226 +f 648//227 691//228 207//229 +f 224//221 219//220 208//230 +f 224//221 208//230 204//231 +f 223//222 224//221 204//231 +f 223//222 204//231 203//232 +f 222//223 223//222 203//232 +f 222//223 203//232 202//233 +f 221//224 222//223 202//233 +f 221//224 202//233 201//234 +f 220//225 221//224 201//234 +f 220//225 201//234 212//235 +f 204//231 208//230 191//236 +f 204//231 191//236 188//237 +f 203//232 204//231 188//237 +f 203//232 188//237 187//238 +f 202//233 203//232 187//238 +f 202//233 187//238 186//239 +f 201//234 202//233 186//239 +f 201//234 186//239 194//240 +f 212//235 201//234 194//240 +f 212//235 194//240 211//241 +f 188//237 191//236 174//242 +f 188//237 174//242 176//243 +f 187//238 188//237 176//243 +f 187//238 176//243 175//244 +f 186//239 187//238 175//244 +f 186//239 175//244 180//245 +f 194//240 186//239 180//245 +f 194//240 180//245 193//246 +f 211//241 194//240 193//246 +f 211//241 193//246 210//247 +f 613//248 585//249 1258//250 +f 176//243 174//242 168//251 +f 176//243 168//251 165//252 +f 175//244 176//243 165//252 +f 175//244 165//252 170//253 +f 180//245 175//244 170//253 +f 180//245 170//253 179//254 +f 193//246 180//245 179//254 +f 193//246 179//254 192//255 +f 210//247 193//246 192//255 +f 210//247 192//255 209//256 +f 168//251 174//242 164//257 +f 165//252 168//251 161//258 +f 165//252 161//258 162//259 +f 170//253 165//252 162//259 +f 170//253 162//259 171//260 +f 179//254 170//253 171//260 +f 179//254 171//260 181//261 +f 192//255 179//254 181//261 +f 192//255 181//261 195//262 +f 209//256 192//255 195//262 +f 209//256 195//262 213//263 +f 160//178 161//258 158//179 +f 161//258 160//178 162//259 +f 162//259 160//178 166//181 +f 171//260 162//259 166//181 +f 171//260 166//181 177//184 +f 181//261 171//260 177//184 +f 181//261 177//184 189//186 +f 195//262 181//261 189//186 +f 195//262 189//186 205//188 +f 213//263 195//262 205//188 +f 213//263 205//188 225//190 +f 242//264 225//190 235//191 +f 242//264 235//191 252//265 +f 258//266 242//264 252//265 +f 258//266 252//265 268//267 +f 273//268 258//266 268//267 +f 273//268 268//267 283//269 +f 287//270 273//268 283//269 +f 287//270 283//269 298//271 +f 300//272 287//270 298//271 +f 300//272 298//271 299//273 +f 312//274 300//272 299//273 +f 312//274 299//273 310//275 +f 252//265 235//191 253//197 +f 252//265 253//197 269//276 +f 268//267 252//265 269//276 +f 268//267 269//276 284//277 +f 283//269 268//267 284//277 +f 283//269 284//277 286//278 +f 298//271 283//269 286//278 +f 298//271 286//278 285//279 +f 299//273 298//271 285//279 +f 299//273 285//279 296//280 +f 310//275 299//273 296//280 +f 310//275 296//280 309//281 +f 269//276 253//197 267//207 +f 269//276 267//207 272//282 +f 284//277 269//276 272//282 +f 284//277 272//282 271//283 +f 286//278 284//277 271//283 +f 286//278 271//283 270//284 +f 285//279 286//278 270//284 +f 285//279 270//284 281//285 +f 296//280 285//279 281//285 +f 296//280 281//285 295//286 +f 309//281 296//280 295//286 +f 309//281 295//286 308//287 +f 272//282 267//207 256//213 +f 272//282 256//213 255//288 +f 271//283 272//282 255//288 +f 271//283 255//288 254//289 +f 270//284 271//283 254//289 +f 270//284 254//289 265//290 +f 281//285 270//284 265//290 +f 281//285 265//290 280//291 +f 295//286 281//285 280//291 +f 295//286 280//291 294//292 +f 308//287 295//286 294//292 +f 308//287 294//292 307//293 +f 255//288 256//213 238//219 +f 255//288 238//219 237//294 +f 254//289 255//288 237//294 +f 254//289 237//294 248//295 +f 265//290 254//289 248//295 +f 265//290 248//295 264//296 +f 280//291 265//290 264//296 +f 280//291 264//296 279//297 +f 294//292 280//291 279//297 +f 294//292 279//297 293//298 +f 307//293 294//292 293//298 +f 307//293 293//298 306//299 +f 237//294 238//219 220//225 +f 237//294 220//225 230//300 +f 248//295 237//294 230//300 +f 248//295 230//300 247//301 +f 264//296 248//295 247//301 +f 264//296 247//301 263//302 +f 279//297 264//296 263//302 +f 279//297 263//302 278//303 +f 293//298 279//297 278//303 +f 293//298 278//303 292//304 +f 306//299 293//298 292//304 +f 306//299 292//304 305//305 +f 230//300 220//225 212//235 +f 230//300 212//235 229//306 +f 247//301 230//300 229//306 +f 247//301 229//306 246//307 +f 263//302 247//301 246//307 +f 263//302 246//307 262//308 +f 278//303 263//302 262//308 +f 278//303 262//308 277//309 +f 292//304 278//303 277//309 +f 292//304 277//309 291//310 +f 305//305 292//304 291//310 +f 305//305 291//310 304//311 +f 229//306 212//235 211//241 +f 229//306 211//241 228//312 +f 246//307 229//306 228//312 +f 246//307 228//312 245//313 +f 262//308 246//307 245//313 +f 262//308 245//313 261//314 +f 277//309 262//308 261//314 +f 277//309 261//314 276//315 +f 291//310 277//309 276//315 +f 291//310 276//315 290//316 +f 304//311 291//310 290//316 +f 304//311 290//316 303//317 +f 228//312 211//241 210//247 +f 228//312 210//247 227//318 +f 245//313 228//312 227//318 +f 245//313 227//318 244//319 +f 261//314 245//313 244//319 +f 261//314 244//319 260//320 +f 276//315 261//314 260//320 +f 276//315 260//320 275//321 +f 290//316 276//315 275//321 +f 290//316 275//321 289//322 +f 303//317 290//316 289//322 +f 303//317 289//322 302//323 +f 227//318 210//247 209//256 +f 227//318 209//256 226//324 +f 244//319 227//318 226//324 +f 244//319 226//324 243//325 +f 260//320 244//319 243//325 +f 260//320 243//325 259//326 +f 275//321 260//320 259//326 +f 275//321 259//326 274//327 +f 289//322 275//321 274//327 +f 289//322 274//327 288//328 +f 302//323 289//322 288//328 +f 302//323 288//328 301//329 +f 226//324 209//256 213//263 +f 226//324 213//263 231//330 +f 243//325 226//324 231//330 +f 243//325 231//330 249//331 +f 259//326 243//325 249//331 +f 259//326 249//331 266//332 +f 274//327 259//326 266//332 +f 274//327 266//332 282//333 +f 288//328 274//327 282//333 +f 288//328 282//333 297//334 +f 301//329 288//328 297//334 +f 301//329 297//334 311//335 +f 231//330 213//263 225//190 +f 231//330 225//190 242//264 +f 249//331 231//330 242//264 +f 249//331 242//264 258//266 +f 266//332 249//331 258//266 +f 266//332 258//266 273//268 +f 282//333 266//332 273//268 +f 282//333 273//268 287//270 +f 297//334 282//333 287//270 +f 297//334 287//270 300//272 +f 311//335 297//334 300//272 +f 311//335 300//272 312//274 +f 312//274 310//275 323//336 +f 302//323 315//337 316//338 +f 304//311 317//339 318//340 +f 303//317 316//338 317//339 +f 309//281 308//287 321//341 +f 307//293 306//299 319//342 +f 311//335 313//343 314//344 +f 301//329 314//344 315//337 +f 312//274 324//345 313//343 +f 306//299 305//305 318//340 +f 308//287 307//293 320//346 +f 310//275 309//281 322//347 +f 322//347 321//341 325//348 +f 314//344 313//343 325//348 +f 323//336 322//347 325//348 +f 319//342 318//340 325//348 +f 315//337 314//344 325//348 +f 321//341 320//346 325//348 +f 324//345 323//336 325//348 +f 320//346 319//342 325//348 +f 317//339 316//338 325//348 +f 316//338 315//337 325//348 +f 313//343 324//345 325//348 +f 318//340 317//339 325//348 +f 326//349 327//350 328//351 +f 326//349 328//351 329//352 +f 333//353 326//349 329//352 +f 333//353 329//352 338//354 +f 347//355 333//353 338//354 +f 347//355 338//354 354//356 +f 364//357 347//355 354//356 +f 364//357 354//356 374//358 +f 386//359 364//357 374//358 +f 386//359 374//358 398//360 +f 412//361 386//359 398//360 +f 412//361 398//360 429//362 +f 329//352 328//351 334//363 +f 329//352 334//363 339//364 +f 338//354 329//352 339//364 +f 338//354 339//364 355//365 +f 354//356 338//354 355//365 +f 354//356 355//365 375//366 +f 374//358 354//356 375//366 +f 374//358 375//366 399//367 +f 398//360 374//358 399//367 +f 398//360 399//367 430//368 +f 429//362 398//360 430//368 +f 429//362 430//368 464//369 +f 339//364 334//363 342//370 +f 339//364 342//370 356//371 +f 355//365 339//364 356//371 +f 355//365 356//371 376//372 +f 375//366 355//365 376//372 +f 375//366 376//372 400//373 +f 399//367 375//366 400//373 +f 399//367 400//373 431//374 +f 430//368 399//367 431//374 +f 430//368 431//374 465//375 +f 464//369 430//368 465//375 +f 464//369 465//375 497//376 +f 356//371 342//370 351//377 +f 356//371 351//377 370//378 +f 376//372 356//371 370//378 +f 376//372 370//378 393//379 +f 400//373 376//372 393//379 +f 400//373 393//379 422//380 +f 431//374 400//373 422//380 +f 431//374 422//380 457//381 +f 465//375 431//374 457//381 +f 465//375 457//381 490//382 +f 497//376 465//375 490//382 +f 497//376 490//382 521//383 +f 370//378 351//377 361//384 +f 370//378 361//384 382//385 +f 393//379 370//378 382//385 +f 393//379 382//385 408//386 +f 422//380 393//379 408//386 +f 422//380 408//386 439//387 +f 457//381 422//380 439//387 +f 457//381 439//387 473//388 +f 490//382 457//381 473//388 +f 490//382 473//388 504//389 +f 521//383 490//382 504//389 +f 521//383 504//389 535//390 +f 382//385 361//384 369//391 +f 382//385 369//391 392//392 +f 408//386 382//385 392//392 +f 408//386 392//392 421//393 +f 439//387 408//386 421//393 +f 439//387 421//393 456//394 +f 473//388 439//387 456//394 +f 473//388 456//394 489//395 +f 504//389 473//388 489//395 +f 504//389 489//395 520//396 +f 535//390 504//389 520//396 +f 535//390 520//396 550//397 +f 392//392 369//391 380//398 +f 392//392 380//398 407//399 +f 421//393 392//392 407//399 +f 421//393 407//399 438//400 +f 456//394 421//393 438//400 +f 456//394 438//400 472//401 +f 489//395 456//394 472//401 +f 489//395 472//401 503//402 +f 520//396 489//395 503//402 +f 520//396 503//402 534//403 +f 550//397 520//396 534//403 +f 550//397 534//403 563//404 +f 407//399 380//398 391//405 +f 407//399 391//405 420//406 +f 438//400 407//399 420//406 +f 438//400 420//406 455//407 +f 472//401 438//400 455//407 +f 472//401 455//407 488//408 +f 503//402 472//401 488//408 +f 503//402 488//408 519//409 +f 534//403 503//402 519//409 +f 534//403 519//409 549//410 +f 563//404 534//403 549//410 +f 563//404 549//410 578//411 +f 420//406 391//405 404//412 +f 420//406 404//412 437//413 +f 455//407 420//406 437//413 +f 455//407 437//413 471//414 +f 488//408 455//407 471//414 +f 488//408 471//414 502//415 +f 519//409 488//408 502//415 +f 519//409 502//415 533//416 +f 549//410 519//409 533//416 +f 549//410 533//416 562//417 +f 578//411 549//410 562//417 +f 578//411 562//417 589//418 +f 437//413 404//412 419//419 +f 437//413 419//419 454//420 +f 471//414 437//413 454//420 +f 471//414 454//420 487//421 +f 502//415 471//414 487//421 +f 502//415 487//421 518//422 +f 533//416 502//415 518//422 +f 533//416 518//422 548//423 +f 562//417 533//416 548//423 +f 562//417 548//423 577//424 +f 589//418 562//417 577//424 +f 589//418 577//424 594//425 +f 454//420 419//419 436//426 +f 454//420 436//426 470//427 +f 487//421 454//420 470//427 +f 487//421 470//427 501//428 +f 518//422 487//421 501//428 +f 518//422 501//428 532//429 +f 548//423 518//422 532//429 +f 548//423 532//429 555//430 +f 577//424 548//423 555//430 +f 577//424 555//430 567//431 +f 594//425 577//424 567//431 +f 594//425 567//431 582//432 +f 470//427 436//426 453//433 +f 470//427 453//433 486//434 +f 501//428 470//427 486//434 +f 501//428 486//434 508//435 +f 532//429 501//428 508//435 +f 532//429 508//435 525//436 +f 555//430 532//429 525//436 +f 555//430 525//436 538//437 +f 567//431 555//430 538//437 +f 567//431 538//437 554//438 +f 582//432 567//431 554//438 +f 582//432 554//438 566//33 +f 486//434 453//433 462//439 +f 486//434 462//439 477//440 +f 508//435 486//434 477//440 +f 508//435 477//440 494//441 +f 525//436 508//435 494//441 +f 525//436 494//441 507//442 +f 538//437 525//436 507//442 +f 538//437 507//442 524//443 +f 554//438 538//437 524//443 +f 554//438 524//443 537//444 +f 566//33 554//438 537//444 +f 566//33 537//444 553//31 +f 477//440 462//439 443//445 +f 477//440 443//445 461//446 +f 494//441 477//440 461//446 +f 494//441 461//446 476//447 +f 507//442 494//441 476//447 +f 507//442 476//447 493//448 +f 524//443 507//442 493//448 +f 524//443 493//448 506//449 +f 537//444 524//443 506//449 +f 537//444 506//449 523//450 +f 553//31 537//444 523//450 +f 553//31 523//450 536//451 +f 461//446 443//445 426//452 +f 461//446 426//452 442//453 +f 476//447 461//446 442//453 +f 476//447 442//453 460//454 +f 493//448 476//447 460//454 +f 493//448 460//454 475//455 +f 506//449 493//448 475//455 +f 506//449 475//455 492//456 +f 523//450 506//449 492//456 +f 523//450 492//456 505//457 +f 536//451 523//450 505//457 +f 536//451 505//457 522//458 +f 442//453 426//452 411//459 +f 442//453 411//459 425//460 +f 460//454 442//453 425//460 +f 460//454 425//460 441//461 +f 475//455 460//454 441//461 +f 475//455 441//461 459//462 +f 492//456 475//455 459//462 +f 492//456 459//462 474//463 +f 505//457 492//456 474//463 +f 505//457 474//463 491//464 +f 522//458 505//457 491//464 +f 522//458 491//464 499//465 +f 425//460 411//459 396//466 +f 425//460 396//466 410//467 +f 441//461 425//460 410//467 +f 441//461 410//467 424//468 +f 459//462 441//461 424//468 +f 459//462 424//468 440//469 +f 474//463 459//462 440//469 +f 474//463 440//469 458//470 +f 491//464 474//463 458//470 +f 491//464 458//470 467//471 +f 499//465 491//464 467//471 +f 499//465 467//471 466//472 +f 410//467 396//466 385//473 +f 410//467 385//473 395//474 +f 424//468 410//467 395//474 +f 424//468 395//474 409//475 +f 440//469 424//468 409//475 +f 440//469 409//475 423//476 +f 458//470 440//469 423//476 +f 458//470 423//476 433//477 +f 467//471 458//470 433//477 +f 467//471 433//477 432//478 +f 466//472 467//471 432//478 +f 466//472 432//478 434//479 +f 395//474 385//473 372//480 +f 395//474 372//480 383//481 +f 409//475 395//474 383//481 +f 409//475 383//481 394//482 +f 423//476 409//475 394//482 +f 423//476 394//482 402//483 +f 433//477 423//476 402//483 +f 433//477 402//483 401//484 +f 432//478 433//477 401//484 +f 432//478 401//484 403//485 +f 434//479 432//478 403//485 +f 434//479 403//485 417//486 +f 383//481 372//480 362//487 +f 383//481 362//487 371//488 +f 394//482 383//481 371//488 +f 394//482 371//488 378//489 +f 402//483 394//482 378//489 +f 402//483 378//489 377//490 +f 401//484 402//483 377//490 +f 401//484 377//490 379//491 +f 403//485 401//484 379//491 +f 403//485 379//491 390//492 +f 417//486 403//485 390//492 +f 417//486 390//492 416//493 +f 371//488 362//487 352//494 +f 371//488 352//494 358//495 +f 378//489 371//488 358//495 +f 378//489 358//495 357//496 +f 377//490 378//489 357//496 +f 377//490 357//496 359//497 +f 379//491 377//490 359//497 +f 379//491 359//497 367//498 +f 390//492 379//491 367//498 +f 390//492 367//498 389//499 +f 416//493 390//492 389//499 +f 416//493 389//499 415//500 +f 358//495 352//494 345//501 +f 358//495 345//501 340//502 +f 357//496 358//495 340//502 +f 357//496 340//502 341//503 +f 359//497 357//496 341//503 +f 359//497 341//503 349//504 +f 367//498 359//497 349//504 +f 367//498 349//504 366//505 +f 389//499 367//498 366//505 +f 389//499 366//505 388//506 +f 415//500 389//499 388//506 +f 415//500 388//506 414//507 +f 340//502 345//501 335//508 +f 340//502 335//508 330//509 +f 341//503 340//502 330//509 +f 341//503 330//509 336//510 +f 349//504 341//503 336//510 +f 349//504 336//510 348//511 +f 366//505 349//504 348//511 +f 366//505 348//511 365//512 +f 388//506 366//505 365//512 +f 388//506 365//512 387//513 +f 414//507 388//506 387//513 +f 414//507 387//513 413//514 +f 330//509 335//508 327//350 +f 327//350 326//349 330//509 +f 330//509 326//349 336//510 +f 336//510 326//349 333//353 +f 348//511 336//510 333//353 +f 348//511 333//353 347//355 +f 365//512 348//511 347//355 +f 365//512 347//355 364//357 +f 387//513 365//512 364//357 +f 387//513 364//357 386//359 +f 413//514 387//513 386//359 +f 413//514 386//359 412//361 +f 445//515 412//361 429//362 +f 445//515 429//362 463//516 +f 478//517 445//515 463//516 +f 478//517 463//516 495//518 +f 509//176 478//517 495//518 +f 509//176 495//518 526//519 +f 463//516 429//362 464//369 +f 463//516 464//369 496//520 +f 495//518 463//516 496//520 +f 495//518 496//520 527//521 +f 526//519 495//518 527//521 +f 526//519 527//521 557//522 +f 556//523 526//519 557//522 +f 556//523 557//522 583//524 +f 595//202 556//523 583//524 +f 595//202 583//524 611//525 +f 621//526 595//202 611//525 +f 621//526 611//525 638//527 +f 496//520 464//369 497//376 +f 496//520 497//376 528//528 +f 527//521 496//520 528//528 +f 527//521 528//528 558//529 +f 557//522 527//521 558//529 +f 557//522 558//529 584//530 +f 583//524 557//522 584//530 +f 583//524 584//530 612//531 +f 611//525 583//524 612//531 +f 611//525 612//531 639//532 +f 638//527 611//525 639//532 +f 638//527 639//532 664//533 +f 528//528 497//376 521//383 +f 528//528 521//383 551//534 +f 558//529 528//528 551//534 +f 558//529 551//534 580//535 +f 584//530 558//529 580//535 +f 584//530 580//535 608//536 +f 612//531 584//530 608//536 +f 612//531 608//536 634//537 +f 639//532 612//531 634//537 +f 639//532 634//537 661//538 +f 664//533 639//532 661//538 +f 664//533 661//538 688//539 +f 551//534 521//383 535//390 +f 551//534 535//390 564//540 +f 580//535 551//534 564//540 +f 580//535 564//540 591//541 +f 608//536 580//535 591//541 +f 608//536 591//541 618//542 +f 634//537 608//536 618//542 +f 634//537 618//542 644//543 +f 661//538 634//537 644//543 +f 661//538 644//543 670//544 +f 688//539 661//538 670//544 +f 688//539 670//544 698//545 +f 564//540 535//390 550//397 +f 564//540 550//397 579//546 +f 591//541 564//540 579//546 +f 591//541 579//546 607//547 +f 618//542 591//541 607//547 +f 618//542 607//547 633//548 +f 644//543 618//542 633//548 +f 644//543 633//548 660//549 +f 670//544 644//543 660//549 +f 670//544 660//549 687//550 +f 698//545 670//544 687//550 +f 698//545 687//550 717//551 +f 579//546 550//397 563//404 +f 579//546 563//404 590//552 +f 607//547 579//546 590//552 +f 607//547 590//552 617//553 +f 633//548 607//547 617//553 +f 633//548 617//553 643//554 +f 660//549 633//548 643//554 +f 660//549 643//554 669//555 +f 687//550 660//549 669//555 +f 687//550 669//555 697//556 +f 717//551 687//550 697//556 +f 717//551 697//556 727//557 +f 590//552 563//404 578//411 +f 590//552 578//411 606//558 +f 617//553 590//552 606//558 +f 617//553 606//558 632//559 +f 643//554 617//553 632//559 +f 643//554 632//559 659//560 +f 669//555 643//554 659//560 +f 669//555 659//560 673//561 +f 697//556 669//555 673//561 +f 697//556 673//561 700//562 +f 727//557 697//556 700//562 +f 727//557 700//562 699//563 +f 606//558 578//411 589//418 +f 606//558 589//418 616//564 +f 632//559 606//558 616//564 +f 632//559 616//564 637//565 +f 659//560 632//559 637//565 +f 659//560 637//565 647//566 +f 673//561 659//560 647//566 +f 673//561 647//566 672//567 +f 700//562 673//561 672//567 +f 700//562 672//567 671//568 +f 699//563 700//562 671//568 +f 699//563 671//568 689//569 +f 616//564 589//418 594//425 +f 616//564 594//425 610//570 +f 637//565 616//564 610//570 +f 637//565 610//570 620//571 +f 647//566 637//565 620//571 +f 647//566 620//571 646//572 +f 672//567 647//566 646//572 +f 672//567 646//572 645//573 +f 671//568 672//567 645//573 +f 671//568 645//573 662//574 +f 689//569 671//568 662//574 +f 689//569 662//574 668//575 +f 610//570 594//425 582//432 +f 610//570 582//432 593//3 +f 620//571 610//570 593//3 +f 620//571 593//3 636//89 +f 646//572 620//571 636//89 +f 646//572 636//89 619//576 +f 645//573 646//572 619//576 +f 645//573 619//576 635//577 +f 662//574 645//573 635//577 +f 662//574 635//577 642//578 +f 668//575 662//574 642//578 +f 668//575 642//578 641//579 +f 593//3 582//432 566//33 +f 619//576 636//89 592//57 +f 619//576 592//57 609//580 +f 635//577 619//576 609//580 +f 635//577 609//580 615//581 +f 642//578 635//577 615//581 +f 642//578 615//581 614//582 +f 641//579 642//578 614//582 +f 592//57 565//56 581//583 +f 609//580 592//57 581//583 +f 609//580 581//583 587//584 +f 615//581 609//580 587//584 +f 615//581 587//584 586//585 +f 614//582 615//581 586//585 +f 614//582 586//585 588//586 +f 565//56 553//31 536//451 +f 565//56 536//451 552//587 +f 581//583 565//56 552//587 +f 581//583 552//587 560//588 +f 587//584 581//583 560//588 +f 587//584 560//588 559//589 +f 586//585 587//584 559//589 +f 586//585 559//589 561//590 +f 588//586 586//585 561//590 +f 588//586 561//590 576//591 +f 605//592 588//586 576//591 +f 605//592 576//591 604//593 +f 552//587 536//451 522//458 +f 552//587 522//458 530//594 +f 560//588 552//587 530//594 +f 560//588 530//594 529//595 +f 559//589 560//588 529//595 +f 559//589 529//595 531//596 +f 561//590 559//589 531//596 +f 561//590 531//596 547//597 +f 576//591 561//590 547//597 +f 576//591 547//597 575//598 +f 604//593 576//591 575//598 +f 604//593 575//598 603//599 +f 530//594 522//458 499//465 +f 530//594 499//465 498//600 +f 529//595 530//594 498//600 +f 529//595 498//600 500//601 +f 531//596 529//595 500//601 +f 531//596 500//601 517//602 +f 547//597 531//596 517//602 +f 547//597 517//602 546//603 +f 575//598 547//597 546//603 +f 575//598 546//603 574//604 +f 603//599 575//598 574//604 +f 603//599 574//604 602//605 +f 498//600 499//465 466//472 +f 498//600 466//472 468//606 +f 500//601 498//600 468//606 +f 500//601 468//606 485//607 +f 517//602 500//601 485//607 +f 517//602 485//607 516//608 +f 546//603 517//602 516//608 +f 546//603 516//608 545//609 +f 574//604 546//603 545//609 +f 574//604 545//609 573//610 +f 602//605 574//604 573//610 +f 602//605 573//610 601//611 +f 468//606 466//472 434//479 +f 468//606 434//479 451//612 +f 485//607 468//606 451//612 +f 485//607 451//612 484//613 +f 516//608 485//607 484//613 +f 516//608 484//613 515//614 +f 545//609 516//608 515//614 +f 545//609 515//614 544//615 +f 573//610 545//609 544//615 +f 573//610 544//615 572//616 +f 601//611 573//610 572//616 +f 601//611 572//616 600//617 +f 451//612 434//479 417//486 +f 451//612 417//486 450//618 +f 484//613 451//612 450//618 +f 484//613 450//618 483//619 +f 515//614 484//613 483//619 +f 515//614 483//619 514//620 +f 544//615 515//614 514//620 +f 544//615 514//620 543//621 +f 572//616 544//615 543//621 +f 572//616 543//621 571//622 +f 600//617 572//616 571//622 +f 600//617 571//622 599//623 +f 450//618 417//486 416//493 +f 450//618 416//493 449//624 +f 483//619 450//618 449//624 +f 483//619 449//624 482//625 +f 514//620 483//619 482//625 +f 514//620 482//625 513//626 +f 543//621 514//620 513//626 +f 543//621 513//626 542//627 +f 571//622 543//621 542//627 +f 571//622 542//627 570//628 +f 599//623 571//622 570//628 +f 599//623 570//628 598//629 +f 449//624 416//493 415//500 +f 449//624 415//500 448//630 +f 482//625 449//624 448//630 +f 482//625 448//630 481//631 +f 513//626 482//625 481//631 +f 513//626 481//631 512//632 +f 542//627 513//626 512//632 +f 542//627 512//632 541//633 +f 570//628 542//627 541//633 +f 570//628 541//633 569//634 +f 598//629 570//628 569//634 +f 598//629 569//634 597//635 +f 448//630 415//500 414//507 +f 448//630 414//507 447//636 +f 481//631 448//630 447//636 +f 481//631 447//636 480//637 +f 512//632 481//631 480//637 +f 512//632 480//637 511//638 +f 541//633 512//632 511//638 +f 541//633 511//638 540//639 +f 569//634 541//633 540//639 +f 569//634 540//639 568//640 +f 597//635 569//634 568//640 +f 597//635 568//640 596//641 +f 447//636 414//507 413//514 +f 447//636 413//514 446//642 +f 480//637 447//636 446//642 +f 480//637 446//642 479//643 +f 511//638 480//637 479//643 +f 511//638 479//643 510//644 +f 540//639 511//638 510//644 +f 540//639 510//644 539//175 +f 568//640 540//639 539//175 +f 568//640 539//175 585//249 +f 596//641 568//640 585//249 +f 596//641 585//249 613//248 +f 446//642 413//514 412//361 +f 446//642 412//361 445//515 +f 479//643 446//642 445//515 +f 479//643 445//515 478//517 +f 510//644 479//643 478//517 +f 510//644 478//517 509//176 +f 539//175 510//644 509//176 +f 691//228 648//227 674//645 +f 702//646 691//228 674//645 +f 702//646 674//645 701//647 +f 731//648 702//646 701//647 +f 731//648 701//647 730//649 +f 759//650 731//648 730//649 +f 759//650 730//649 758//651 +f 786//652 759//650 758//651 +f 786//652 758//651 785//653 +f 648//227 621//526 638//527 +f 648//227 638//527 663//654 +f 674//645 648//227 663//654 +f 674//645 663//654 690//655 +f 701//647 674//645 690//655 +f 701//647 690//655 720//656 +f 730//649 701//647 720//656 +f 730//649 720//656 749//657 +f 758//651 730//649 749//657 +f 758//651 749//657 777//658 +f 785//653 758//651 777//658 +f 785//653 777//658 805//659 +f 663//654 638//527 664//533 +f 663//654 664//533 692//660 +f 690//655 663//654 692//660 +f 690//655 692//660 721//661 +f 720//656 690//655 721//661 +f 720//656 721//661 750//662 +f 749//657 720//656 750//662 +f 749//657 750//662 778//663 +f 777//658 749//657 778//663 +f 777//658 778//663 806//664 +f 805//659 777//658 806//664 +f 805//659 806//664 833//665 +f 692//660 664//533 688//539 +f 692//660 688//539 718//666 +f 721//661 692//660 718//666 +f 721//661 718//666 747//667 +f 750//662 721//661 747//667 +f 750//662 747//667 775//668 +f 778//663 750//662 775//668 +f 778//663 775//668 803//669 +f 806//664 778//663 803//669 +f 806//664 803//669 831//670 +f 833//665 806//664 831//670 +f 833//665 831//670 838//671 +f 718//666 688//539 698//545 +f 718//666 698//545 728//672 +f 747//667 718//666 728//672 +f 747//667 728//672 756//673 +f 775//668 747//667 756//673 +f 775//668 756//673 784//674 +f 803//669 775//668 784//674 +f 803//669 784//674 804//675 +f 831//670 803//669 804//675 +f 831//670 804//675 811//676 +f 838//671 831//670 811//676 +f 838//671 811//676 830//677 +f 728//672 698//545 717//551 +f 728//672 717//551 746//678 +f 756//673 728//672 746//678 +f 756//673 746//678 757//679 +f 784//674 756//673 757//679 +f 784//674 757//679 776//680 +f 804//675 784//674 776//680 +f 804//675 776//680 783//681 +f 811//676 804//675 783//681 +f 811//676 783//681 802//682 +f 830//677 811//676 802//682 +f 830//677 802//682 810//683 +f 746//678 717//551 727//557 +f 746//678 727//557 729//684 +f 757//679 746//678 729//684 +f 757//679 729//684 748//685 +f 776//680 757//679 748//685 +f 776//680 748//685 755//686 +f 783//681 776//680 755//686 +f 783//681 755//686 774//687 +f 802//682 783//681 774//687 +f 802//682 774//687 782//688 +f 810//683 802//682 782//688 +f 810//683 782//688 809//689 +f 729//684 727//557 699//563 +f 729//684 699//563 719//690 +f 748//685 729//684 719//690 +f 748//685 719//690 726//691 +f 755//686 748//685 726//691 +f 755//686 726//691 745//692 +f 774//687 755//686 745//692 +f 774//687 745//692 754//693 +f 782//688 774//687 754//693 +f 782//688 754//693 781//694 +f 809//689 782//688 781//694 +f 809//689 781//694 780//695 +f 719//690 699//563 689//569 +f 719//690 689//569 696//696 +f 726//691 719//690 696//696 +f 726//691 696//696 716//697 +f 745//692 726//691 716//697 +f 745//692 716//697 725//698 +f 754//693 745//692 725//698 +f 754//693 725//698 753//699 +f 781//694 754//693 753//699 +f 781//694 753//699 752//700 +f 780//695 781//694 752//700 +f 780//695 752//700 773//701 +f 696//696 689//569 668//575 +f 696//696 668//575 686//702 +f 716//697 696//696 686//702 +f 716//697 686//702 695//703 +f 725//698 716//697 695//703 +f 725//698 695//703 724//704 +f 753//699 725//698 724//704 +f 753//699 724//704 723//705 +f 752//700 753//699 723//705 +f 752//700 723//705 744//706 +f 773//701 752//700 744//706 +f 773//701 744//706 772//707 +f 686//702 668//575 641//579 +f 686//702 641//579 667//708 +f 695//703 686//702 667//708 +f 695//703 667//708 715//160 +f 724//704 695//703 715//160 +f 724//704 715//160 694//709 +f 723//705 724//704 694//709 +f 723//705 694//709 714//710 +f 744//706 723//705 714//710 +f 744//706 714//710 743//711 +f 772//707 744//706 743//711 +f 772//707 743//711 771//712 +f 694//709 715//160 666//713 +f 694//709 666//713 685//714 +f 714//710 694//709 685//714 +f 714//710 685//714 713//715 +f 743//711 714//710 713//715 +f 743//711 713//715 742//716 +f 771//712 743//711 742//716 +f 771//712 742//716 770//717 +f 666//713 631//152 658//718 +f 685//714 666//713 658//718 +f 685//714 658//718 684//719 +f 713//715 685//714 684//719 +f 713//715 684//719 712//720 +f 742//716 713//715 712//720 +f 742//716 712//720 741//721 +f 770//717 742//716 741//721 +f 770//717 741//721 769//722 +f 631//152 605//592 604//593 +f 631//152 604//593 630//723 +f 658//718 631//152 630//723 +f 658//718 630//723 657//724 +f 684//719 658//718 657//724 +f 684//719 657//724 683//725 +f 712//720 684//719 683//725 +f 712//720 683//725 711//726 +f 741//721 712//720 711//726 +f 741//721 711//726 740//727 +f 769//722 741//721 740//727 +f 769//722 740//727 768//728 +f 630//723 604//593 603//599 +f 630//723 603//599 629//729 +f 657//724 630//723 629//729 +f 657//724 629//729 656//730 +f 683//725 657//724 656//730 +f 683//725 656//730 682//731 +f 711//726 683//725 682//731 +f 711//726 682//731 710//732 +f 740//727 711//726 710//732 +f 740//727 710//732 739//733 +f 768//728 740//727 739//733 +f 768//728 739//733 767//734 +f 629//729 603//599 602//605 +f 629//729 602//605 628//735 +f 656//730 629//729 628//735 +f 656//730 628//735 655//736 +f 682//731 656//730 655//736 +f 682//731 655//736 681//737 +f 710//732 682//731 681//737 +f 710//732 681//737 709//738 +f 739//733 710//732 709//738 +f 739//733 709//738 738//739 +f 767//734 739//733 738//739 +f 767//734 738//739 766//740 +f 628//735 602//605 601//611 +f 628//735 601//611 627//741 +f 655//736 628//735 627//741 +f 655//736 627//741 654//742 +f 681//737 655//736 654//742 +f 681//737 654//742 680//743 +f 709//738 681//737 680//743 +f 709//738 680//743 708//744 +f 738//739 709//738 708//744 +f 738//739 708//744 737//745 +f 766//740 738//739 737//745 +f 766//740 737//745 765//746 +f 627//741 601//611 600//617 +f 627//741 600//617 626//747 +f 654//742 627//741 626//747 +f 654//742 626//747 653//748 +f 680//743 654//742 653//748 +f 680//743 653//748 679//749 +f 708//744 680//743 679//749 +f 708//744 679//749 707//750 +f 737//745 708//744 707//750 +f 737//745 707//750 736//751 +f 765//746 737//745 736//751 +f 765//746 736//751 764//752 +f 626//747 600//617 599//623 +f 626//747 599//623 625//753 +f 653//748 626//747 625//753 +f 653//748 625//753 652//754 +f 679//749 653//748 652//754 +f 679//749 652//754 678//755 +f 707//750 679//749 678//755 +f 707//750 678//755 706//756 +f 736//751 707//750 706//756 +f 736//751 706//756 735//757 +f 764//752 736//751 735//757 +f 764//752 735//757 763//758 +f 625//753 599//623 598//629 +f 625//753 598//629 624//759 +f 652//754 625//753 624//759 +f 652//754 624//759 651//760 +f 678//755 652//754 651//760 +f 678//755 651//760 677//761 +f 706//756 678//755 677//761 +f 706//756 677//761 705//762 +f 735//757 706//756 705//762 +f 735//757 705//762 734//763 +f 763//758 735//757 734//763 +f 763//758 734//763 762//764 +f 624//759 598//629 597//635 +f 624//759 597//635 623//765 +f 651//760 624//759 623//765 +f 651//760 623//765 650//766 +f 677//761 651//760 650//766 +f 677//761 650//766 676//767 +f 705//762 677//761 676//767 +f 705//762 676//767 704//768 +f 734//763 705//762 704//768 +f 734//763 704//768 733//769 +f 762//764 734//763 733//769 +f 762//764 733//769 761//770 +f 623//765 597//635 596//641 +f 623//765 596//641 622//771 +f 650//766 623//765 622//771 +f 650//766 622//771 649//772 +f 676//767 650//766 649//772 +f 676//767 649//772 675//773 +f 704//768 676//767 675//773 +f 704//768 675//773 703//774 +f 733//769 704//768 703//774 +f 733//769 703//774 732//775 +f 761//770 733//769 732//775 +f 761//770 732//775 760//776 +f 622//771 596//641 613//248 +f 622//771 613//248 640//777 +f 649//772 622//771 640//777 +f 649//772 640//777 665//778 +f 675//773 649//772 665//778 +f 675//773 665//778 693//779 +f 703//774 675//773 693//779 +f 703//774 693//779 722//780 +f 732//775 703//774 722//780 +f 732//775 722//780 751//781 +f 760//776 732//775 751//781 +f 760//776 751//781 779//782 +f 693//779 665//778 691//228 +f 693//779 691//228 702//646 +f 722//780 693//779 702//646 +f 722//780 702//646 731//648 +f 751//781 722//780 731//648 +f 751//781 731//648 759//650 +f 779//782 751//781 759//650 +f 779//782 759//650 786//652 +f 917//783 918//784 913//785 +f 892//786 917//783 913//785 +f 892//786 913//785 887//787 +f 866//788 892//786 887//787 +f 866//788 887//787 861//789 +f 840//790 866//788 861//789 +f 840//790 861//789 834//791 +f 813//792 840//790 834//791 +f 813//792 834//791 807//793 +f 786//652 813//792 807//793 +f 786//652 807//793 779//782 +f 913//785 918//784 893//794 +f 887//787 913//785 893//794 +f 887//787 893//794 867//795 +f 861//789 887//787 867//795 +f 861//789 867//795 841//796 +f 834//791 861//789 841//796 +f 834//791 841//796 814//797 +f 807//793 834//791 814//797 +f 807//793 814//797 787//798 +f 779//782 807//793 787//798 +f 779//782 787//798 760//776 +f 893//794 918//784 894//799 +f 867//795 893//794 894//799 +f 867//795 894//799 868//800 +f 841//796 867//795 868//800 +f 841//796 868//800 842//801 +f 814//797 841//796 842//801 +f 814//797 842//801 815//802 +f 787//798 814//797 815//802 +f 787//798 815//802 788//803 +f 760//776 787//798 788//803 +f 760//776 788//803 761//770 +f 894//799 918//784 895//804 +f 868//800 894//799 895//804 +f 868//800 895//804 869//805 +f 842//801 868//800 869//805 +f 842//801 869//805 843//806 +f 815//802 842//801 843//806 +f 815//802 843//806 816//807 +f 788//803 815//802 816//807 +f 788//803 816//807 789//808 +f 761//770 788//803 789//808 +f 761//770 789//808 762//764 +f 895//804 918//784 896//809 +f 869//805 895//804 896//809 +f 869//805 896//809 870//810 +f 843//806 869//805 870//810 +f 843//806 870//810 844//811 +f 816//807 843//806 844//811 +f 816//807 844//811 817//812 +f 789//808 816//807 817//812 +f 789//808 817//812 790//813 +f 762//764 789//808 790//813 +f 762//764 790//813 763//758 +f 896//809 918//784 897//814 +f 870//810 896//809 897//814 +f 870//810 897//814 871//815 +f 844//811 870//810 871//815 +f 844//811 871//815 845//816 +f 817//812 844//811 845//816 +f 817//812 845//816 818//817 +f 790//813 817//812 818//817 +f 790//813 818//817 791//818 +f 763//758 790//813 791//818 +f 763//758 791//818 764//752 +f 897//814 918//784 898//819 +f 871//815 897//814 898//819 +f 871//815 898//819 872//820 +f 845//816 871//815 872//820 +f 845//816 872//820 846//821 +f 818//817 845//816 846//821 +f 818//817 846//821 819//822 +f 791//818 818//817 819//822 +f 791//818 819//822 792//823 +f 764//752 791//818 792//823 +f 764//752 792//823 765//746 +f 898//819 918//784 899//824 +f 872//820 898//819 899//824 +f 872//820 899//824 873//825 +f 846//821 872//820 873//825 +f 846//821 873//825 847//826 +f 819//822 846//821 847//826 +f 819//822 847//826 820//827 +f 792//823 819//822 820//827 +f 792//823 820//827 793//828 +f 765//746 792//823 793//828 +f 765//746 793//828 766//740 +f 899//824 918//784 900//829 +f 873//825 899//824 900//829 +f 873//825 900//829 874//830 +f 847//826 873//825 874//830 +f 847//826 874//830 848//831 +f 820//827 847//826 848//831 +f 820//827 848//831 821//832 +f 793//828 820//827 821//832 +f 793//828 821//832 794//833 +f 766//740 793//828 794//833 +f 766//740 794//833 767//734 +f 900//829 918//784 901//834 +f 874//830 900//829 901//834 +f 874//830 901//834 875//835 +f 848//831 874//830 875//835 +f 848//831 875//835 849//836 +f 821//832 848//831 849//836 +f 821//832 849//836 822//837 +f 794//833 821//832 822//837 +f 794//833 822//837 795//838 +f 767//734 794//833 795//838 +f 767//734 795//838 768//728 +f 901//834 918//784 902//839 +f 875//835 901//834 902//839 +f 875//835 902//839 876//840 +f 849//836 875//835 876//840 +f 849//836 876//840 850//841 +f 822//837 849//836 850//841 +f 822//837 850//841 823//842 +f 795//838 822//837 823//842 +f 795//838 823//842 796//843 +f 768//728 795//838 796//843 +f 768//728 796//843 769//722 +f 902//839 918//784 903//844 +f 876//840 902//839 903//844 +f 876//840 903//844 877//845 +f 850//841 876//840 877//845 +f 850//841 877//845 851//846 +f 823//842 850//841 851//846 +f 823//842 851//846 824//847 +f 796//843 823//842 824//847 +f 796//843 824//847 797//848 +f 769//722 796//843 797//848 +f 769//722 797//848 770//717 +f 903//844 918//784 904//849 +f 877//845 903//844 904//849 +f 877//845 904//849 878//850 +f 851//846 877//845 878//850 +f 851//846 878//850 852//851 +f 824//847 851//846 852//851 +f 824//847 852//851 825//852 +f 797//848 824//847 825//852 +f 797//848 825//852 798//853 +f 770//717 797//848 798//853 +f 770//717 798//853 771//712 +f 904//849 918//784 905//854 +f 878//850 904//849 905//854 +f 878//850 905//854 879//855 +f 852//851 878//850 879//855 +f 852//851 879//855 853//856 +f 825//852 852//851 853//856 +f 825//852 853//856 826//857 +f 798//853 825//852 826//857 +f 798//853 826//857 799//858 +f 771//712 798//853 799//858 +f 771//712 799//858 772//707 +f 905//854 918//784 906//859 +f 879//855 905//854 906//859 +f 879//855 906//859 880//860 +f 853//856 879//855 880//860 +f 853//856 880//860 854//861 +f 826//857 853//856 854//861 +f 826//857 854//861 827//862 +f 799//858 826//857 827//862 +f 799//858 827//862 800//863 +f 772//707 799//858 800//863 +f 772//707 800//863 773//701 +f 906//859 918//784 907//864 +f 880//860 906//859 907//864 +f 880//860 907//864 881//865 +f 854//861 880//860 881//865 +f 854//861 881//865 855//866 +f 827//862 854//861 855//866 +f 827//862 855//866 828//867 +f 800//863 827//862 828//867 +f 800//863 828//867 801//868 +f 773//701 800//863 801//868 +f 773//701 801//868 780//695 +f 907//864 918//784 908//869 +f 881//865 907//864 908//869 +f 881//865 908//869 882//870 +f 855//866 881//865 882//870 +f 855//866 882//870 856//871 +f 828//867 855//866 856//871 +f 828//867 856//871 829//872 +f 801//868 828//867 829//872 +f 801//868 829//872 808//873 +f 780//695 801//868 808//873 +f 780//695 808//873 809//689 +f 908//869 918//784 909//874 +f 882//870 908//869 909//874 +f 882//870 909//874 883//875 +f 856//871 882//870 883//875 +f 856//871 883//875 857//876 +f 829//872 856//871 857//876 +f 829//872 857//876 836//877 +f 808//873 829//872 836//877 +f 808//873 836//877 835//878 +f 809//689 808//873 835//878 +f 809//689 835//878 810//683 +f 909//874 918//784 910//879 +f 883//875 909//874 910//879 +f 883//875 910//879 884//880 +f 857//876 883//875 884//880 +f 857//876 884//880 863//881 +f 836//877 857//876 863//881 +f 836//877 863//881 862//882 +f 835//878 836//877 862//882 +f 835//878 862//882 837//883 +f 810//683 835//878 837//883 +f 810//683 837//883 830//677 +f 910//879 918//784 911//884 +f 884//880 910//879 911//884 +f 884//880 911//884 889//885 +f 863//881 884//880 889//885 +f 863//881 889//885 888//886 +f 862//882 863//881 888//886 +f 862//882 888//886 864//887 +f 837//883 862//882 864//887 +f 837//883 864//887 858//888 +f 830//677 837//883 858//888 +f 830//677 858//888 838//671 +f 911//884 918//784 915//889 +f 889//885 911//884 915//889 +f 889//885 915//889 914//890 +f 888//886 889//885 914//890 +f 888//886 914//890 890//891 +f 864//887 888//886 890//891 +f 864//887 890//891 885//892 +f 858//888 864//887 885//892 +f 858//888 885//892 859//893 +f 838//671 858//888 859//893 +f 838//671 859//893 833//665 +f 915//889 918//784 919//894 +f 914//890 915//889 919//894 +f 914//890 919//894 912//895 +f 890//891 914//890 912//895 +f 890//891 912//895 886//896 +f 885//892 890//891 886//896 +f 885//892 886//896 860//897 +f 859//893 885//892 860//897 +f 859//893 860//897 832//898 +f 833//665 859//893 832//898 +f 833//665 832//898 805//659 +f 919//894 918//784 916//899 +f 912//895 919//894 916//899 +f 912//895 916//899 891//900 +f 886//896 912//895 891//900 +f 886//896 891//900 865//901 +f 860//897 886//896 865//901 +f 860//897 865//901 839//902 +f 832//898 860//897 839//902 +f 832//898 839//902 812//903 +f 805//659 832//898 812//903 +f 805//659 812//903 785//653 +f 916//899 918//784 917//783 +f 891//900 916//899 917//783 +f 891//900 917//783 892//786 +f 865//901 891//900 892//786 +f 865//901 892//786 866//788 +f 839//902 865//901 866//788 +f 839//902 866//788 840//790 +f 812//903 839//902 840//790 +f 812//903 840//790 813//792 +f 785//653 812//903 813//792 +f 785//653 813//792 786//652 +f 404//412 1267//904 1268//905 +f 384//906 373//907 372//480 +f 346//908 345//501 352//494 +f 435//909 436//426 419//419 +f 331//910 327//350 335//508 +f 462//439 453//433 1265//911 +f 920//912 921//913 922//914 +f 920//912 922//914 923//915 +f 923//915 922//914 927//916 +f 923//915 927//916 933//917 +f 933//917 927//916 940//918 +f 933//917 940//918 949//919 +f 949//919 940//918 959//920 +f 949//919 959//920 971//921 +f 971//921 959//920 984//922 +f 971//921 984//922 999//923 +f 999//923 984//922 1011//924 +f 999//923 1011//924 1027//925 +f 1027//925 1011//924 1042//926 +f 1027//925 1042//926 1059//927 +f 1059//927 1042//926 1077//928 +f 1059//927 1077//928 1095//929 +f 1095//929 1077//928 1110//930 +f 1095//929 1110//930 1129//931 +f 1129//931 1110//930 1144//932 +f 1129//931 1144//932 1163//933 +f 1163//933 1144//932 1179//934 +f 1163//933 1179//934 1196//935 +f 1196//935 1179//934 1210//936 +f 1196//935 1210//936 1220//937 +f 1220//937 1210//936 1212//938 +f 1220//937 1212//938 1201//939 +f 1201//939 1212//938 1181//940 +f 1201//939 1181//940 1169//941 +f 1169//941 1181//940 1147//942 +f 1169//941 1147//942 1135//943 +f 1135//943 1147//942 1113//944 +f 1135//943 1113//944 1102//945 +f 1102//945 1113//944 1081//946 +f 1102//945 1081//946 1065//947 +f 1065//947 1081//946 1046//948 +f 1065//947 1046//948 1032//949 +f 1032//949 1046//948 1016//950 +f 1032//949 1016//950 1003//951 +f 1003//951 1016//950 988//952 +f 1003//951 988//952 974//953 +f 974//953 988//952 962//954 +f 974//953 962//954 951//955 +f 951//955 962//954 942//956 +f 951//955 942//956 934//957 +f 934//957 942//956 928//958 +f 934//957 928//958 924//959 +f 924//959 928//958 921//913 +f 921//913 920//912 924//959 +f 926//960 920//912 923//915 +f 926//960 923//915 932//961 +f 938//962 926//960 932//961 +f 938//962 932//961 947//963 +f 956//964 938//962 947//963 +f 956//964 947//963 968//965 +f 980//966 956//964 968//965 +f 980//966 968//965 995//967 +f 1006//968 980//966 995//967 +f 1006//968 995//967 1022//969 +f 1036//970 1006//968 1022//969 +f 1036//970 1022//969 1053//971 +f 932//961 923//915 933//917 +f 932//961 933//917 948//972 +f 947//963 932//961 948//972 +f 947//963 948//972 969//973 +f 968//965 947//963 969//973 +f 968//965 969//973 996//974 +f 995//967 968//965 996//974 +f 995//967 996//974 1023//975 +f 1022//969 995//967 1023//975 +f 1022//969 1023//975 1054//976 +f 1053//971 1022//969 1054//976 +f 1053//971 1054//976 1089//977 +f 948//972 933//917 949//919 +f 948//972 949//919 970//978 +f 969//973 948//972 970//978 +f 969//973 970//978 997//979 +f 996//974 969//973 997//979 +f 996//974 997//979 1024//980 +f 1023//975 996//974 1024//980 +f 1023//975 1024//980 1055//981 +f 1054//976 1023//975 1055//981 +f 1054//976 1055//981 1090//982 +f 1089//977 1054//976 1090//982 +f 1089//977 1090//982 1109//983 +f 970//978 949//919 971//921 +f 970//978 971//921 998//984 +f 997//979 970//978 998//984 +f 997//979 998//984 1025//985 +f 1024//980 997//979 1025//985 +f 1024//980 1025//985 1056//986 +f 1055//981 1024//980 1056//986 +f 1055//981 1056//986 1091//987 +f 1090//982 1055//981 1091//987 +f 1090//982 1091//987 1124//988 +f 1109//983 1090//982 1124//988 +f 1109//983 1124//988 1122//989 +f 998//984 971//921 999//923 +f 998//984 999//923 1026//990 +f 1025//985 998//984 1026//990 +f 1025//985 1026//990 1057//991 +f 1056//986 1025//985 1057//991 +f 1056//986 1057//991 1092//992 +f 1091//987 1056//986 1092//992 +f 1091//987 1092//992 1125//993 +f 1124//988 1091//987 1125//993 +f 1124//988 1125//993 1156//994 +f 1122//989 1124//988 1156//994 +f 1122//989 1156//994 1142//995 +f 1026//990 999//923 1027//925 +f 1026//990 1027//925 1058//996 +f 1057//991 1026//990 1058//996 +f 1057//991 1058//996 1093//997 +f 1092//992 1057//991 1093//997 +f 1092//992 1093//997 1126//998 +f 1125//993 1092//992 1126//998 +f 1125//993 1126//998 1159//999 +f 1156//994 1125//993 1159//999 +f 1156//994 1159//999 1176//1000 +f 1142//995 1156//994 1176//1000 +f 1142//995 1176//1000 1157//1001 +f 1058//996 1027//925 1059//927 +f 1058//996 1059//927 1094//1002 +f 1093//997 1058//996 1094//1002 +f 1093//997 1094//1002 1127//1003 +f 1126//998 1093//997 1127//1003 +f 1126//998 1127//1003 1160//1004 +f 1159//999 1126//998 1160//1004 +f 1159//999 1160//1004 1192//1005 +f 1176//1000 1159//999 1192//1005 +f 1176//1000 1192//1005 1189//1006 +f 1157//1001 1176//1000 1189//1006 +f 1157//1001 1189//1006 1178//1007 +f 1094//1002 1059//927 1095//929 +f 1094//1002 1095//929 1128//1008 +f 1127//1003 1094//1002 1128//1008 +f 1127//1003 1128//1008 1161//1009 +f 1160//1004 1127//1003 1161//1009 +f 1160//1004 1161//1009 1193//1010 +f 1192//1005 1160//1004 1193//1010 +f 1192//1005 1193//1010 1215//1011 +f 1189//1006 1192//1005 1215//1011 +f 1189//1006 1215//1011 1207//1012 +f 1178//1007 1189//1006 1207//1012 +f 1178//1007 1207//1012 1191//1013 +f 1128//1008 1095//929 1129//931 +f 1128//1008 1129//931 1162//1014 +f 1161//1009 1128//1008 1162//1014 +f 1161//1009 1162//1014 1194//1015 +f 1193//1010 1161//1009 1194//1015 +f 1193//1010 1194//1015 1217//1016 +f 1215//1011 1193//1010 1217//1016 +f 1215//1011 1217//1016 1227//1017 +f 1207//1012 1215//1011 1227//1017 +f 1207//1012 1227//1017 1216//1018 +f 1191//1013 1207//1012 1216//1018 +f 1191//1013 1216//1018 1209//1019 +f 1162//1014 1129//931 1163//933 +f 1162//1014 1163//933 1195//1020 +f 1194//1015 1162//1014 1195//1020 +f 1194//1015 1195//1020 1218//1021 +f 1217//1016 1194//1015 1218//1021 +f 1217//1016 1218//1021 1230//1022 +f 1227//1017 1217//1016 1230//1022 +f 1227//1017 1230//1022 1229//1023 +f 1216//1018 1227//1017 1229//1023 +f 1216//1018 1229//1023 1225//1024 +f 1209//1019 1216//1018 1225//1024 +f 1209//1019 1225//1024 1203//1025 +f 1195//1020 1163//933 1196//935 +f 1195//1020 1196//935 1219//1026 +f 1218//1021 1195//1020 1219//1026 +f 1218//1021 1219//1026 1231//1027 +f 1230//1022 1218//1021 1231//1027 +f 1230//1022 1231//1027 1232//1028 +f 1229//1023 1230//1022 1232//1028 +f 1229//1023 1232//1028 1228//1029 +f 1225//1024 1229//1023 1228//1029 +f 1225//1024 1228//1029 1214//1030 +f 1203//1025 1225//1024 1214//1030 +f 1203//1025 1214//1030 1184//1031 +f 1219//1026 1196//935 1220//937 +f 1219//1026 1220//937 1224//1032 +f 1231//1027 1219//1026 1224//1032 +f 1231//1027 1224//1032 1223//1033 +f 1232//1028 1231//1027 1223//1033 +f 1232//1028 1223//1033 1222//1034 +f 1228//1029 1232//1028 1222//1034 +f 1228//1029 1222//1034 1221//1035 +f 1214//1030 1228//1029 1221//1035 +f 1214//1030 1221//1035 1204//1036 +f 1184//1031 1214//1030 1204//1036 +f 1184//1031 1204//1036 1171//1037 +f 1224//1032 1220//937 1201//939 +f 1224//1032 1201//939 1200//1038 +f 1223//1033 1224//1032 1200//1038 +f 1223//1033 1200//1038 1199//1039 +f 1222//1034 1223//1033 1199//1039 +f 1222//1034 1199//1039 1198//1040 +f 1221//1035 1222//1034 1198//1040 +f 1221//1035 1198//1040 1197//1041 +f 1204//1036 1221//1035 1197//1041 +f 1204//1036 1197//1041 1185//1042 +f 1171//1037 1204//1036 1185//1042 +f 1171//1037 1185//1042 1151//1043 +f 1200//1038 1201//939 1169//941 +f 1200//1038 1169//941 1168//1044 +f 1199//1039 1200//1038 1168//1044 +f 1199//1039 1168//1044 1167//1045 +f 1198//1040 1199//1039 1167//1045 +f 1198//1040 1167//1045 1166//1046 +f 1197//1041 1198//1040 1166//1046 +f 1197//1041 1166//1046 1165//1047 +f 1185//1042 1197//1041 1165//1047 +f 1185//1042 1165//1047 1164//1048 +f 1151//1043 1185//1042 1164//1048 +f 1151//1043 1164//1048 1137//1049 +f 1168//1044 1169//941 1135//943 +f 1168//1044 1135//943 1134//1050 +f 1167//1045 1168//1044 1134//1050 +f 1167//1045 1134//1050 1133//1051 +f 1166//1046 1167//1045 1133//1051 +f 1166//1046 1133//1051 1132//1052 +f 1165//1047 1166//1046 1132//1052 +f 1165//1047 1132//1052 1131//1053 +f 1164//1048 1165//1047 1131//1053 +f 1164//1048 1131//1053 1130//1054 +f 1137//1049 1164//1048 1130//1054 +f 1137//1049 1130//1054 1117//1055 +f 1134//1050 1135//943 1102//945 +f 1134//1050 1102//945 1101//1056 +f 1133//1051 1134//1050 1101//1056 +f 1133//1051 1101//1056 1100//1057 +f 1132//1052 1133//1051 1100//1057 +f 1132//1052 1100//1057 1099//1058 +f 1131//1053 1132//1052 1099//1058 +f 1131//1053 1099//1058 1098//1059 +f 1130//1054 1131//1053 1098//1059 +f 1130//1054 1098//1059 1097//1060 +f 1117//1055 1130//1054 1097//1060 +f 1117//1055 1097//1060 1096//1061 +f 1101//1056 1102//945 1065//947 +f 1101//1056 1065//947 1064//1062 +f 1100//1057 1101//1056 1064//1062 +f 1100//1057 1064//1062 1063//1063 +f 1099//1058 1100//1057 1063//1063 +f 1099//1058 1063//1063 1062//1064 +f 1098//1059 1099//1058 1062//1064 +f 1098//1059 1062//1064 1061//1065 +f 1097//1060 1098//1059 1061//1065 +f 1097//1060 1061//1065 1060//1066 +f 1096//1061 1097//1060 1060//1066 +f 1096//1061 1060//1066 1066//1067 +f 1064//1062 1065//947 1032//949 +f 1064//1062 1032//949 1031//1068 +f 1063//1063 1064//1062 1031//1068 +f 1063//1063 1031//1068 1030//1069 +f 1062//1064 1063//1063 1030//1069 +f 1062//1064 1030//1069 1029//1070 +f 1061//1065 1062//1064 1029//1070 +f 1061//1065 1029//1070 1028//1071 +f 1060//1066 1061//1065 1028//1071 +f 1060//1066 1028//1071 1033//1072 +f 1066//1067 1060//1066 1033//1072 +f 1066//1067 1033//1072 1050//1073 +f 1031//1068 1032//949 1003//951 +f 1031//1068 1003//951 1002//1074 +f 1030//1069 1031//1068 1002//1074 +f 1030//1069 1002//1074 1001//1075 +f 1029//1070 1030//1069 1001//1075 +f 1029//1070 1001//1075 1000//1076 +f 1028//1071 1029//1070 1000//1076 +f 1028//1071 1000//1076 1004//1077 +f 1033//1072 1028//1071 1004//1077 +f 1033//1072 1004//1077 1021//1078 +f 1050//1073 1033//1072 1021//1078 +f 1050//1073 1021//1078 1041//1079 +f 1002//1074 1003//951 974//953 +f 1002//1074 974//953 973//1080 +f 1001//1075 1002//1074 973//1080 +f 1001//1075 973//1080 972//1081 +f 1000//1076 1001//1075 972//1081 +f 1000//1076 972//1081 975//1082 +f 1004//1077 1000//1076 975//1082 +f 1004//1077 975//1082 992//1083 +f 1021//1078 1004//1077 992//1083 +f 1021//1078 992//1083 1010//1084 +f 1041//1079 1021//1078 1010//1084 +f 1041//1079 1010//1084 1040//1085 +f 973//1080 974//953 951//955 +f 973//1080 951//955 950//1086 +f 972//1081 973//1080 950//1086 +f 972//1081 950//1086 952//1087 +f 975//1082 972//1081 952//1087 +f 975//1082 952//1087 965//1088 +f 992//1083 975//1082 965//1088 +f 992//1083 965//1088 983//1089 +f 1010//1084 992//1083 983//1089 +f 1010//1084 983//1089 1009//1090 +f 1040//1085 1010//1084 1009//1090 +f 1040//1085 1009//1090 1039//1091 +f 950//1086 951//955 934//957 +f 950//1086 934//957 935//1092 +f 952//1087 950//1086 935//1092 +f 952//1087 935//1092 944//1093 +f 965//1088 952//1087 944//1093 +f 965//1088 944//1093 958//1094 +f 983//1089 965//1088 958//1094 +f 983//1089 958//1094 982//1095 +f 1009//1090 983//1089 982//1095 +f 1009//1090 982//1095 1008//1096 +f 1039//1091 1009//1090 1008//1096 +f 1039//1091 1008//1096 1038//1097 +f 935//1092 934//957 924//959 +f 935//1092 924//959 929//1098 +f 944//1093 935//1092 929//1098 +f 944//1093 929//1098 939//1099 +f 958//1094 944//1093 939//1099 +f 958//1094 939//1099 957//1100 +f 982//1095 958//1094 957//1100 +f 982//1095 957//1100 981//1101 +f 1008//1096 982//1095 981//1101 +f 1008//1096 981//1101 1007//1102 +f 1038//1097 1008//1096 1007//1102 +f 1038//1097 1007//1102 1037//1103 +f 924//959 920//912 929//1098 +f 929//1098 920//912 926//960 +f 939//1099 929//1098 926//960 +f 939//1099 926//960 938//962 +f 957//1100 939//1099 938//962 +f 957//1100 938//962 956//964 +f 981//1101 957//1100 956//964 +f 981//1101 956//964 980//966 +f 1007//1102 981//1101 980//966 +f 1007//1102 980//966 1006//968 +f 1037//1103 1007//1102 1006//968 +f 1037//1103 1006//968 1036//970 +f 993//1104 1005//1105 976//1106 +f 966//1107 993//1104 976//1106 +f 966//1107 976//1106 953//1108 +f 945//1109 966//1107 953//1108 +f 945//1109 953//1108 936//1110 +f 930//1111 945//1109 936//1110 +f 930//1111 936//1110 925//1112 +f 921//913 930//1111 925//1112 +f 921//913 925//1112 922//914 +f 976//1106 1005//1105 977//1113 +f 953//1108 976//1106 977//1113 +f 953//1108 977//1113 954//1114 +f 936//1110 953//1108 954//1114 +f 936//1110 954//1114 937//1115 +f 925//1112 936//1110 937//1115 +f 925//1112 937//1115 931//1116 +f 922//914 925//1112 931//1116 +f 922//914 931//1116 927//916 +f 977//1113 1005//1105 978//1117 +f 954//1114 977//1113 978//1117 +f 954//1114 978//1117 955//1118 +f 937//1115 954//1114 955//1118 +f 937//1115 955//1118 946//1119 +f 931//1116 937//1115 946//1119 +f 931//1116 946//1119 941//1120 +f 927//916 931//1116 941//1120 +f 927//916 941//1120 940//918 +f 978//1117 1005//1105 979//1121 +f 955//1118 978//1117 979//1121 +f 955//1118 979//1121 967//1122 +f 946//1119 955//1118 967//1122 +f 946//1119 967//1122 961//1123 +f 941//1120 946//1119 961//1123 +f 941//1120 961//1123 960//1124 +f 940//918 941//1120 960//1124 +f 940//918 960//1124 959//920 +f 979//1121 1005//1105 994//1125 +f 967//1122 979//1121 994//1125 +f 967//1122 994//1125 987//1126 +f 961//1123 967//1122 987//1126 +f 961//1123 987//1126 986//1127 +f 960//1124 961//1123 986//1127 +f 960//1124 986//1127 985//1128 +f 959//920 960//1124 985//1128 +f 959//920 985//1128 984//922 +f 994//1125 1005//1105 1015//1129 +f 987//1126 994//1125 1015//1129 +f 987//1126 1015//1129 1014//1130 +f 986//1127 987//1126 1014//1130 +f 986//1127 1014//1130 1013//1131 +f 985//1128 986//1127 1013//1131 +f 985//1128 1013//1131 1012//1132 +f 984//922 985//1128 1012//1132 +f 984//922 1012//1132 1011//924 +f 1015//1129 1005//1105 1035//1133 +f 1014//1130 1015//1129 1035//1133 +f 1014//1130 1035//1133 1045//1134 +f 1013//1131 1014//1130 1045//1134 +f 1013//1131 1045//1134 1044//1135 +f 1012//1132 1013//1131 1044//1135 +f 1012//1132 1044//1135 1043//1136 +f 1011//924 1012//1132 1043//1136 +f 1011//924 1043//1136 1042//926 +f 1035//1133 1005//1105 1052//1137 +f 1045//1134 1035//1133 1052//1137 +f 1045//1134 1052//1137 1080//1138 +f 1044//1135 1045//1134 1080//1138 +f 1044//1135 1080//1138 1079//1139 +f 1043//1136 1044//1135 1079//1139 +f 1043//1136 1079//1139 1078//1140 +f 1042//926 1043//1136 1078//1140 +f 1042//926 1078//1140 1077//928 +f 1052//1137 1005//1105 1068//1141 +f 1080//1138 1052//1137 1068//1141 +f 1080//1138 1068//1141 1106//1142 +f 1079//1139 1080//1138 1106//1142 +f 1079//1139 1106//1142 1112//1143 +f 1078//1140 1079//1139 1112//1143 +f 1078//1140 1112//1143 1111//1144 +f 1077//928 1078//1140 1111//1144 +f 1077//928 1111//1144 1110//930 +f 1068//1141 1005//1105 1087//1145 +f 1106//1142 1068//1141 1087//1145 +f 1106//1142 1087//1145 1120//1146 +f 1112//1143 1106//1142 1120//1146 +f 1112//1143 1120//1146 1146//1147 +f 1111//1144 1112//1143 1146//1147 +f 1111//1144 1146//1147 1145//1148 +f 1110//930 1111//1144 1145//1148 +f 1110//930 1145//1148 1144//932 +f 1087//1145 1005//1105 1107//1149 +f 1120//1146 1087//1145 1107//1149 +f 1120//1146 1107//1149 1140//1150 +f 1146//1147 1120//1146 1140//1150 +f 1146//1147 1140//1150 1174//1151 +f 1145//1148 1146//1147 1174//1151 +f 1145//1148 1174//1151 1180//1152 +f 1144//932 1145//1148 1180//1152 +f 1144//932 1180//1152 1179//934 +f 1107//1149 1005//1105 1121//1153 +f 1140//1150 1107//1149 1121//1153 +f 1140//1150 1121//1153 1154//1154 +f 1174//1151 1140//1150 1154//1154 +f 1174//1151 1154//1154 1188//1155 +f 1180//1152 1174//1151 1188//1155 +f 1180//1152 1188//1155 1211//1156 +f 1179//934 1180//1152 1211//1156 +f 1179//934 1211//1156 1210//936 +f 1121//1153 1005//1105 1141//1157 +f 1154//1154 1121//1153 1141//1157 +f 1154//1154 1141//1157 1175//1158 +f 1188//1155 1154//1154 1175//1158 +f 1188//1155 1175//1158 1206//1159 +f 1211//1156 1188//1155 1206//1159 +f 1211//1156 1206//1159 1226//1160 +f 1210//936 1211//1156 1226//1160 +f 1210//936 1226//1160 1212//938 +f 1141//1157 1005//1105 1155//1161 +f 1175//1158 1141//1157 1155//1161 +f 1175//1158 1155//1161 1187//1162 +f 1206//1159 1175//1158 1187//1162 +f 1206//1159 1187//1162 1205//1163 +f 1226//1160 1206//1159 1205//1163 +f 1226//1160 1205//1163 1213//1164 +f 1212//938 1226//1160 1213//1164 +f 1212//938 1213//1164 1181//940 +f 1155//1161 1005//1105 1153//1165 +f 1187//1162 1155//1161 1153//1165 +f 1187//1162 1153//1165 1173//1166 +f 1205//1163 1187//1162 1173//1166 +f 1205//1163 1173//1166 1186//1167 +f 1213//1164 1205//1163 1186//1167 +f 1213//1164 1186//1167 1182//1168 +f 1181//940 1213//1164 1182//1168 +f 1181//940 1182//1168 1147//942 +f 1153//1165 1005//1105 1139//1169 +f 1173//1166 1153//1165 1139//1169 +f 1173//1166 1139//1169 1152//1170 +f 1186//1167 1173//1166 1152//1170 +f 1186//1167 1152//1170 1172//1171 +f 1182//1168 1186//1167 1172//1171 +f 1182//1168 1172//1171 1148//1172 +f 1147//942 1182//1168 1148//1172 +f 1147//942 1148//1172 1113//944 +f 1139//1169 1005//1105 1119//1173 +f 1152//1170 1139//1169 1119//1173 +f 1152//1170 1119//1173 1138//1174 +f 1172//1171 1152//1170 1138//1174 +f 1172//1171 1138//1174 1149//1175 +f 1148//1172 1172//1171 1149//1175 +f 1148//1172 1149//1175 1114//1176 +f 1113//944 1148//1172 1114//1176 +f 1113//944 1114//1176 1081//946 +f 1119//1173 1005//1105 1105//1177 +f 1138//1174 1119//1173 1105//1177 +f 1138//1174 1105//1177 1118//1178 +f 1149//1175 1138//1174 1118//1178 +f 1149//1175 1118//1178 1115//1179 +f 1114//1176 1149//1175 1115//1179 +f 1114//1176 1115//1179 1082//1180 +f 1081//946 1114//1176 1082//1180 +f 1081//946 1082//1180 1046//948 +f 1105//1177 1005//1105 1086//1181 +f 1118//1178 1105//1177 1086//1181 +f 1118//1178 1086//1181 1104//1182 +f 1115//1179 1118//1178 1104//1182 +f 1115//1179 1104//1182 1083//1183 +f 1082//1180 1115//1179 1083//1183 +f 1082//1180 1083//1183 1047//1184 +f 1046//948 1082//1180 1047//1184 +f 1046//948 1047//1184 1016//950 +f 1086//1181 1005//1105 1067//1185 +f 1104//1182 1086//1181 1067//1185 +f 1104//1182 1067//1185 1084//1186 +f 1083//1183 1104//1182 1084//1186 +f 1083//1183 1084//1186 1048//1187 +f 1047//1184 1083//1183 1048//1187 +f 1047//1184 1048//1187 1017//1188 +f 1016//950 1047//1184 1017//1188 +f 1016//950 1017//1188 988//952 +f 1067//1185 1005//1105 1051//1189 +f 1084//1186 1067//1185 1051//1189 +f 1084//1186 1051//1189 1049//1190 +f 1048//1187 1084//1186 1049//1190 +f 1048//1187 1049//1190 1018//1191 +f 1017//1188 1048//1187 1018//1191 +f 1017//1188 1018//1191 989//1192 +f 988//952 1017//1188 989//1192 +f 988//952 989//1192 962//954 +f 1051//1189 1005//1105 1034//1193 +f 1049//1190 1051//1189 1034//1193 +f 1049//1190 1034//1193 1019//1194 +f 1018//1191 1049//1190 1019//1194 +f 1018//1191 1019//1194 990//1195 +f 989//1192 1018//1191 990//1195 +f 989//1192 990//1195 963//1196 +f 962//954 989//1192 963//1196 +f 962//954 963//1196 942//956 +f 1034//1193 1005//1105 1020//1197 +f 1019//1194 1034//1193 1020//1197 +f 1019//1194 1020//1197 991//1198 +f 990//1195 1019//1194 991//1198 +f 990//1195 991//1198 964//1199 +f 963//1196 990//1195 964//1199 +f 963//1196 964//1199 943//1200 +f 942//956 963//1196 943//1200 +f 942//956 943//1200 928//958 +f 1020//1197 1005//1105 993//1104 +f 991//1198 1020//1197 993//1104 +f 991//1198 993//1104 966//1107 +f 964//1199 991//1198 966//1107 +f 964//1199 966//1107 945//1109 +f 943//1200 964//1199 945//1109 +f 943//1200 945//1109 930//1111 +f 928//958 943//1200 930//1111 +f 928//958 930//1111 921//913 +f 1151//1043 1137//1049 1150//1201 +f 1142//995 1143//1202 1122//989 +f 1053//971 1089//977 1069//1203 +f 1122//989 1123//1204 1109//983 +f 1096//1061 1103//1205 1117//1055 +f 1171//1037 1170//1206 1184//1031 +f 1191//1013 1209//1019 1190//1207 +f 1036//970 1053//971 1070//1208 +f 1036//970 1070//1208 1037//1103 +f 1203//1025 1202//1209 1209//1019 +f 1066//1067 1085//1210 1096//1061 +f 1050//1073 1076//1211 1066//1067 +f 1184//1031 1183//1212 1203//1025 +f 1041//1079 1040//1085 1075//1213 +f 1171//1037 1151//1043 1170//1206 +f 1157//1001 1158//1214 1142//995 +f 1137//1049 1117//1055 1136//1215 +f 1038//1097 1072//1216 1039//1091 +f 1178//1007 1191//1013 1177//1217 +f 1089//977 1109//983 1088//1218 +f 1037//1103 1071//1219 1038//1097 +f 1050//1073 1041//1079 1076//1211 +f 1157//1001 1178//1007 1158//1214 +f 1040//1085 1039//1091 1074//1220 +f 1170//1206 1150//1201 452//1221 +f 1264//1222 1071//1219 1263//1223 +f 1261//1224 1262//1225 1076//1211 +f 1085//1210 1076//1211 1262//1225 +f 1190//1207 1208//1226 405//1227 +f 509//176 526//519 1260//1228 +f 1260//1228 526//519 556//523 +f 167//201 556//523 595//202 +f 595//202 621//526 1255//200 +f 172//192 163//182 1254//199 +f 8//49 18//42 3//1229 +f 3//1229 18//42 1288//1230 +f 15//75 7//66 1240//82 +f 1250//50 8//49 3//1229 +f 1//32 1283//40 566//33 +f 593//3 566//33 9//41 +f 19//1231 20//34 33//25 +f 1243//2 636//89 593//3 +f 64//18 40//6 36//17 +f 1244//24 64//18 36//17 +f 641//579 614//582 1237//1232 +f 1250//50 1239//1233 4//48 +f 7//66 4//48 1239//1233 +f 5//74 14//73 11//81 +f 1240//82 7//66 1239//1233 +f 1//32 553//31 565//56 +f 593//3 9//41 1289//83 +f 18//42 20//34 1288//1230 +f 40//6 27//5 1252//16 +f 1249//58 6//65 565//56 +f 14//73 15//75 11//81 +f 592//57 1234//130 1233//58 +f 1237//1232 614//582 588//586 +f 1237//1232 588//586 605//592 +f 539//175 159//177 1259//1234 +f 164//257 1257//1235 168//251 +f 509//176 1256//1236 159//177 +f 1258//250 585//249 1259//1234 +f 169//1237 164//257 174//242 +f 191//236 208//230 185//1238 +f 1290//1239 207//229 640//777 +f 621//526 1292//1240 1255//200 +f 163//182 160//178 157//180 +f 1284//1241 1292//1240 648//227 +f 1252//16 27//5 12//95 +f 119//124 116//129 104//161 +f 116//129 88//135 1242//136 +f 87//159 666//713 715//160 +f 87//159 1241//1242 666//713 +f 1253//1243 47//150 631//152 +f 631//152 666//713 1253//1243 +f 86//142 74//144 60//143 +f 640//777 1291//1244 1290//1239 +f 1291//1244 640//777 613//248 +f 208//230 219//220 200//1245 +f 665//778 640//777 207//229 +f 1285//226 200//1245 219//220 +f 648//227 207//229 1284//1241 +f 691//228 665//778 207//229 +f 605//592 1236//1246 1245//1246 +f 1235//151 605//592 631//152 +f 1248//145 48//153 37//167 +f 667//708 1251//1247 1247//158 +f 605//592 1235//151 1236//1246 +f 641//579 1238//1248 1246//1249 +f 641//579 1237//1232 1238//1248 +f 404//412 391//405 1267//904 +f 1265//911 453//433 436//426 +f 328//351 327//350 331//910 +f 443//445 462//439 469//1250 +f 342//370 1275//1251 344//1252 +f 342//370 334//363 1275//1251 +f 372//480 385//473 384//906 +f 351//377 1271//1253 361//384 +f 351//377 350//1254 1271//1253 +f 337//1255 335//508 345//501 +f 384//906 385//473 396//466 +f 361//384 368//1256 369//391 +f 361//384 1271//1253 368//1256 +f 352//494 1276//1257 346//908 +f 397//1258 396//466 411//459 +f 342//370 350//1254 351//377 +f 342//370 344//1252 350//1254 +f 380//398 369//391 368//1256 +f 334//363 328//351 332//1259 +f 404//412 418//1260 419//419 +f 404//412 1268//905 418//1260 +f 426//452 1286//1261 1282//1262 +f 1282//1262 411//459 426//452 +f 352//494 362//487 1277//1263 +f 1277//1263 1276//1257 352//494 +f 391//405 380//398 381//1264 +f 426//452 443//445 444//1265 +f 444//1265 1286//1261 426//452 +f 362//487 372//480 373//907 +f 373//907 1277//1263 362//487 +f 1202//1209 1183//1212 1270//1266 +f 1116//1267 428//1268 1136//1215 +f 428//1268 1287//1269 1136//1215 +f 1073//1270 353//1271 1074//1220 +f 353//1271 363//1272 1074//1220 +f 353//1271 1073//1270 1279//1273 +f 1070//1208 1069//1203 1263//1223 +f 1274//1274 1069//1203 1088//1218 +f 1177//1217 1273//1275 1272//1276 +f 1272//1276 1158//1214 1177//1217 +f 428//1268 1116//1267 427//1277 +f 1088//1218 1108//1278 343//1279 +f 1103//1205 1085//1210 1278//1280 +f 1108//1278 1123//1204 1280//1281 +f 1123//1204 1281//1282 1280//1281 +f 1143//1202 1158//1214 360//1283 +f 1158//1214 1272//1276 360//1283 +f 1075//1213 1261//1224 1076//1211 +f 1085//1210 1262//1225 1278//1280 +f 1123//1204 1143//1202 1281//1282 +f 1143//1202 360//1283 1281//1282 +f 1074//1220 363//1272 1075//1213 +f 363//1272 1261//1224 1075//1213 +f 1270//1266 1183//1212 452//1221 +f 1266//1284 1150//1201 1136//1215 +f 1273//1275 1177//1217 1190//1207 +f 1208//1226 1202//1209 406//1285 +f 1202//1209 1269//1286 406//1285 +f 1072//1216 1071//1219 1264//1222 +f 1241//1242 1253//1243 666//713 +f 71//137 86//142 60//143 +f 88//135 86//142 71//137 +f 1245//1246 1237//1232 605//592 +f 119//124 104//161 90//119 +f 667//708 1246//1249 1251//1247 +f 621//526 648//227 1292//1240 +f 208//230 200//1245 185//1238 +f 174//242 191//236 169//1237 +f 1258//250 1291//1244 613//248 +f 1244//24 19//1231 33//25 +f 1288//1230 20//34 19//1231 +f 199//208 182//198 178//1287 +f 206//1288 218//214 190//1289 +f 1260//1228 556//523 167//201 +f 157//180 1254//199 163//182 +f 178//1287 182//198 1254//199 +f 218//214 206//1288 1285//226 +f 161//258 1257//1235 158//179 +f 324//345 312//274 323//336 +f 303//317 302//323 316//338 +f 305//305 304//311 318//340 +f 304//311 303//317 317//339 +f 322//347 309//281 321//341 +f 320//346 307//293 319//342 +f 301//329 311//335 314//344 +f 302//323 301//329 315//337 +f 311//335 312//274 313//343 +f 319//342 306//299 318//340 +f 321//341 308//287 320//346 +f 323//336 310//275 322//347 +f 418//1260 435//909 419//419 +f 337//1255 331//910 335//508 +f 469//1250 462//439 1265//911 +f 1137//1049 1136//1215 1150//1201 +f 1143//1202 1123//1204 1122//989 +f 1089//977 1088//1218 1069//1203 +f 1123//1204 1108//1278 1109//983 +f 1103//1205 1116//1267 1117//1055 +f 1170//1206 1183//1212 1184//1031 +f 1209//1019 1208//1226 1190//1207 +f 1053//971 1069//1203 1070//1208 +f 1070//1208 1071//1219 1037//1103 +f 1202//1209 1208//1226 1209//1019 +f 1085//1210 1103//1205 1096//1061 +f 1076//1211 1085//1210 1066//1067 +f 1183//1212 1202//1209 1203//1025 +f 1040//1085 1074//1220 1075//1213 +f 1151//1043 1150//1201 1170//1206 +f 1158//1214 1143//1202 1142//995 +f 1117//1055 1116//1267 1136//1215 +f 1072//1216 1073//1270 1039//1091 +f 1191//1013 1190//1207 1177//1217 +f 1109//983 1108//1278 1088//1218 +f 1071//1219 1072//1216 1038//1097 +f 1041//1079 1075//1213 1076//1211 +f 1178//1007 1177//1217 1158//1214 +f 1039//1091 1073//1270 1074//1220 +f 1150//1201 1266//1284 452//1221 +f 1071//1219 1070//1208 1263//1223 +f 1208//1226 406//1285 405//1227 +f 1256//1236 509//176 1260//1228 +f 1257//1235 161//258 168//251 +f 585//249 539//175 1259//1234 +f 715//160 667//708 1247//158 +f 667//708 641//579 1246//1249 +f 435//909 1265//911 436//426 +f 332//1259 328//351 331//910 +f 444//1265 443//445 469//1250 +f 346//908 337//1255 345//501 +f 397//1258 384//906 396//466 +f 1282//1262 397//1258 411//459 +f 381//1264 380//398 368//1256 +f 1275//1251 334//363 332//1259 +f 1267//904 391//405 381//1264 +f 1269//1286 1202//1209 1270//1266 +f 1073//1270 1072//1216 1279//1273 +f 1069//1203 1274//1274 1263//1223 +f 343//1279 1274//1274 1088//1218 +f 1116//1267 1103//1205 427//1277 +f 1108//1278 1280//1281 343//1279 +f 427//1277 1103//1205 1278//1280 +f 1183//1212 1170//1206 452//1221 +f 1287//1269 1266//1284 1136//1215 +f 405//1227 1273//1275 1190//1207 +f 1279//1273 1072//1216 1264//1222 +f 191//236 185//1238 169//1237 +f 190//1289 199//208 178//1287 +f 218//214 199//208 190//1289 diff --git a/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb b/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb new file mode 100644 index 00000000..c93a07c9 --- /dev/null +++ b/docs/tutorials/deform_source_mesh_to_target_mesh.ipynb @@ -0,0 +1,2149 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deform a source mesh to form a target mesh using 3D loss functions" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "collapsed": true, + "id": "HfwwW9HqtuvQ" + }, + "source": [ + "In this tutorial, we learn to deform an initial generic shape (e.g. sphere) to fit a target shape.\n", + "\n", + "We will cover: \n", + "\n", + "- How to **load a mesh** from an `.obj` file\n", + "- How to use the PyTorch3d **Meshes** datastructure\n", + "- How to use 4 different PyTorch3d **mesh loss functions**\n", + "- How to set up an **optimization loop**\n", + "\n", + "\n", + "Starting from a sphere mesh, we learn the offset to each vertex in the mesh such that\n", + "the predicted mesh is closer to the target mesh at each optimization step. To achieve this we minimize:\n", + "\n", + "+ `chamfer_distance`, the distance between the predicted (deformed) and target mesh, defined as the chamfer distance between the set of pointclouds resulting from **differentiably sampling points** from their surfaces. \n", + "\n", + "However, solely minimizing the chamfer distance between the predicted and the target mesh will lead to a non-smooth shape (verify this by setting `w_chamfer=1.0` and all other weights to `0.0`). \n", + "\n", + "We enforce smoothness by adding **shape regularizers** to the objective. Namely, we add:\n", + "\n", + "+ `mesh_edge_length`, which minimizes the length of the edges in the predicted mesh.\n", + "+ `mesh_normal_consistency`, which enforces consistency across the normals of neighboring faces.\n", + "+ `mesh_laplacian_smoothing`, which is the laplacian regularizer." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 0. Import modules" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": {}, + "colab_type": "code", + "collapsed": true, + "id": "ylbZGXYBtuvB" + }, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "from pytorch3d.io import load_obj, save_obj\n", + "from pytorch3d.structures import Meshes\n", + "from pytorch3d.utils import ico_sphere\n", + "from pytorch3d.ops import sample_points_from_meshes\n", + "from pytorch3d.loss import (\n", + " chamfer_distance, \n", + " mesh_edge_loss, \n", + " mesh_laplacian_smoothing, \n", + " mesh_normal_consistency,\n", + ")\n", + "import numpy as np\n", + "from tqdm import tqdm_notebook\n", + "%matplotlib notebook \n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "mpl.rcParams['savefig.dpi'] = 80\n", + "mpl.rcParams['figure.dpi'] = 80\n", + "\n", + "# Set the device\n", + "device = torch.device(\"cuda:0\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Load an obj file and create a Meshes object" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": {}, + "colab_type": "code", + "collapsed": true, + "id": "dz0imH-ltuvS" + }, + "outputs": [], + "source": [ + "# The path to the target 3D model we wish to fit\n", + "# e.g. download https://free3d.com/3d-model/-dolphin-v1--12175.html and save in ./data/dolphin\n", + "trg_obj = os.path.join('./data/doplhin', '10014_dolphin_v2_max2011_it2.obj')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "rbyRhI8ituvW" + }, + "outputs": [], + "source": [ + "# We read the target 3D model using load_obj\n", + "verts, faces, aux = load_obj(trg_obj)\n", + "\n", + "# verts is a FloatTensor of shape (V, 3) where V is the number of vertices in the mesh\n", + "# faces is an object which contains the following LongTensors: verts_idx, normals_idx and textures_idx\n", + "# For this tutorial, normals and textures are ignored.\n", + "faces_idx = faces.verts_idx.to(device)\n", + "verts = verts.to(device)\n", + "\n", + "# We scale normalize and center the target mesh to fit in a sphere of radius 1 centered at (0,0,0). \n", + "# (scale, center) will be used to bring the predicted mesh to its original center and scale\n", + "# Note that normalizing the target mesh, speeds up the optimization but is not necessary!\n", + "center = verts.mean(0)\n", + "verts = verts - center\n", + "scale = max(verts.abs().max(0)[0])\n", + "verts = verts / scale\n", + "\n", + "# We construct a Meshes structure for the target mesh\n", + "trg_mesh = Meshes(verts=[verts], faces=[faces_idx])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# We initialize the source shape to be a sphere of radius 1\n", + "src_mesh = ico_sphere(4, device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the source and target meshes" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def plot_pointcloud(mesh, title=\"\"):\n", + " verts = mesh.verts_packed()\n", + " faces = mesh.faces_packed()\n", + " x, y, z = verts.clone().detach().cpu().unbind(1) \n", + " fig = plt.figure(figsize=(5, 5))\n", + " ax = Axes3D(fig)\n", + " ax.scatter3D(x, z, -y)\n", + " ax.set_xlabel('x')\n", + " ax.set_ylabel('z')\n", + " ax.set_zlabel('y')\n", + " ax.set_title(title)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox β‰₯ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "bento_obj_id": "139741805306320" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "bento_obj_id": "139740023070416" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib notebook\n", + "plot_pointcloud(trg_mesh, \"Target mesh\")\n", + "plot_pointcloud(src_mesh, \"Source mesh\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Optimization loop " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": {}, + "colab_type": "code", + "collapsed": true, + "id": "Sc-3M17Ltuvh" + }, + "outputs": [], + "source": [ + "# We will learn to deform the source mesh by offsetting its vertices\n", + "# The shape of the derform parameters is equal to the total number of vertices in src_mesh\n", + "deform_verts = torch.full(src_mesh.verts_packed().shape, 0.0, device=device, requires_grad=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": {}, + "colab_type": "code", + "collapsed": true, + "id": "0BtSUfMYtuvl" + }, + "outputs": [], + "source": [ + "# The optimizer\n", + "optimizer = torch.optim.SGD([deform_verts], lr=1.0, momentum=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "9DAjqI9Atuvp", + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c223843a57fe44f68fff46d993f77b3c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "HBox(children=(IntProgress(value=0, max=2000), HTML(value='')))" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBo\ndHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXl0XPl13/l5W+1AAYWVJMCtyebS\nXJoL0O6Wt0wsb7JnZEeTWFEkK0fO+Pg4zjkzmbFjSydSYilxHDuZeOTY8ngkjSdeFaktKVJsS3Ja\ni6UOm+wF4E6CBLEDBAq1V731N3+8etWFAgqoAgokwH4fHR2JqFfvvdq+7777u/d7JSEEPj4+Pj5P\nDvLjPgEfHx8fn9biC7uPj4/PE4Yv7D4+Pj5PGL6w+/j4+Dxh+MLu4+Pj84ThC7uPj4/PE4a6weN+\nLaSPj4/PzkSq94Afsfv4+Pg8YfjC7uPj4/OE4Qu7j4+PzxOGL+w+Pj4+Txi+sPv4+Pg8YfjC7uPj\n4/OE4Qu7j4+PzxOGL+w+Pj4+Txi+sPv4+Pg8YfjC7uPj4/OE4Qu7j4+PzxOGL+w+u4JQKMSLL774\nuE/Dx2dX4Au7z66gVCrxEz/xEwCMj4/zR3/0R9t6vEwmw/ve9z727dtHd3c373znO5mdnd3WY/r4\ntApf2H12HZ/97Ge3Xdh/9md/lqmpKV555RXu3LlDKBTiXe9617Ye08enVUhCrOvM69v2+uwIJEni\nM5/5DDdv3uTDH/4wAJqmMTY2xt69e/n1X/91PvnJTzI5Ocng4CAf+tCHeO973wvA+9//fizLIpPJ\n8NJLL5HJZPjoRz/Kiy++yJUrV1Yda3Fxkf7+fr7xjW/wwgsvADA5Ocn+/ft57bXXePbZZx/xq/fx\nWZO6tr0IIdb7r4/PjgAQn/nMZ4QQQvz0T/+0eMc73lF57OMf/7gYGBgQIyMjwrIs8aUvfUkEAgHx\nyiuvVLZPJBLiD//wD4Vt2xse66/+6q8EIIrF4oq/9/T0iN/7vd9r+Wvz8dkkdbXbT8X47Ho+8YlP\n8Au/8AucPn0aRVH40R/9UX7sx36MT3/605VtEokEf//v/31keeOv/MOHDwmFQoRCoRV/TyQSLC4u\nbstr8PFpJb6w++x6bt++zYc+9KGKGIdCIb74xS8yMTFR2ebQoUNbPo4QAkmqf/fr47NT8IXdZ9cT\nDof5xCc+QalUqvzXMAy+8IUvVLYJBAIN76+vr49SqUQ+n1/x98XFRfr6+lp67j4+24Ev7D67nqNH\nj/L666+v+NvExAS2bW9qf+fOnUNVVS5fvlz52927d0kmkzz//PNbPl8fn+3GF3afXUc4HGZycpJU\nKoVhGPz8z/88n/zkJ/nKV76CZVl85zvf4cKFC3zxi1/c1P4TiQTvfve7+dCHPsTMzAxLS0v84i/+\nIj/4gz/I8ePHW/56fHxajS/sPruO97znPczOzjI4OMjo6Cjve9/7+JVf+RU+8IEP0NbWxvvf/35+\n9Vd/lXe+85119/HRj36UCxcu1H38P/7H/8jRo0c5efIkhw4dQlXVba+d9/FpFX4du88jQQiBZVmU\nSiVkWUZVVTRNa6hKxcfHZ03qruT7wu6z7QghME0Tx3EwTZPq75wkSb7Q+/hsDl/YfR4Ptm1jmiaU\nRdwwjFXbeE0VkiRVhF7TNFRV9YXex6c+dYVdfbTn4fNWwUu92La9Ye23J+getm0zPj6Opmns2bPH\nF3ofnybxhd2n5VSnXDbT0LOW0FuWBYAsy8iyTCAQQFEUX+h9fNbAF3aflmJZFqOjo+zZs4fOzs6W\n7HMtoS8UClAWekVRKhG93xnq4+MLu0+LqE69rIckSWywrrPhdrVCb1lWJY/vRfG+0Pu8lfGF3WfL\neKmS6gXQeqLciKg3S7XQexeYaqFPp9P09vb6Qu/zlsEXdp9NUxule6LZaFS+HlvZR63Q37p1i1gs\nVqm48SN6nycdX9h9NkV1bXqtOLZC2FuNt8haHdH7Qu/zpOILu0/T1Namr0UrInbHcba0j/X2vVbq\nxhd6nycFX9h9GqZe6qWWen9fWFhgbGyM9vZ2Ojs76ejoQFUf/1fQF3qfJ43H/6vy2RU0U5tem4px\nHIdbt25RLBZ55plnyOfzpFIpxsfHAejo6KCzs5N4PF4R+seZzqkn9MVikXw+z549e3yh99nR+MLu\nsyG2bfPqq69y4sQJNE3bcPtqUc7n84yOjtLf38/x48exLItQKERXVxeUSxVTqRTJZJL79+8jSRId\nHR0IIRo61qPAE3rDMEin0/T09PgRvc+Oxhd2n7pUp15KpVLDz/OEfWZmhvHxcZ555hni8fia26qq\nSnd3N93d3QCYpkkqlWJqaopCocDS0lIlbROPx3dEp6mfuvHZ6fjC7rMmzdSm1yKEYGJigmAwyPDw\ncFN5dE3T6OnpwbZtDMOgv7+fVCrFwsICd+7cQdM0Ojs76ezspK2tbVcIvdcZqyiKL/Q+jwRf2H1W\nIIRY4c3SbG16NptlcnKSnp4ennnmmS0LWSAQoLe3l97eXgB0XWd5eZmZmRmy2SyBQGCF0G+ncDZ6\nYasVetM01+yM9YXeZ7vwhd2nwlZq04UQTE5OMj09zZ49e2hvb9+SaNU7XjAYpL+/n/7+fgBKpRLL\ny8tMTU2RzWYJh8OV1I3XlNRKNmtq5uE4DrZtMzMzg23b7Nu3zxd6n5bjC7sPNFCbLstyXWE3TZNr\n166hqirDw8NMTk4+ss7TUCjEnj172LNnD0IIisUiy8vLTExMkMvliEQiGIZBPp8nEonsCOGUJAnL\nsnAcpyL01RG9oiioquoLvc+m8YX9LU4ztelrCW0qleLatWscPnyYPXv2rLvtdiNJEpFIhEgkwr59\n+xBCUCgUeP3117l37x6FQoFoNFpJ3YTD4R0hnGtF9N5AEl/ofTaDL+xvYRzHqUSOjdSmV3eCCiEY\nHx9nfn6ec+fOEYlEVmzbCmFvRdQfjUYJBAKcPn0aIQT5fJ7l5WXu3r1LsVikra2tUkcfDoe3fM6N\nsl4/wFpCr+s6kiT5Qu/TEL6wv0UpFotMT08zMDDQkDhUi7VhGIyOjhKNRhkeHl5VmdIqE7BWI0kS\nsViMWCzG4OAgQghyuRzLy8vcvn0bXddpa2urRPTBYHDF83dCw9RaQl9deeMLvQ++sL/18FIvuq6z\nsLDA4OBgQ8/zxHppaYmbN29y9OjRSqXKWttul89LK5Ekiba2Ntra2ti/fz+O45DNZlleXub69euY\nplmxP/CGhrRKOIUQmy7VrBX62dlZCoUCBw8e9CN6H/CF/a1FtS2AoihNi+/ExASFQoELFy4QCoXq\nbve4bXs3iyzLxONx4vE4Bw8exHEcMpkMy8vLTE9Po+s6qqpWovqtdMZudmzgeufuXVDXSt1omlbZ\nxufJxxf2twBr1aY3I5ylUonFxUV6enoYGhpq2itmtyLLMh0dHXR0dHDo0CEePnzI/Pw8uVyOyclJ\nHMep5Ocfp6FZ7UVio9SNqqqVweC+0D+Z+ML+hFOvNr1R8fU6PuPxOPv27XtkQrATLw6SJBEOhzl8\n+DCUfW7S6TTLy8s8ePAAIcSahmZr0cqIfaN91Qq9ruuUSqUVQu/l532hfzLwhf0JZr3adFmW103F\neI6MhUKBoaEhxsbGmuq83GmivB2oqkpXV9eGhmae0CuKsi3n0exFYj2h92rs4/G4L/S7GF/Yn0Aa\nqU1fT3wLhQIjIyP09fVx/PjxplM3uzXH3gjrCV09Q7PFxUXGxsZQFKWStmmkxLRRthr9Vwu4YRhc\nv36dM2fO+BH9LsYX9ieM9WwBqqn32OzsLPfu3ePUqVMrHBkftbA/CXiGZj09PVAWzeXlZRYWFnj4\n8CGaplEsFrdsaNbKtI7jOBWHSmoieu/vvtDvfHxhf4LI5/MVR8Fmf3C2bXPjxg0sy2J4eHhVxcd6\nlgK1PMkR+1YIBAL09fXR19dHMBis+MN4hmbBYLCSumnW0Gw7o/9qAbdte8VibLXQ7wSnTR8XX9if\nALzUy9WrVzl69CjRaLSp52ezWUZHRxkcHKzbsNSKiL1YLHLr1i1CoVAl77ybxKCVFxohBIFAgJ6e\nnoqhWbFYrHjRVxuadXZ2Eo1G64r3o16IrcYX+p2JL+y7nOra9I0WRGvxHBknJyc5ffo0bW1tdbdt\npuloLWH3qmueeuopLMta4a+eSCRWRak7NWLfztRDOBwmHA6vMjR78OBBxdDME/pqQ7NWp2K2cqdQ\nK/T5fJ62tjbC4bAv9I8QX9h3Md4C6WaGYViWRbFYJJ1O89xzz21YsdFsxO7hOA63b98mn88zNDRU\nufh4Xav1bHdVVd2Rwt4qGomM1zI0W15eXmVoZhgGgUCgZee1FQGufU337t3j8OHD2LbtR/SPEF/Y\ndyG1C6Tej6nRiD2dTnPt2jU0TePUqVMNHbPZCNqLOEdGRujt7eXYsWOVUrpq6tnuzs3NkcvlsCxr\nhRvjk0KzFy3P0CwajTIwMLDC0GxxcZH5+XmSyWSl6maz71WrO2K9LufqHL1naeEJvTdG0Bf61uEL\n+y6jdmRdNRuJrxCCBw8eMDc3x9mzZ3njjTcaPm6zEXs+n+fVV1/l5MmTFZ+VRp7nRamxWIzZ2Vn2\n7du3pklXIpFoWZT6uNhqiaJnaGZZFtFolFAoRCqVasjQrB6tFnavyqb6vKv3X90RXTsv1hf6zeML\n+y6hkdr09SJ2z5ExEoms6ci4EY0Ku+M4TE5Oks1meeGFFzYtvp4ArGXSlUwmuXr1KrZtE4/HK1Hq\nVrxbGqHVi6etNhRrb2+nvb29IUOzep9LrRC34twa7YqljtAHAoGKi6VPY/jCvgtopjZ9LWFPJpPc\nuHFjXUfGjWhE2L3USywWo7u7e8sRde3xqk26Dh06hG3blZb+iYkJhBAV4dquTs+dWLe9lnhuZGhW\n76K43RH7Rqwl9IVCofJYOp2mv78fVVV35GexU/CFfYez0ci6amprzYUQjI2NkUwmOX/+/JZy1BsJ\n+8OHD7l9+zYnT55ElmUmJyfX3K6VtfCKopBIJEgkElDV0l/b6Wnbdssj0a3yKEsUWcPQzLsoplIp\nJiYmKoZmrV603ur7Xi30lmUxNjZGe3s71AwG94V+Jb6w71CEECwsLOA4TkW4NqI6FVMqlRgdHaWj\no4OLFy/W/XE1KjD17gYcx+HOnTtks1mGhoYIBAJkMpnHUtFS29LvdXqapsnly5cJBoOViH47Bl0/\nLjZzkVjrophOp5mZmSGTyZBOp1c4V27l7qeVpZjVKRkvPVk9L9YXehdf2HcgXm16NptFCNGwsHtR\nrhc9Hz9+vGJQtd72jfwAZFleVdFSKpV444036O7u5sKFCzuuBt3r9JyYmGBoaGjNQdfeQmwj8093\nco59q/vyDM1s26atrY2BgYFVhmaeyG+nodl6rBX9V0f01ULvVdy8VYXeF/YdRnVtuizLlWikESRJ\nYnp6GoCLFy9uWAmxlW5S7+Jx4sSJhi88zRxzOy4OXgPQ3r17V9SFj42NUSgUVlSR1Bsk0kpx2EnC\nXruvRg3NOjs7aW9vfyRprkbSOr7Qu/jCvkOornrxvpzNdJIWCgUmJiZob2/n2WefbTi90oywO46D\n4zjcvXuXTCZT9+KxUyL29VirLtyrIrl58yaGYaxYXGx1aeVOjf7rLdDXMzSbm5vj9u3baJpWEfpq\nQ7PHna9fT+i9evru7u4nTuh9Yd8B1KtNb9R4a25ujrGxMfr7+xtKKVTvvxmbAC9X3dXVtSL1sta2\nu80ETJKkSrnggQMHcBynUnEzNTWF4zioqkogEMCyrC1PS9ppqZjqfTUintWGZgC6rrO8vLzC0Mxb\nuG7V+bViAbxa6PP5PAsLCxV7hicpoveF/TGyUW36RsJr23YluhweHmZhYaHp1E2j4pnNZpmZmeHs\n2bPr5u2b3e9ORZblFUOsbdvm/v37ZDIZXn/99UrO2UtFPI6cs8dOuEgEg0H6+/tXGJp5C9eXLl1q\n2NBsPVpd2WTbdt3F2N0u9L6wPyYaqU1fT9hzuRyjo6Ps27ePwcHBpr1iaFCAvdTL4uIi/f39G4p6\no/t9FPtoJYqiEIvFCAQC7N+/H9M0K97qd+/eRVXVykJsLBbbUIB2ghivhVd5slW89YypqakVC9fj\n4+Pk8/m6hmYbnVsrhb3Zxdjx8XH6+/s33QvyKPGF/THQaG36WiWGQgimp6eZmJjg1KlTlZpemkyt\nNLJ9qVRiZGSERCLB0aNHSSaTDe13p4nydqBpGr29vZUfuZeKmJ6eJpvNVqyJ60Worc6xt3JfrRJP\n77ykBgzNYrFYpbyyXjpxuyL29agW+mbuhh83vrA/QhqxBaimVngty+LatWvIsszw8PCqPG8rI/bF\nxUVu3bpVKZlcWlralLvjZtltF4fqVES1mZkXoUaj0Yo9sdco9laosFlLiNdauPYMze7evUupVCIW\ni60yNHsUEftG2z/OlFsz+ML+iHAch+npaXRdZ3BwsKHnVAt7JpPh6tWrHDx4kL179264faP7rxVP\nIQR3794llUqtqHrZTAXNk0Yzr782QvWEyzPo8oy7NE1r2KBrvfPa7qqY7dyXVGVoNjg4uKJCqdrQ\nzMt3t4pmhb2RCH+n4Av7I8BLvdi2jWEYDT/PE+oHDx5UFi7Xm47UzPg61hBgr1u1s7OTixcvrvhR\nPo4qlZ0YsW9G9GqFy3Ec3njjDXRd5/r161iWtSUzs8dRFbOd+1qrQimbzfLgwYOKTXE8Hq+kbjZb\nimrbdlPvtR+x+8AatemKojQVydq2TTKZRNM0nnvuuYaaM5rZf7V4Li0tcfPmzbrdqq2YeVoqlbh2\n7VqlosTr+Hyr4UWeAwMDRCKRNc3Mmmnn38kLsa24SHiGZolEgu7ubvr7+ys+N+sZmrX6/Hxh91mz\nNr2ZVMny8jJXr14lFApx8uTJhp7TbMQuyzK2bXPnzp1VqZdattKlStWF4+jRo6iquuI2ey072d1U\nWrZV6pmZJZNJ7t27t2GX504W9lZ+jl4vQXUpaj2Xz2qhr9dz0GxqZacZya2HL+wtRgixwlO6tuFo\nI2EXQnDv3j0WFxc5c+YMd+7cafjYzUbsjuNw8+ZNenp6VqVetrLvamEXQnD//n0WFxe5cOECmqZh\nWdaKtITnsT49PV1xGYzFYk9knt5jPQGtZ2bmdXkGAoHKQmwsFtuxYtzKtA5lIV5rf/UMzbzFa2DN\nOyA/YvdpiI1q0zcSdl3XGRkZIR6PMzQ0VLGbbZRm7giWlpaYn5/n0KFDHD58eMPtNxOxm6ZZGe7h\nOUx6FUHV51ztse79KB8+fEg6nebVV1+tpG2qW9UfB48r51/b5enNifXMzAzDYHZ2lq6uroZrwuvR\nSjF+XFUsnqGZl1KsvgOqNjQrFApNvVe+sL8FaaQ2fT3h9coLjx07VonUhBAtbziq9mjv7++nra2t\nZfuu3tayLC5dusSRI0cqgtQI3o+yra2NUqnEyZMnV7Sqe/XhiURiyyK2GXZCyqN2Tuwrr7wC5cHR\njZqZbcd51bIdqZjNXCjWMjRbXl5mfn6emzdvrvC5qWdo5v0Wd0uK0Bf2LdJMbfpawu75ma9lqtXq\nhiPvjsDzaB8bG2vp4AvK78fk5CSlUom3ve1tRCKRhs9/reNVR6vV9eG1IpZIJLZcNvgoaZVIeK3v\nAwMD7N+/HyEEuVxuhZlZIyPxPHZyKqZVEbPXXDY/P8+RI0dQFGVDQzPvotLsezMxMcG//bf/lne8\n4x388A//8IrHRkZG+OM//mNkWebcuXO8613vAuDTn/40d+7cQZIk3v/+93PkyJGmX6Mv7FvA801v\nxtO8Wni9UXLd3d1r5ribLflbb/HUW7ysviPY6oJoLZZlcf36dWRZrtRxt5K16sOr53pWlw12dnZu\n2ahrt1D9/ZPWmBNbOxKvOt9c+x49CamYRvEWTzcyNJuZmaFQKNDZ2dnUOZRKJT71qU9x6tSpNR//\n1Kc+xQc/+EESiQQf+chH+K7v+i4ymQxzc3N87GMfY2pqit/5nd/hYx/7WNOv7a3xzd8GbNvmxo0b\nxOPxhr0jqoV9fn6eu3fvcvLkyYrR1FapZ0Fw7949lpaWuHDhwopb81YKey6XY2RkhP379zMwMMC3\nv/3tLbySxqitd66ujnjw4EEll2pZVktEYada7bJB+q92JF4qlaosLEqSREdHB4lEgvb29icyFdPs\n/moNzWZnZ7l06RIjIyNcunSJ3t5eXnjhBb77u7973f1rmsYv//Iv8+d//uerHpufn6/MBgY4d+4c\no6OjZDIZhoaGABgYGCCfz1MoFJoOknxhb5Lq1MtmUiW2bXP9+nV0Xa+MkmsVtRG7ruuMjo7S3t6+\n5ni8Zm176wnb7Ows9+/f5/Tp0w3n7LdyvHrUVkd4wyGmp6e5fPnyqmqSzTYbtYLHla9VFGXFwqL3\nHj18+LDSzj89PU1vb++WF6u3IxXzqL1iAPbs2cPb3/52Dh8+zPPPP8/8/DypVGrD5ymKUnf/qVRq\nhc9TPB5nbm6ObDa7opihvb2dVCrlC/t2Upt6aVbYi8Ui6XSavr4+Tpw40fIfdnXEnkwmuXHjBk8/\n/XRlOMJa228lYvfKJb2LVCvbvVuBNxxifHycoaGhVdUk0Wj0Ld0oxRoDNF577TXC4fCqxerN2O3u\n9FQMTVyoq3Ps1dH8ZlnLymOt39hmAwBf2BugXm16M52k09PTjI+PEw6HOXDgwLacp3dHMDY2tmbq\npZZmhL32bsBbH9jOi1Srywtrq0lq/VuaWWTcKju1wkKSJHp7exkYGIAqX/VqMzPvPdpoqMtuEPZG\nabVPTCKRWBH1J5NJOjs7URRlxd+Xl5fp6Ohoev++sG/AerXpa9Vl1+ItKAI899xzXLp0advO1TRN\nCoUClmWtmXqpZbOpGG/eaSvXBx41pi0IR6IrGqWqFxm9RqlG2/qfFGq/57VzYmtdGKtLK2urklp9\n8Xqcwt7qGvbe3l6KxSILCwt0dXXx6quv8gu/8Atks1n+7M/+jLe//e3cv39/hRtoM/jCvg4b1aZv\nNGzac2Q8cOAA+/bt29Zz9VIvmqZx7Nixhp7TbDdpo/YDrWAzEft8psTUcomneqJ0RDQMy+aX/vwG\noxNF+q+9xq+/8zhdsSD/6D+9wZ3FArIEP3m2j3/6A0eQZZnPXU/zJ1fmcYTge59K8HMH4iSTScbG\nxpjICpK6zIXBNvbsac1C7E6M2NfLi69lZpbL5Ugmk5WqpPb2dhKJBB0dHU9UxL6ZY9+7d48/+IM/\n4OHDhyiKwssvv8zFixfp7e1leHiYn/mZn+E//If/AMDzzz9fcW09fPgwH/rQh5AkiQ984AObOl9f\n2Neg0dr0eqkYr5Z7enqaM2fOEIvFtnw+9c7Ba9l/+PAh58+f57XXXmt4v7IsV9JLG2GaJvl8viH7\nge1GCMGfvzHH2GKBHzzRzZl9cf7918b4w8szOI5AUyQ++ENH+ZMrM1ydzQGwMJ3l733yNZ7pj/LG\ndBbvU/v/Ls0wdCDO1HKJ33rpAbYAWYLPvTFPNKTw08/t55+9lGbsYQFJgDZS5GcnlhgabCORSDCr\nB5jL25zf38G+jt2fp2/mgiPLcqUq6eDBg9i2XbnrmZiYQNd1IpEIoVCoZXc9j+t7t5mI/fDhw3zk\nIx+p+/jJkyfXLGV8z3ves6lzrMYX9hoaGVnnsVYqxjRNrl69SiAQYHh4eMtfZi9yXetcDMNgdHSU\nWCzG0NDQpia4NxKxe3XiwWCQo0ePNnWMtY7Z6HZet9+dh3mWcgYn97SRKhj8/J9cZSqto8jw2ddm\n+dtPJ/ji1cWKWFuO4F/819tYNlTH/KmixSv301S/YlvAv//rByTzBnZ5Y6f8v599bY7v3E9zZ6FQ\n2Y9tw6duSfQPdPHPXnzATMZCAEEFfma4i59+25GG7mR2csS+2fOqNisDGB8fxzTNSiu/V3rplVbu\nJnuI3eTFji/sK2l0ZJ1HbY7aE8Cnnnpqy6vmtceo/RF4xzp69OimZzBulO4QQvDgwQPm5+ebvhto\nBXdTNr/2+1eYXC6hyhLtQQlVUXiQ0qEssqbt8IWriysEXABGnaWPtdzw5zMFhLRaZLK6w8NsadW+\nM0WL3/xvEyzmrcpjJRt+/5UlMqkMl+YtlooCG4XD3VH+9TuP09e+chF7J3rNe7TyglPd52EYBqlU\nivn5+YqZWXWH56O80G3G2dEX9l2Gl3r5m7/5G55//vmGn+elYqrTIefOnWtpx2VtNUpt6mUrZXrr\nLZ56dx6hUGhTdwPNkilZ/Ner8/z1rUWCAQXLcbg+aZDUXSkWQFYHVVqZOlpPHhWgVt9DMpRqXrJh\nS/TEVHL6atm3rDVSbUC6ZK4S/KIFf3rHxHHAckBgk5rM8FP/9yV++8f3Em2PYylhYiFtx0bsraQ2\nIAkEAivmxHrlp1NTU2Sz2U0NuG7VuTWy/W7qZN49Z7pNVNemNxtFybKMYRhcuXKFtra2hgWw2Tym\nJ75e6iUajbZEbOtF7N6i76FDh9izZ8+WjrERQgi+cWeJ/+vr40wkS5i2A5KbDhFitXBbdT4iGaiV\nYE2VsKueEFbLbfeOqNmvoGA4yNKbaRhvfw4yMvaKfUvUv6IYlvuQ97ADJEvwT748T8maoWCAIkFv\nBH734DIDPZ1PrMBv9D2vLT8tFosVD3pvwHV1aWUr2UzE7gv7LqBebXozopvJZFhcXOTs2bN1m4Bq\nWS9nXm97x3Faknqpdy7VTE1NMTk52ZJF37WwbZvxh1k+N/qQS/dTlEyb2axOUJEpetHxOtdXqc7D\nmgJ6OTz3RFmVJSTeFHEhSUQ1Cd228V62KoFAIh5WMRxBrrwTgbuIGtJkJEmQ1d+UdlHef0iFUs3a\nc+25eSL/MG8jlS8cloCZHPzjP7vBL12QkYMROjsSDPR3EW2xv87jpJmouNoHyBtw7ZmZeX0Guq4z\nPz/fkj6Dzcw73S1DNnirCnu9BdJGRddxHO7evUsymaSjo6NhUWednHk9JEliYmKCVCq15dTLWvv2\n7gY87xvHcRgaGtqW6GRpOcW//NwVXlkQ5Aw3XeGlSkrm+v0A1agylAN7nLLYy5KEjEBV3M/OcQSa\nKiObDraAgOJulzcF0YBMTndaZ2kGAAAgAElEQVRc0RWgKRKaIhPWZPK6jSxRecy0HdpCKoZlYjqi\nckFQJIlYUEEIC6NqkdZbSNVrXo4DSFV3IBYwkbX56BWFVCmLZadpC4zzPx6W+aFjXZWSwe1ulNpO\ntlKeWGtmZlkWly9fplAoNGRm1upz83PsO5y1RtZ5KIqy4ZW5WCwyOjpKV1cXzz77LFevXm3q+M00\nBXmLTYqiNJV6acZt0ms6GRkZYWBggIGBgRY3lQi+enOBr41M8PV7aYq27C5u1qRD6gXpikSlWoWy\niAdVmZLhVMJ3SYKOiMbDnOFG6OU0jiJJaIoElkBTZGIBBQcJRzigO3iv0rBckddkGU0BVZYxbQdZ\nllBkiWhAoRBwsHWrkgoKKBJvO5zgG3eTGMU3w3ZVhlN7YozO5DBqPuZVaSUHpjNG5QHdEvzJbcHx\ngxGC+TxTU1OPvFGqlYu6rTQBkyQJTdM4dOjQqnF4Dx48gKopSfF4fMP3qdlUjBDCF/adSCO16Z6w\n1/M8WVhY4M6dO5w4cYJEIlGJ+puhUWFPpVJcu3aNWCzGgQMHmorwGxV2SZLI5/O8/vrrnDp1ing8\n3tAxGuWzr07z/748wVyqQF4XWIBUzlY3Kh9hTUa3HMzyWyZL0BlRWcbGcgTYDpLkirir8xIOAiGB\nLQSKLKEjMG2HVFEQCSgEVJmQ5l7UQpqCZTlYjiAaVFjMSxi2g7trQSKs8Oy+dr52ewm7fA5SuSQy\nHFAqdwweigRn9sW5Ppd/M2Ff3kZTVlfrODUXLd1y+D+/Ncsze2KkiwqDHRH+TlekkntWVfWxVZI0\ny3ZaANczfFtcXGRsbGzV+1R7HptJxfjCvsNotDa9nug6jsOtW7coFosrHBmb8YrZ6BjV5zo+Ps78\n/Dznzp1jfHy8aU/2Rr60juPw4MED8vk8b3vb21pq4GXZDp+8WuJW+i6pggmShBfTrvdKVOnNxVGp\nXNUiOQ7e26VJoKgyRcNBQqAgkBQJJAkBhBRoC6sYlrsQ3hZSMC2ZkmEgSxKqLKFbFiEtgGW7KRoh\nLBRZ5sL+dhRJZj5TQrfcqF+SIFm0uTaXoy2oUCi5EbuquJF8LKi651j+SmkytIc1srpF7fJsNCjz\nPYc6+YubS3XfAwGYDkyldOYzOgKJKxOCr9xK8hs/cYLnho5iGAbJZHKFSZfXPNaKSpKdagGwUSqk\n1sys9n0KBoMVoY/FYn65426nmdp0L2KvJp/PMzo6Sn9/P8ePH1+Vk2+lsHszQsPhMMPDwxU3uWaO\n0UgrfqlUYmRkpOLz0QpRdxzBV28s8JnXprk9n2MuU64pkdzHGiGgStimu61cfps7YyH0rI5jCywB\nQeFQLOc4DMfNtUcCrtAWbDDyFrIkIYRDKKCSNx0CCuzrCFGyBLppc7IvyjfzBpIoR8yOw+UHaSIB\nBdOBzrBGyRY4AlRFZl88yLfGihiOK74q0NceYDpdpGS/KeGmDW1BhTsL+VWReVdY4/5ycZWoV1/M\nqjEdkMpbZ0sWH/nybT77jy4SCQQq7oLeAuPo6OiKiVKeNfHjnijVypJO27ab2leg6n2iyszMc/b0\nBmwUCoUNzczwhX3nUJ162UxpIcDMzAzj4+M888wza6YpNvOlrSfsXuqldkZoq8fjeZOUTpw4QSAQ\nYGxsrOnXUMtcpsQvfe4ad+ZzlEyLvPmmUtXT9IDs5pidqjRFRySAqluUTAdNkYgqDkFNpjOiUTJt\nHAEHOsNMpYp0hGQe5k0cCQbbZJK6RURTcITAcgSaorC3I8S1mSxFG6ZSJSIBhZAmM53W0RSZSEAi\nrLl3AKK8IGraDgs5N70TDao83RtlYrlELKhg2Q6WAMMSqLJEsWQTViUsW3JfpyToaQuS021UWXJT\nRcItu+yIBigZ9qqqnn3xIDndYqm4evG4UjIpYDql8z///mUUSaIjovHuoX38yMlewuEwoVCI06dP\nVyZKVXu3xOPxykLsRguMrW6aanXEvpV91ZqZjY+Pk8vlKmZmXmllvRGLvrDvABzH4f79+4RCocqE\nkkbwInbLsioVIsPDwy2tEKlN33jdnXNzc2s2NzUr7PUi9rUmKRUKhS3/mBezOv/kT0a4t5jDdqBg\nbrw/CRCSm9JwBVUAEkt5A9MWaLK7gJk1IbNcxCkvtGqKTLJgUCgLZDSoYVgOshpAz5XAcegMQsmW\nCQcUhBAEVRnLdu8cTNvhqe4IWd3Gth2EkCgfmmO9MW7M5YgFVXTLxrTd6D6vW6QKJgFVIqhCUHIX\nfwc7wzzMGaRL7sqBIku0BVX6YgFm0xms8oqvJLmLvYmIxr3iygaojpBCQFMwi1bdMk6q/j6xrKNI\nMLFc4vrcLd6YyvBP/9aBFWPxar1bvAVGb1qSl46Ix+OrhHInuzG2cl/eQmxXV1dF6KtHLJqmuWLE\noqZpmxL2erNLk8kkv/Vbv1XZbn5+nve85z1YlsWf/umfVgK7M2fO8JM/+ZObeo1PnLB7Ubppmk1/\nSRVFIZfLcfPmTfbv38++ffu2xWfcS/dUd3d6qZdaWhGxV3vKVNv5biaVRFkARqcz/Kf/PsFLtxfJ\nlN6s/a6Hpkg4jqiUHpo2CASq7C54xoIKWd2uLIDGQxoPMzbhoEJetxEInuqOMJPRQYKcYSOZNrGg\nRkCVKZpu6kRWVAIKaNhMPMxgmG5uvicWIKvbHOqO0tcW4MU3LGbSOiXTRlPcTtKM7jaqJSIBCoYb\nde9pD/JgqcBi3r1j0BTB/kSYvvYQr09l0GQZ3XZwbEFAUdnXEebrY0lkr5pHQEdIJVW0WMpblSYo\nRYKi5SCXF0yr3ztFhqcSQW4v6qveR1u4F0bTFrz4+hzvOJFY16SudoFxeXm5UgRQO1FqO4S9lWP2\nWhkxVzcc1Y5YdBynckG8fPky3/zmN+nr60PTNM6ePbvujAOP69ev151d6s04pZxi+shHPsLFixd5\n+eWXef7553nf+9635df3xAh77QKpqqobeqXXPj+bzTI3N8f58+e3pTmHqog9nU5z9erVDX1l1htQ\nvRa1Yu2leNZqbNqMNW5RN/nn/+Um3x5LUjBsCubGFwYZsGyBLLn/vyemsVRwWzTjIQUhySiyhKbK\n2I4goilEgwrJPPTEgmiKiVGuJ7dSJSIBlY6wRrZkMtAZxHYgFJApmg6G7RALqgz2RBlfKpLWS0gS\n5Es6igAjl2TeDFM0bNqCChFVJmvajC8ViWoK6aJJumjiCNjfG2G5aOEAbUGZvOFgO4K2oMpsqgRA\nJKiALsoLn4LetgCO41bjaLJEQHFf17mBNu4tFsp19hKScEhEA4SDSiWXTnltoSOsIq/hXePh1dgX\nTIf/9XM36Qw4nJi6xQeeH+RAV/0GJ03TVrX0J5PJSt45EolgGAbFYrEl/RI7eTD2eounsixXovXD\nhw/zvd/7vfzlX/4lN27c4POf/zzxeJxf+qVfWnf/o6OjDc0ufemll3juuecaulg0wxMh7GvVpiuK\ngmGsZfm0GtM0uXbtGoZhcPjw4W0TdcpiOj8/Ty6Xa8hXptmo2rsQeNbBMzMzdY/T7EXDcOD/+Nw1\nXptMk9Vt9DV8VDw8n5aOsIJpCXTbQZPcnHrJAlkGx3EXCfOGiSpLqIqMbrpdobplUzLhYU4noMrI\nEhQMG9NyCGsKqiKV68zd9Iwqy0QDEh1hDdN2ODfYwZl97fzhKzOkCiYZQ+LU3jZyjszUbIFsySKo\nQEnYqJJCR1jl1N42vnx1wfX/KS9aeufTFlCwbYHhCHTLRrdkCobtrgeoMtGAwtl97Xz15iK65WA5\nrnWBIikc7AqzlDcrKR4JN/feHlTpbw9wbaZcBSRBJCATUCRyhrNuesZjPmexJMFYyvXZ+eUfOsI7\nTvVt8CyXUCjE3r17K+mIVCrFzZs3V0yU8iL6zSywt3ow9uPydo/FYuzfv5/v//7vR5ZlSqXShs9J\npVINzS7967/+az74wQ9W/n3jxg0+9rGPYds2733vezl06FBTr8tjVwv7erXpjUw3oiqiPXz4cMMX\ngrXOo5EvsGmazM/PEwwG66ZeatlMKsY0TUZGRlBVlaGhobqRSTMXjZuzWX7tUoHpbMEtE6x3/LIY\n2eX/r5s2puO299sCHCHIlExsx61RVxUZWXZLDw3DJqjKPN0X5cZsDkmComGhW3CkJ4Ysu3nykulQ\nMG0Od4fpiqg8WCpSNC2imoIiSwhkJAmuz2WxHYewColYkAfLJWL9UYaf6qHkLLKYM7ERCMchoepc\nGiuiSIJ4SKVgCWYzOvs7Q8iShO64qaP2oMILhxN86doCiuwm0U1bEA0onOiP8oWRBYKajDAcKDdI\nvXd4gF988QaOI1wBlyUk4V4gRqezbjOVLCFJkNPdC1ex5rurSHBuoI3Lk9lV77nXwJU3bP7d1+7x\n3MEOumPNVcRUt/SfPXt2xUSp6kapRCLRUANQ9X5bweMaZO0du/o33kh03cjs0tu3b7N3796K2B89\nepT29nbOnz/PrVu3+O3f/m1+4zd+o/EXVcWuFnbbtutWvaxVulhNbb14JBJhamqqqfQNVcK70Zck\nnU5z7do12tvb6erqavhL2ugFysOyrMqFaqOpTY2kYh4s5fnVL99idDpDqtjI+bqLnEXTQVE8l0O3\nbFCS3NREQJHIliwGOsPkdJuwpqAp7t2DIkmVq0ZAhZ62MDndoi2kMZ4sEg0oGLZDKCATVhUGExGQ\nJL59L0mmZGEL+Lnv2c/EconZVAnLcVAkymWXbuNRb1uQE/3tvHR7EVMIVFkmZYcoOQaKbGGYNo4t\n0GSJc30BrtgwkSpiC4iFJAqGTdGwiARUJMmhZHmLrBZhTYYCBFQZUa55v/uwQCIaIKfbBCSJgCqh\nmxbP7G1ndDpDLKRiOwJHCBxZIqgplEw3yJDKOXdVltx1hTp+NAhX4FNFi9//mwl+6uI+9sRDBNXG\nxbBafDzv9I6ODg4dOoRlWaRSKZaWllY0ACUSiUfSKPU4I3bv993Ma6ydabrW7NIrV65w+vTpyr/3\n7dtX+c0eO3aMdDq96de9e1xt6rDewlE9QTQMg1dffRVd1xkeHq5cMTe6GNQ7zkYNRw8ePOD69euc\nPXu2MjKsUZqJ2GdmZkgmkxw6dKihUXwb7fvaTIZ//Mdv8NpEinRx/UlLkme+5bgt+ooEUU2hKxYk\nHlLpiQVQy8XpsaBKQJUxLQfTdrBst7xRVWSQ3OjVEQK5fKEQCGQEpuUgyRKaohALqCQLJolIAN0U\nqLJCUFMIBWS+fO0hAHvjIVR3B5XjHu5xP+vRmQyaKhMPayiyK4jPH+5AU1WEIiMpMgOdYWwBc5ki\nYQWCMiTzFi/dWSSoypWO04As0R0LYAlYyOoUDIeS5aApMoe6Isyli2SKJiXLIW/YZEsWbRrs7wyh\nqRI53aJg2FgOxAIKiYiGQEKTKVfjyAgEhiVYT1pcH3rBn1yZ5d3/z6v8+O9c4ve+2XiD23qLnaqq\n0t3dzdGjRxkaGuLkyZOEQiGmp6d55ZVXGBkZYWpqinw+vy1e8487Ym/22GfPnuXll18GqDu7dGxs\njIMHD1b+/fnPf55vfetbAExMTGxpGMmujtjXo55Ie3XcTz/99CrzrmbTHlRF1GvlIL2qFy/1oigK\ny8vLTV08Gjknx3G4efMmhmHQ39/f8MLXehH7XKbEv/qLWyQLBkXTWTP14kmAKFe9tIVUN1Ivt/Bb\njiCsSqSLDmCSLdlQfsyN0l3zr6xuUzQd+tuDDCTCpIsmBcNxjb5yJqf2RNnbEeLqbA7dsokE3B9k\nR9j1NZ/JuAukEqBKEpPLJZ471Mn5Ax04wN/cdaP5oQNxbFtw+UGKTMkiqLi15rLs5vCP9bXxxnSW\nZM7GBiRZwlaCCFkmFFSxiiaaArJtMhCBmymBbruv+weOd/Pla4s4wi1vdBy34uf03jam0yXypkNE\nk9Btt/HoUDvMZXTm0nrlwmPZDu3hAPGQSsly01OSg7uuEJBXGaVJQH+bxGx25adjCyjaDqWcySdf\nniISUPgHzw1u+H1oZrEzGAyuaJSqtdxta2vDNE10XW9Jo9TjjtibPfaxY8dWzS596aWXiEQiDA8P\nQzmKb29vrzznu7/7u/n4xz/OV77yFRzH4ed+7ueafFVvsquFfb1bo1phF0Jw9+5dUqlUpY57o+c0\nQj3h9VIvtZ7mGw3AXmv/60VAhUKBkZER9uzZw4kTJ7hz505TA6prEcLtIP3VL91iMW/g1MmnS0As\n6KZFDEuUuz1BOAIDgWWD5ThMp3V6YgEcIYioDpaQykZeEh2RIHNZk/aQWj42PNUT5eu3l4gEZIqG\njSwJBjvDtIc1vu9IJ1+7vUTecGgPwT//0SO8+MY8ed3CtBxiQfd2WVUkQqpMrmQxMp1DliEUULgy\nkeFYX5TvOZIgXTS5t1RAldy7gz3xIG9MpVnKGcRCKnndYuxhAU2W6YkGyZRMZFlCluDswW4WsyXk\ndBZFEpR0k69dnSKvS4RU1+LAtNyL1WxGR5YkAjLkLDcK1xSZvOmuFViOIBJU0coNWyXDYSpdIqhI\nmJJb1qjIENFkVEWq+MLLQDysgCQDq79PtgOyJDBt+KPLM/z4mX7i4fUXQDe72LmW5e5WGqXWotV+\n6M2UT272olI7u7Q6Ogf4zd/8zRX/7urq4sMf/nDTx1mLXZ+KqUd1iqRUKvHKK68gSRIXL16su/ix\nmYh9rYajiYmJSuqldlDFZhqO6m2/sLDAa6+9xvHjxzlwwG1U2UwJo0eqYPDzf/wGH/4vN5nPGWsu\nklZH6QXDxi4vCJq2Q7pkoqkSkYBKLCjRHlZJRANEg4qbb1bddEk8pGHZkC65jTlS2Tu9YNqk8gZ5\nw0aWXBEMKgpvTGfpjGiML+uucMsSecPhN792n1hA5QdP9NAeVtFttyP0nWd6MR3BXEanYFiokmvr\nawtBpmQhSRJvP95Ne0hDliSCikxfLMBEslhOEbmRq6bKJKIBnj/ciaq4pZg9UY1n+mNMLJcIBzRC\nAQ1bkpnMuna9pmWhOBaOI+gIKRzpDnF7IcdywXKbqWT3/dkTk1jI6diCStmohOBgV5iBjhBW2atG\nkaE95FbP5HQbpexJIwHpoo1w6qdnHOGmZuYyOv/qv97hK9cXKNSbGdjCKhavLjwYDHLu3DnOnz9P\nd3c36XSa119/nStXrnDv3j2Wl5cb/i1sRyqm2Rz7bmJXR+zroSgKlmWtcmTc6Dmbidi951iWxdWr\nV9E0re4g61Y0HAkhuHPnDplMZoUp2Wb271HQLf73z17l6nRm3Xy6KAuLXPZEF+Ua8oAqIUsyqgxF\nw8EuR5phzW0wKpoOJdM13OoMu3XqhmVRMKzKoIvuaIC2kApCVEoGFUkQLjsxLuZ0vNEZiiRxd7HA\nC4c7CQdkIgGFbMlGtwWLeYM9bSEKhkVAKddY4gpgIuJGrS+Pp0kVTEKaQkE3eXUqy8X97SwXLQzb\nLRcNKjKHuyO8dHsJu+yNMJnS+c+vzoAAWZFQEWiORDSg8q6Le/mL6wss5wyiiuCFwTAvXZ9hetlG\nlV1PGMsW/A9PdzE1O8e9ZIGgIqHbAtMW7IsHOdrbxn+7s4hpuQu9kkR5YVVy1y4U9z0PquAgVbp3\nV3xnpJVWDqYDf3ljkW+OLdHbHuTX/qcTHO9vW/XZtlo8PTZqlKo16Frr4vI4UzG7bcgGuz1i3yi6\nyOVyTE5OMjQ0tKGos8VUTCaT4dKlS/T19fHMM8+s2/ywFWHXdZ3Lly8jyzIXLlxYNYhhM8LuOIJ/\n81d3uDmXI6dbq0bMUY6qK9G1ItMe0ogGFBRFquS2I5pMQXewhaBgQVa3kIXDQGfYbe133C7LVNHi\n753fS39bGJCwHUGmaPHuC3sZPthBb1vQrQQBAprCr/zwEYqGTdGwy54xAkkCTXbvUP77eIqFrOFO\nKHIEX725RLJocmF/Jz9wvAdFdhdyv/doggsH4kynSjxIFghqCqbtRmMl02awM8K5wXY6wyoBReZt\nhztpC8qkiiaaIhOQ3eOaDpzfH6dkOuimgyrLnOyPIUuUL2I2RUvw7WmdkhRCUxXagoo7ms9xuHJv\nhsmMgyoLgqpCQJFQymu8IU1muWCiqjKy7N6ddLcFOJhwnRttB0zh9gIEVaVcF//mXU9QgYGO1cM5\n7PKQkemUzi++eIP57Oqu1lbWna931+g1Sh07dozh4WGefvppVFVlYmKCS5cucfXqVWZmZigW3yzD\narWwN7Oe4EfsOwQv7wxw/vz5TZuANfqcubk5UqkUZ8+eJRqNtvQY1dsnk0lu3LjBsWPH6nrgNJuK\nMWzBJ75xj8+/PoNRdjRctU+gK6qSLVqYjrvIVzDcSBIhKBiCkukQj0js6wgxm9YJqW7EiSwTVGUM\nxyEedj03bMvmjYlF7i0VKwuhtiP46q1F3n6ihwNdYZYKJiXHQJYl4mGNwc4IF/fHeXUqg266F49/\n9Px+kgWDuXQJw7IJqgrg2hZ4Ngcl08awYblocmMuT3tQJR5SCaoy2aq5dpoiE1Ql7i0WSJfcnP1L\nd5ZIFdvLgupglz1hNFXi7EAc3XK4PZ9HkeFwd4Rb83kW8wbtIbdJKlUwyJcsTCGIBFTiAZW8bnNy\nsJO5uYdceWgjYaPIEFJkDneFeZjTcRwHTZaJaG5Xal63WcwbBMqli67dARztCTO5XEQGVFVCldwm\nsmxp7eDEnQjlpmZ+++vj/MsfO7bi8VZbADQqnLUGXfl8nmQyuaJRqlQqrSoXfFTsxoj9iRP22dlZ\n7t27x6lTp7h27VpTX9RmI3bLslhcXKx4vTRyVW/Ww91L9dy/f5+FhYW6C7/V2ze6/4mlPB9/vcTN\n5H23U7KmRrr638mChShXfHjDpqNB1a1wKUeSIUXGdBxkWaA6ICsKthAsFQwcB/Ryd3AkoJAt6uRL\nOpZdXv/DTTXkdYtL4ynssq/MQkbnD16eYn8izJl97SzkTJbyBrGgyttP9PD6ZJpriSwP8ya2EJRM\nm3hIZaAjhO0ILk2k3eoSSWI2XeI79wXvvriXHznZw2dfn8N2BIYtOD/YxkyqyGxGJ6IpWBLYjnt3\ncWF/u3tOtiAUkHnhUCfzGZ1XJzMoEhi2w39+bZa+Ng1JuKkQtdwV+3RfDNNxmEu7c12ffaqdjkiQ\nv065r9uw3B/h0e4AXVKeb9/VKRggsFFkm+5okKf7IiznTbIl0019qW4kv5R3K40cwLLcQSaaujo1\n4+HNX3UEfONukm/cXuK7DndWLhittgDY7EJsLBardHt6d8O3b9/m3r17jI+Pb6pRaiv4EftjxJvZ\naVkWw8PDm2qBbkbYM5kMV69eJRqNsmfPnoY/+GYbjmzbJplMEggEGhqP12jEfmc+y//22avMpkRl\nOtFajS9hTSaguKV2luPmzUPlhqK8blWaYzRFIhJQyBkWRdMdjhHA9X15+7Fufufr4yCBqijIssz/\n8v3HGPv8TWZSJbBBkgR6Po3IWBTLC3yWA0FZYjFvcqQnyhdG5hlPFpEliWTe4F986TZDBzp4/nCC\njkiAa7NZhBB8+EeOspAz+eqth5XFQlGenGGV35v2kMaJvhjLBRPddtAth8W8ieO4dw9CeO8lDO3v\nQAIWklkCAZVYUOXrd5awHIdAQEUDiqbNvs4IeVOQLpoVe4ChA3HuLxWZSZXIGjbX53I8SJYwbTeV\nElJdj5mDfXFsWSJlPaQ95FCyBI4DYXS6ZJmxnIFlu8sFlinobw/wzN42UgUTgbu9l46p/YZUL3g7\nAnRboOdNfvkLNxjoDPOLb3+KC/s7Wp6KacVFwmuU8oQ+FAo98kYpX9gfMd6H6A0b2OrMzkaiXSEE\nU1NTTE1NcebMGRYXF1tW5VKLd/EIhUKcOHGioec0Uk5p2Q4f/uJNZpZL5Ousk5aDaCTcLkpVkcjr\nJprsdlQGFYk8brQqlf/THtZ4Zm87f3V9AUsIBIIj3SGSc9PEwyrpkltFc6QnQncsyDvP9PPl6w8p\nGjbdsQDfdaiT7z/Wzh9cvc5y0UaVBAiHUqnE9x3p5BPfmsB2BBbuwubEcpGhA3FAIlU0SRctHCH4\n2u0lnu6NcmZvOzfn80wnC5RMB0WW6Im5+edrs1kuT6ZRZZmiaTOb1vm75/dwf6nIfFZ3vWtkmfOD\n7VybzfKd+ykkYSMki8XiIvGw4kb7lpsWkiSJ9pDK3z2/h6/efIgiSRzpjSHLEq88SKFbDiFNZjFn\nkJJMLBsU1S0ZLRgOSzmDxbyBbQtikQCq4t69lCSNmYJMpmQTUcsXX0lCwi0zNcqDPgKK+zl1RwMs\nF8zygG8IqTJB1bUqqJ3BWjAc7i0W+eXP3+Lf/52T9Go739vFa5TyUpG6rrO8vMz09DTZbJZwOFxZ\niG3FRCl24Vg8druweyI7MTHB6dOnaWtbvdLfDBvVjHvt+oqiVFIvyWSyqQhcUZQNI2ohBNPT00xO\nTnLy5Enu37/fstcA8Ltfv8/NhSwl0ymPcKuaClWO0gVQKrslSoaFIklYNqQsCwXYEw/SGVG5OZ/H\nchwsSeZ7jiT4zKszBDW57LEOE3NJpkIRSnaRcEABAWOLBQRwf6lIqmBi2gKBTsGw6e+K8yOn+/nG\n3WVyhQL7uyIMRgV3ro+gOAaSEKiKgoNbOXPxQAd/dGmKVx6k3Q5WVeZL1xZYyndwZl+cv/PsHl68\nfB+hBvnBEz2c7ItyfT7HVKrk2heUKZgOE8sl/u75vbx0d4l98SAHuyJkSxYvj6cQuCWTliNYypv8\n8Mkelgs2cxkdRYaBeIgTfTFemUhzf6mEhMNMWuep7gi5kklQld2LRUAhpMpYtlsSmTNsnu6JcmZf\nO9dns9xfLLKQ1YkGFKJBjb/1dDepoklpJu/aMagKju0Qkm1GHiyi2251kivkDqGAgp41kMsdvK7j\nJZV5rdU4wu01yJZMfu2vxvg3P9S/o4V9LXFdr1GqWCwSi8VWTZRqthzYcZyWjo58FOxqYTcMg0wm\nw3PPPVf3itqq28tsNiJqR54AACAASURBVMvo6CgHDx5k7969lb83m1rZaHvbtrl+/ToAw8PD2Lbd\nsjuCkmnz7756lz9+ZaosptSMYnYxy0bi8ZCCUXaYMm2nyopWJqfbZEqmO9C5PAjj1YkUhu1a25rl\ndIYTiBEJqEAR3bIRjoSDRL5k8dpUppIqWcpZXBpfRlMOu97twi3xs1Ho6u7iueEBvm/5Nl+5uUTR\ntNEQPNXmELUyyJLAsGxkWcKyBSUc5jI6p/a6de2KJDAFXJ/NosoSiWjAXdC1HYKqgixJIBwSEY35\nTInp5RKLWYNb83m+90gnsaBKpuTeDXhV4wFF5qcu7OXKZIrjfTEUCVIlkysTKSQhCAZUTMfhwXKB\ntrA7AapU9l8/0hPlfMLigRGlaFg8O9DO/aUCr01lUBVXhEumw98+3k1XVONbY0lM213oVi2LPe1B\nnnsqwXfuLaOZuvsdF24ZaodiElIgpKpkdZug5l5QiqZN7ddC8OaxJpaLLGQNEqHWiHGrvd0bWcBs\ntFGqo6OjqXNrdXPUo2B3nW0NwWCQkydP1n3cW6jcym1Ubeql1tJXUZSmO0nrCW8+n2dkZITBwUEG\nBgYqx2+Ft4xhOfyTPx3h9cl0lai/iVQ17cdx3I7Fku2gINERdgdFhGSq5rAKLNtNRVBuAHIEdIZU\nJsplagFVwnAEfW1BbsgSjpCQypOG/tvdJIqEW/duuha1Od3iykSKr99ZZiGrY5qCzEyGtoDCP3x+\ngMO9bfxUW4ixxSK9UY3OoHtxz6WSqFK5oqe8sPvjp/uwHMHnXp/jXloQCRjMpEtMpUr8g+F9/K2n\nu3iYNcgbFhFN5XB3hP2JEJ9+eYq8bpM3JUppG9MRDO2P8xc3DAq66z450BkiGlT5L1fnufuwwH8f\nT9HXFuS5A/GKs6VVtlSIBSR+/FQv37ibRLdsjvREubC/nS+8mmaumMe2HRbzBiFVcadJyTJhTcIR\nborr8oRbbx8PqygIsoZNe0hDKQ8bUWWJoCq5dzFCIJQAecPAFm5VUkgRaLJCSfI6AN5cFPe+A5aA\nZMHkI1+d4afOxBkc3LooP866c496E6UWFxfJ5/NcuXKlkp9fz5dlu+r7t5NdLewbffm86Hizwm5Z\nFtevX0eSpG1tOAKYm5urVPNU+0e0ajTe737jPtdm0m8ueNY+D0hE3fyz7QhyuoUqSWiKjGFDNKCQ\nKZoguYtiFw92cn0mQ7poVrpBo5rEYFhnJi1jOQ5tQY3vO5Jg+FCC+0sFlvImAUXi+44ksB2HrmiA\nxZxBUFUQCPbFw3z9zhKZkoVWHmkXUBVmMjpfu7lIf1uA3/3mBJmSiSpJ/MDxbv7h9zzF+UUNK7TM\nyFQG23HoCzn0GTPcLYRYzOqVexJJklgumFi2g6rI/NjpXlRFJlM0iAY0CoZDwbBxECi4NfIFw+Zo\nb5T2kMrle/P82DM9HB/s5s/fmOfWfA5VllEkicnlIiFNZiAe5n6y4EbXEhzoitIfD9LTFmAhZ9AW\nlFnIGMzmHJClihVD3rCxLPfuJaDIdEaDPNUT4bXJNKYjCCsSiqwQVAWDiRCTqRLpklUZYBIPK/8/\ne+8dZ+dVn/t+37br7Nl79p5eNOrN6sW4yDamGLAxLWAbck7OoZ2ThITk3nxuCjk3OXCSHAhcuFwS\nQki7ISH0bjDYYIzkJlt1NJJGo9GMptfd61vX/WO9e6wujSxubA6/fyxLu++1n/e3nvX8nodlTWEG\n01WCukbN8eSuB4UVjXBkrq79l7JHVQHzgo3jZMHis/vTHJg9yUffsl6asl1n/TyA/cVebOqDUpFI\nhFqtxoYNG8hms8zOzjI4OLg4KJVMJolGo4vPdz0d++Vi8QA+8IEPnOfw+sEPfpBkMnnF+yy1XtbA\nzlVUINczcFSvOvXS29t7RafE66FizgVqz/M4deoUtVqN3bt3X8TlLVWXfqkLQbpU45uHxslWnEXv\n7nMrqCG13mWLSEDD0FWCmox8s1yX5akACrBQksAeVQW7lsUZTVeYL1oIBB0xg6CdZ8IKgVJDU2VY\nRrHm0toQJB42KNUcQgE5daoqKh99y3o++LV+LEfQ0hDkrrVJClWbhqBKyXTQfAffxrDBVN7kwFhO\nUi6KglBg75kMTw1n6IyH2NGToDcZIVOx2N7dyJznUXULICSXXbMcOfTjY0Ox5vLDE/OMZWtYjkci\nrPGru7toCOoslCy0gBznjwY0qpbDwfE8MyWXr/Wl2VkQ/sSn5NyF/z05ruAtW9t58kyG+ZLFq9Ym\n0VWVh4/NMTRfQlVUcmWLdW1Rn/MWGJqCqqqsSoaZzFcpVB0UVWVrVyMNQZ1oSMPLC0qmi6HJWYDO\nxhAP988R1lVM5NprCGls62lktmDiKq4MAw/IAJCcqxHUTUmN+Z38pYKvbF+d9Nxojs/uHeWDd19f\nyAM/ByrmRkox683ehYlS1WqVbDbL6OjoYqLU6Ogozc3N5wXMX62uFItXrw996EPnyZav5T5LqZc9\nsF+prhfYJyYmGB8fvyT1cmFdT0ddr1qtxtGjR2ltbWX9+vWX/CEs9cdx4eGpadm875+eJV2+NKir\n/uBK/blMv9NT/W5dCDkVWnM8GkOqjGxTFL743ATFmkNAV7Ecl6m8SUtjnHRZdowVy6NkuTx7Nosr\n4MR0gZot+ffpfJXfuKOXWEhnWSLMmYUKqgJVy2VtawOrmqN8/MfDVE2XtniQ165L4QpwhdS2az46\nCwFHJwr8+p5lfOfbMzw1nMXxBH2TRV61NkVnsok3bQ3z1QNjmK5CMqSxpxMWJseoaWHGMtXFgIt8\nzWXvmSxv3dbOd4/OEg1qdMRD/Nfbu/nKwWlOzZZACIqWxUTfLO/c1UkqapDxjdKCuspq3xK4bko2\nvFDl3bd288XnJhHI6VJVVZnMmTSFFQq2pK9s12NZKsye1UmOTOTxBHQ0BvnG4WlGF6roquIbrUk7\nAlWVn4WmKSQDOiXTxbQ82fnbDhXbQ1MUFE3F8iChyRmB+io1VAUNcVHH7vnnK65w+cGJef7LnmWE\njOvb7b6U6YvLvbYLB6VyuRwnTpzg4MGDPPLII2zYsIHNmzezY8eOiya+z61rjcV7sfe5Uv0S2M8p\nx3EWT9V37959TduvpQ4c1WthYYFTp05dk4fNUurcw9PJhRwf/LdDnM56l+zQ6lyrKyDVEJABzK6g\nbDl4inwsVZGKEdWHBc8/PiybLtGAxnyxBgJ0XcV0PCxPyBF5f+S/KWLw7EgGTVUJ6H5ws4Bc2ebX\nv3SMsUwVxxOMZapM5Ws8uLODV61r5mNvXsffPd7P+uVJSqbLjmWNBHWVvokirh/9l4oGiQU1Ts6W\neHYki+NKumEmX2PfmSzv2BGiIxHi3hU6WryNV61OcnKuguO6jIxnsFwX3cN3pQTLdkiEdO7f0oau\nSvniwfEiA3MVf3Tfw9A0arbHTMHinTs7+cmpBWxX8J9u6SYe0vnMz0YYnC0TNDTmyxZnFioEDA3d\nt+G1HI+QrnB3j8G43UDJdFiRirAiFeHrh6eZydcQKPRPFUEIFFVBR0HXIKip3L+5lS89P0nZdCUP\nb0hf+I0dDTx1JisPvgW4CDygKxFkNF0lEtQoWzLmz9BkmtWFV3rF/yvPFeRKNb785Enevnv5ebTE\ntdZLHdivRs8qikJTUxMPPvggJ0+epLe3l0wmw7Fjx9i2bdsV73stsXif//znmZ+fZ/369bzrXe+6\n5ii9a61fArtfdeolEAiwfv36a+bUlkrFCCEwTZORkRF27dp1Q7yqL3w9QgimZ+f4zS8dY6x4aakb\nyINL3fc+qdkuQggMTcVQFYKGTj3MKGxIW4CpXFUmEqkqK9tCTGRKGLqGpqkYqsrNK5JYbpqZQg0F\n6WJ4+6oUP+yX1rquH/Ic0FRiIZ2JXE1eiITA0FVqjuTU//pnZzk8UWQu79GXnmF3b5yGoMbO3gQP\n7ujgqeEsjWGd21c20ZUI8/RwDseTICiEwBHywFdTFNIli8dGHTx1ju8dm2P3sjh7VifZvaqV/jlL\n+tl4HoGAwtpGl2eOj3B43qPigoLC1u5GOuNBhhcquB4YQCyk0RTWcTxpFRwN6Ise6pmyg6qqWK68\nwM2XTF61rpm9pzOULZeArvDK1U04pQyZik3JdDCdEp3xINO5GqqmoghB1XYJ6Squ6y1643TEDMaz\nNfYN5whoULMhX/PY1BZkW7fU7GuqgmZIWWQkoNIQ1HFcD1VTiQV1TMcj1RAgWzZxVEk3GSpUbXmI\nin+xLzvwlf4CqjPI2phFLBZbNPK6ljV7o6mYG1lLtQjwPG9xluRa5kmuFov3wAMPsG3bNhoaGvj4\nxz/O/v37rylKbyn1sgf2G8GxT05OMjo6yubNmxkcHPy5JRxZlkVfXx9CCHbt2vVzW/j5fJ4fnMpT\n9AJYnnWRqZeuShVLImJg1uS/Vy1XHq5pCitbopyeL8vJT03hjlVNVC2PsbSkTNakAqyMmAT1OH1T\nJQSCW1ckSEUDvHN3N9P5KoeG59nSGSMeNrh9dZKDY3kmczUMTeGW5Ql0TUXz5Yn1769OsewfzWPa\nUm3jeIKB2TJ3rk5xYDTPg7s6yVVtcjWb5akwd6xOMVOo0RoLMl2Qtr6aCq/b0MKWrhgffXSIbA1C\nAYHleuwfzbGpK0YibPDQzg4WyhZVy2VLVyORgMbn9o1Sc2syr9Xx6J/I8c4tcWabQ4xmKiQjOm/f\n2cU965v5/W+dZHC+jKooHJrIs3tZQuad+j9KxxOEdI2N7TFWJCPkqzbRoM7r1zfxn/95lqxlo/gO\njfvOZFAVgetKhZChK2zqiHFqriQVSbrKuvZGftA/K4FaVYkEVUzLd6NEwXY9bMfzdfIuQqioQg4x\nWZaDqkguPqip1ByB68mL/uWSfufKDv9y0uTt29t5Z0+KbDa7KBtMJBKLg0CX6n5f6h37UoF9Kbe/\nWizeXXfdtfjn7du3MzY2dk1Rekuplz2wX6muRpPUNeNCCG6++WZ0XV8yfXOtVEw9NHvNmjUMDQ39\nXEDdsixOnjyJ53mM242ky2mcC1y9dOWFTNKFkiX/X1cJGRKIDE1ltmCiqyqu52K7gmdGsr5PjHzN\nY1mTnlQzp6fyRIIalZrN3sEFCjWbtliQ/qkC8wWT0bzJxg6H5c0R/uTetaQrNofHchiK4NRsibtW\nJjkwkadqy9zTPauaJMgLcZ683vU/36rl8Jtf7mcsW0UIQd9kib95KExTJMCDOzt54nSakumwtauR\n3mSEA6N5clUX4evwVUWhZnuUTZeIodMZDzFbMBlakJOpr1jRtJhcZOgqOqBoCqFgiF2tZW5OCLa0\nKShhk688P87peUnRGJq0Kj4+U+Tem1r51pEZSpZLxNB4763d5Co2D/fPUqw5tEQDbO+MyO9FqKDK\nnUHVcolHAuQqtn9xUnnF8gSrW6PYruDEdJGhuRIl0z2vm1MU6IoH+F7/rPTHF1KXnogG2NrdyHNn\ns4QDKqoj/LhBGcUXDWgUTRnHh3+xv3AZe0IhV3X5yqFZ2hpDvGVrL729vbiuSy6XI5PJMDIycp4t\nb32s/6UM7EtVyi1VMr1161a++tWv8trXvvaiWLxKpcKnPvUp/uAP/gBd1zlx4gS33HILyWTysve5\nnvqFBvYr0SR1G4Kenh66urrOC/G9HpOuy1U9eGN6enoxNHtoaOg63s2Vq1AocOzYMZYtW8afPzrC\n/uk0Nefi9+H5E6W6cr5vt6GpKIqgVJNdZChoYGjyMzEdgRB+UjvgKhoHxwt4nkc4oGNqKo4riAY0\nnhhcwBEyo7RQ8yjUXLoSEf7oOyepmI488Asb3L02RcjQ6EmFuKkjxkS2ykLJZmiuTFcixJB/oCqE\noCMewhOCgbkSo76boaIo5CsWn/zJMJ96+03sPZ2mNxlmoWzxyjVSXhkOaCxvCjEyX8ITkhppjgRZ\nkYrQFgvwN/tGOTZdwnEFp2bLOJ5gS1cjTwymF/3Yt3Q1sq6nmcdPKTw5WuF74w5hfZ5b2hU8zwWB\n7/siCOoq8ZDOu2/rYaFo8boNzaxubeB9XzzKZLaGqkjK688eHXnhEFiRmneBwv2b2zk2WcB0PVak\nIswWTRqCOk8PpxnNVH3AdAlomq/GEaxKhXjdmkb+7IkZdE3B0DXwBE0RnY54aPFAPOTbABuqguVK\nr/v68JY45wD93FIV4V8oXL5xeIb7NrVhaCqappFKpUilUuA3FJlMhomJCYrFIpFIBE3TXhQwnVs3\nmta5no59KcB+tVi87du388d//McEAgGWL1/OK17xClRVveg+L6Z+oYH9ct33udTLhTYEN7Jjrwdv\nBAIBbr755vMW041crHUVz9atW/nn56Z5asJCUZXz3BlVn+pw/ZDoumY9X7HwXI+y8IehhELYUEF4\nKKqKJwTxoMpC0SYW0ihZchAoYqjMmw66D0qGLrtM0xWLgzAqChXL4ckzaSZzVQz//WfKNjuWxWkM\nG/zk+ALf758jpGusa4+yoSPG2vYGHh9YoFws0NOeZNeyJsIBjQ1tDew9nZFtql913v7xwTQ/Oy0D\nMfoni745WBN7VieZT2dJuwY9TWFetbYZRYHxXI2RtDQUA4HjSXB/z209xII6jifoTYbpTgQ5MV3i\nRyfncV2Bonhkqi5TzU2s6whycrqI4wpCqsf93Q6NXpFvnqxQtgTHp4v8p1d0M5WrofmacMcTZMom\nm1sMTuXlgXM4pPKGjS2oKtyxOslXD01zcnoWXVPoSoSZK7xwFhE2dJIRnU1dcQo1m7lskX8+lEYI\nFp+j5jqAwky+Rsl0fTWSRyxksCIVom+qRPUc45jGEJTP4WM0RR6i1uWPVdtlIlcjU5E7sgsrEAic\nN9ZfqVQYHh5mbm6O+fl54vH4Im1zPaP5/55B1tdze64Si3fvvfdy7733XvU+L6Ze9sB+tdzTc6dC\n69SL53mL1Mul7nMjLAIuZ0HAOecCSwH2S93e8zxOnDiB67rs3r2b0azJc6NSLudeMF3qAUEVdBTf\nMkCWoUHI0OWWXIG2xiCd8TAj8yUqjkdQFcQ1m/buOIWKicDhFSubWdvWwDcOTZKpWCiKwormKDd1\nxDg4lpVZpX4SZ1tjiHzF9j8rfF5X+q2MZaocmypg+BeQ8XyNZckI0YDG7auSTIyX2dgbJ9UQoCUW\n5LaVTXynb46ZQg38i9Oda1IcHM3yzEgW2w9oLZgug3NlNnc1YmgKG5o17t6+mnTZpurIidCS6eL4\np8qaKgFXCEHFcrn3phb6p0uMZ6tEAxpzRYua48mxfV2eT6TLNg/u7GBVcwRVUfgPu7toiWr89leO\ncXS6Ir1b5suMzBdpDAdYKNv+MJIgpOt0xVTu2CRpmoNjOQbmSty1Osl3++aYzksfG0OVtJjtd9gy\nkEOhYntEgxp7h9JUTFvmm6oqiuKh+JOoXYkQz43mCOpy4lcIQSyoYrvQENCkj4xv5xDQdUxHBpgI\nIUFd9deM1L5DtmLzuX1n+dDr1mBcYXBJURSi0SjxeJyWlhZaW1vJ5/Nks1nGx8cBFkE+Ho9fE2D/\nPIadrlUcUZ/8fqnSSperlz2wX6k0TaNWkyBwOerlwroRk571HcHldPD1Lv9aF0td6XLua65Wqxw9\nepSOjg6WLVuG6wn+Zf8YfVOFRXXDeY/hm1hFAhqm61GybBAK8YDKtp4GTqctmhuC3Ly8ialcFU1t\n4PRUhnhQY9eaLlwBZ6Yz6AqsbIliaCqrWxs4OpEnYmjoKgzMFlnb1sB0robiuTRFdLYvi/P8SHbR\nSlZXBYaq0tMU4rGTC+CHVyAUilWH+aKJ3hjkC/snmM1b6INDrGiO8tZt7axqjvLPv7aVT/x4mIrl\ncuvKJl6/sYVHT8y/QMn7KUqRgMbrNjQzWzR5+KDD4w+fpmK5rGuL8qYtbcTDOhs6YgzMlKh4Cp2N\nAX7v1Stpawzw+98eYLpg4rqClc0R7tvcSiyoU6zagPwMd/fGiYcNuhMhpvIm/dNFAprKbMVb/L6E\nLxXd1eZQrHhUHJVAUON37uzGKc6Tcz2+0zdLumxhaAoD0yUiQW1xx+P5B589TRHmiiZV2yOow/ae\nOEcnCi+EiKtyHa5uiWJoCstTYRIhg2dHsqiKQjKsg6Ji6BoBXZVKIFUhHgnguB5ly5NB2ULuxlTB\nRYErroDHTi6wULL5xNs2Sl/+K1R9UlRV1UUg5zKxeHV+/nJujP+eHXv9d/dLYH8JVb37npqa4uzZ\ns9fkALnUjv3chei6LgMDA4ue8JfrCq7XhqC+uOoa+I0bNy7+YL59ZIqT00VM33el/rtUgEbfzCsW\nNmTnpmtYjswJbdBcnj5bRFUU5oomM7kqmapNEJeap1AVCoWay76hNOWa3K9/5cAEt69K8cyZNIau\nYqoqQ/MVUg0BNrTFOD1bplizsVzBdK7GXWuaSUYD9E3maQjqvGtzIxiGjIPzwSugK0SDGkFd5dGT\nCyyULRnAoSqMZCqcTVfQVIXtPY3sWhZnpmhyy4oE8bCBoausaolwbKqE63kENJXXrEtxaDzPT04t\ncGzBQ9dkZ9s3WWRNa5SNHTHu3djK7969gtNzJfI1l9mSxd8+NcZ03kRVFVwFRjJyGvRNm1t57PgM\nzbEgd65t5U2bW/ns3lEeH1zAcQU/PDHP+jZpeCYwF73cUw0hXrN9OeuyNYqlCscn83zzwFnWNXpk\nFcFc0URTVRRFZb5s0aYGCBo6luNiOh6RgM5r16cQQKYk1UDnYp88C9BAUehoDHJ6vsxktkbF9rBd\nQdSQHb7juSxPhRnLVqnZkp/3PIeQoaEpijyU9deNpoJyiebA9QTHpgp89EdD/Mm9a66447zcpOil\npj3rboyVSuU8WWV9COjf03fm5dit84sA7FdaXIqiMDc3R7VavSLQnlvXHQbtx/F1dnbS09Nzxde1\nVO17XWUghGB4eJh0On2eBt7zBF89OMngXOmi6dL6MJGhq1Qt2anVt+4V22W2KAOdQ4ZG0bSZK1kI\nz0MzVDRdxXY99g2lqVhylD9sKBSrNk+d8RU3Lqiq1FrPFy1Oz1Uo1GTaUt50efzUAhs6YiSjBlXb\nJV2s8k8Hqmxogt1JhZqpk6tJl8X33tbNG25qYzJXY2BWxfT8kAxPeocjBL/55X4OTeQRnuArB6f4\n6JvXs7kzRsVyaI8FmSmYvG5DC4mIQc3xmC/J9CbXt7F1XI/xbI3VLVHuWJ3i+dEc3+6bZUUqwvae\nOPg8eMDPG7Vdj4rpsq69gf9xd5JV3e3MWgZ7T2d4diRL1fLQVAl6wwtl3n1rD18+OEWpJsf6f+fu\nFdy1JoVpu/z2V/s5PmchBPQtwOZ2+Z5c16XmSWBtCOrcuiLJkYkCrhDcuaqJxrCBEPDYwAKjmRqa\n4hEN6AR0laorA7/b4yE8BNMFE4Ts9jVVQagKEV166Fcsl4rtEQlqVC35fFu6GnhmJEckoFCzZcce\nVKHqXbyOLFdguS77zqQZzXSzPHX54ZlrBcRwOExXVxddXV3nuTH29/fjui6JROKG+aov9bUt9bYv\npXrZA/vlqlQqMTAwgGEYbNmy5ZoXxvXYENi2zeHDh9m0aRPxePyqt7+ejt00Tfr7+4lEIuzateu8\nxfadI1MML0inwHOr/o7r6hbLkfa2qYYAnidwhViMxHM8gaEquMJFMXSEgp+c5C0GSoR0FtM31rY1\ncGyysOjwqCrQlQizUMrLz9pX0Die1FY/0j9DrmKjaipzFXAw+LWbO0mmSvz4VIZi1WTf8TFKhQLN\nEZ1IUMOyXTxPkAgb9CbDBHWNIxMF6USpKpRNl//nibN86T07aG4IcFN7jKLpsKolyrNnswR1jZs6\nYvRP5LGFQEEhFQ3wazd3sbM3wWeeOMvXD09TMh2OTRaZLpjctrKJsUwVy/UQwE0dMX7zruWcTVf4\nHw+P4CpFwobB23d0oCjSjsAVoIH02dEU3rWrC9fz2NAeoylicGgsz/6zWY5NlfCQVsKWB+kaLG+O\nMpap4glBLKCyOmpiVOa5rSPMczPSo8Y+m2d5MsxoukrAUNEUjYLpsqo5QkJXWdUchUCIkbR01VQU\ncFwpT13bEmVta5S9QxnGMlWEH9sXC+m4nsC0PSKGiicUApqDrqm4HoQND9uVKVb1Tt5xZYJW1XL5\n7tEZPviqlVyurkcccCk3xlwux8zMDNlslsOHD9+QtKSlUDG/BPaXUNWpl9WrVzM3N7fk3NNrteH1\nPI/Tp09j2za33nrrFf0jzq2lArvruhw9epTVq1fT3t5+3r8NzZb4zBPDWI57XreuALGQTsV0cIUE\nRwWFbMVEVcGyBDXXI6jK7q5myuDonctTzBUtJrJVAppCWyzMhvYGnhrOkPcnJVsaI9y2MkUspHNk\nPI/rCe7Z0EpPMszZdMXXwUs/kxVNYSZmFyibNoqq+rJKBdsTKKrKo0NlhjK+iqNqk7eLvKINtiRc\nFgIQa4jytp09bO6KM52vcaHhcN1e4InBNJ/Ze5Zc2SIZCbB7eYLbVjaxrq2BHa0aE2aARNhgfVuU\n8VyN2eIcPx1MY7kC1e/MT82UuGdDC++9tZvRrEkkoLGjp5EnBhf4672jzBdtNM3FdmuEjqls64mz\nbyhNzXYJGRr3bWrjrVs7KJkOH3lkkH94ZgLH9WhpCHD/lna5Y3A8XOQhpaoqPLSzc/Fi9b7bezgy\nUSBftfju0WkmciaqIsF1OldGCE9a8NoeCnLmIBXW+N7JLK5QCBjyUNT1PGkupijEQxqPnJjDUBVs\nz6NqecTCGg0BOZE6XzQpmi6uJ9UwhqbgeC6ekHMNCnLa1vIPUz0PhOUxOF++6m/jxQJiXVap6zq6\nrrN8+fLzZJXRaHQxRGMp0sqlduwvt/QkftGA/cLcU8uymJ6eXtJjXCvo1mo1+vr6SKVShMPhawb1\npTwH/kWqWCyyefPmRV6yXkII/u6pswR1qXY49xFVH7DPVeB4nqCtMUTE0NAUl66IwU1JwXS2TE0J\n09MiY+YESA56alXupAAAIABJREFUUyunZ8uoqkJrLMi3D09iOnDryoQvB4xweCwPQP90kTdsaqVq\nuiTCOhPpEgENPrA1gAf8eCTEfNFc9Fy5qTdOUFOZK0iOWfghFmkTent7SbVZPHtylDOZGh//4QCv\nXBbkgR3tdCeCjGek/C8c0Lh3YwvPj+b5h2fGyJRtEJCp2hwaz3PL8iYs1+WmFp0/f+Um9o+VEMJb\n/EzqIR+aouCq8mrYFDF4w8YWLMfjZ6fTlC2XfM0hX7XxkJ25psrziDdtaScVkSZcr9vYyu7eOAdG\n8/z41DzPDOdQVUmhjWWrDMyUWNMa5cR0EdfzaI6ovG69lF7euqKJRwfm+d2vn8B2PfasaqJgST5a\n+EY2HgpRA0pV2XSEAiqbO6I8emKOqi1tiCv+4FFjNEh3IsS69gb2DmYkkOkGuioI6BA1NGxXsL0n\nznMjOYK+z4/qa9cVRUVB2hgI4YeNn7O4HAHPj+X51/0T/OrNlxYi3MhOt/5YwWCQjo4OOjo6EEJQ\nLpfJZDIMDg5imibxeHwR6K9Euy6lY1+q/cBLpV72wF5fVPWQiq6urkWO23XdJdMq10LFpNNpBgYG\nWL9+PalUitnZ2SVtPa8F2D3PY2BgAMuyaG5uvmRHkqva9E8VmMxWL7INEJ4E9nBAhlEj5ORhyJDJ\nQYaukAwpZHJFhks6QvEouyVWNkeIhQyeHErzxOA8jSGdN23p5Pv9c+Rqcupx31CGezbofL9/llzF\nQtdUynMl/vvDp3hoVzfxsMEJ08NyHD57qMxvvXodD+0s8v3jc1Qtl2hQ5bfvXk5HY4i/f2aMWsFa\njGmr2+oemijx9JSHUBRA5ftnXbqaK3xod5B/OGxS8XRevTbJu3Z18MjJNEJI3T5+4Icn4M41SRpD\nOl/NTPB/fHuQ+ZLFps4Yd6xOoigKmztjHBrPU7ZcGoM6D+7oZM/KJj7yyGmeGc5StiTd8eat7USC\n2uLAl6oorEhF6WkKsbOnkadHcnxh/wSffmKEu1Y1kSnbMhC7nh3rf1dv3drGutYojQHBlsYae3b2\nIoTgwz84zfOjOVxPWgo8NpCWYGvLVCh5ETN4cMcyfjwwD3j0NKiIUlpKS/1sU9OVgd3/7fVr+NHJ\nBR4fSFMyZfedr9gYuoqhKdzcm+DwRJG+iQJl2yOgSSdPHQmgnpAGb1X//bqXGHRzXY9/enacoKHy\njh2dF/37jfBPP/exLgRXRVFoaGhYDLn2PI98Pk8mk2F0dHTRxOtSIRpLuei8HPNO+UUAdoDp6WlG\nRkYuCqm4Hr78SgNHQghGRkZYWFhg586di37KS01quhqwn2vnu2HDhkXt/bnleYI/+mY/IwuV8ygY\nzZfEGLrkk21X+NmXspMu1RyqlovluiwUqoCCI1wSEY25oknJdLFdj6rPrXvC4bt90zJoWYCuKDge\n9E0WADD89+y4MpxjrlBj31CaquWgKApnMjZfPzTFnWub2bMqyRODC5RqDl94doI1rQ2sbWkgXcpS\ncz0SkQB3rEpiOR7lmoMnXphFKlsuZ4oq//HOrcQ68nzsR0M8MpDhxESarphKc0hluuBPUApBd1OI\nvskCUzmTvzpUpeLK9zpbNAkbGtt7Grl3UysP7Oxg/3CWgKHS1hjgEz8Z5ocn5nA9eaHpny6yPBXh\n3o2tPNw3TSigsywZ5Y/fIEMQnhnO8tm9Z6UKxXGZK5r8yrYODk8UKNXkpG08rLOtW67L+za18K3D\nU/zVYJG/7T/Cq9elODYpX7jsjmW49h2rkuw9k8G0PUIBlbvXJImFdF65rpnJbJWBuTITSpBE2KVg\nedRsaf/QFBB8/EenGMnZ6Jq6eJbiCoHiefQkwqQrtlTjaJK2qfkaeUWBsK6SqzoUavKgPaApOOfK\nrOq/BQ9qjuAL+yd4zbpmmqLn71hvpH/6tQDx5WSVMzMzDA4OEgqFFoHecZxfcuwv9crlcszOzl5S\n9XI9wH45xYpt2xw7duySh5dLTWq6ErDXdwPn2vleKsf0wGiOvsniRT84/F2zoakUqzaWJ4iFDFQU\nMmWbmu0R1KTqA1WjYkrJm+l4gKBqnePbrkBI10iE/fAJRe4CKqaNJ4LEQwYl06EeutYWCzKTyVE2\nHelzDmiaHGmfylX55uFpijWpCvn+sTneuFlhz+okG9sbKNsud69tZnVLBENTmS6Y7D+bXXxPIV2l\nLRZgIlvlt756gkxZyv7O5hXevCnF7cs98Bxmig7djQavWREmU6wxnK6St0DT8FUu0qfmzjVJXrG8\niYCmMFcwpT2uqjKeqVKzPQxNRfUlfmOZKm/Z2sbHXpNkVU8nBS/AvqE0AF87PEPJdBYjA3MVh2LV\n5h3bO9g7lKGtMchDOzu4baX8Lv/k4VM8ejKN7XooFCnWHJIRnbGsvAB7rkc4FGB9ewO9yTA7ljWy\nf0SaQxVNhwOjOU5Ml7A9IQ+Wg7CmJcpMySERNrh7VYKvHZ6RNgWe9McJGSo7uxOEAjrt8SCPnpwn\nGtTQVOnKaTked69NYlQzHMoodCcCZCourueRCOsUq9Lj/dz5CEuAZzoIIXjkxDzv2n1+GM2NBMTr\n6ZrPlVVeGHJdLBYZHBy8SFZ5qfolx/7vVIlE4rL+yNezFbzUxSCfz9Pf38/q1asvmaRyI+LxhBCc\nPXuWubm583YDl7v99/qmyNdsLrwE1RUajisPRx0hFQ6q763uuB4a0BAOYrkukUB9+Elql2Nhg4rp\nkKs66JqC7bo0RQNsCej0TeaxHekP8+Yt7SyULR47OU/JdAloKu/dFMBzHZ4ZD5IpW4vmW2vbGwga\nKiXTRlVVVAS2EAzOldjS3ch82eJHJ+f56qFpgrrKgzs6uPemFp49NcVoUaBpKps7Y7z+pjYeOT5H\nvuag+JyN7Qkmiza/+5oN3LfDZq5Y4/t90+wbLrA+nqFW9QioL1iPKwg2dzZyx6okuarD+79+nOH5\nCgFd4bXrm7mpM8bBMRlHp6oqsYDGe27t5vZVSZ48nOa3vjnEZF4mTf3KtnaSEYNBT6CqknvXgZCh\n0REP8tcPbmI8W+XgWJ7xbI1YUOPEdOm8qL5c1ebBXR1ULBfHE5iuYM/KJlRF4Y7VSf7qZ2c5MVOS\nnHh3jELthUNyVVWoOh47emKULIWzmSrHZysYhkZQd0Hx140QrIuUODLncnpGo1STk6u6Kr3cIwGV\nHT2N/MPeeeZqnj+ZCoYms25l1w8XNu6O7yPz5FD6ImD//7tjv1JdGHL93HPP0dnZSTabpb+/H8/z\nSCQSJJNJ4vH4eUB+Pc99pYi7/v5+vvSlL6GqKh0dHfz6r/86J0+e5JOf/CQ9PT0ALFu2jPe85z3X\n/X75RQD2G+2SeC6ICiEYHx9ncnJy0cDrUrXUsI0LgdpxHI4dO0YoFGL37t0XLaQLb/+j47M8PZLl\nwp+arsre2fMgHFARQqVkudItUBGUTYfGsJS5Wa5HxNDY0xvj8FQF01NpDOl88h2b+Nf94+wbkr4r\n8ZDUVSuKQktU5ch4lpZ4hK09caq2R9n0+EH/NJZZ5VuDCp96524OFIf4yQlpL7u6LU5HY5C1bTGi\nQR3b9SQf7ni+PlsO9+SrMou1WHP47rFZGoI6v72rgfbuHqZLgmRDgOXJMOGARsTQKPkHn0JAIqxT\ntlyeHs7yuSdHyZblQed0Jcy7b+liKDPESEGg4tEYVkloNb51aILHh3IcnyriCUHJhEdPLvDBVy7n\nvs2tnJotg4BXrEgQ0FVGM1U+e6DAYMbGE/J1fuPIDL9xZy8TuRrFmpQKvnJNkvf7yUMff+wM3+2b\nkW6LEYOHdnUuJlTVy1AVgprKu29bxus2tMhDZB8U/2bvKPvP+l7zisLTIzliQX+t+eteVxTyVYcn\nzhTIV2yEArGgTnNDgJLpEg0G+Y+7uzg0UWC4lKNqu5i2S6nmYKjSX6Y3GeZTPz2LZcmAjoLpoCkK\nYUPuWExHnhcENCmjPHel2x4cnykxna/REX+hGfl5c+wvphRFIZFIkEgkWLFiBY7jkMvlWFhY4MyZ\nM+i6TjKZXNyFLSXv9GoRd5///Of50z/9U1KpFJ/85Cc5cuQIwWCQjRs38nu/93s37D2+7IH9Rle9\nY68HWauqetkg63q9mI69VCrR19d3SU+Zyz3+gdEs+KZd50J7NKBRtR1c/4BP1RRaAxrCc9Fw2dQV\n5/bVKXJVh2zZQtcUdGGyoinAgqmye3kCy/GIBXUiAUm/pMsOg3MlQobGz4ZylE2X2XKe//nD03z0\nLTfJnUPFRtNUnh6v8hc/GmRDeyPV5VWeG82zUDI5M1+muSHI2rYGTs6UUIGtXTHu29SG5Qc419+I\nosgYOF1TmS97fO6RYQYXpHfKrSuaeP2mVm5f1cSzIzksx6MlFuCBHR08OZTma4enWShK2aaqKIxl\na4xma9zSFeQjb13H4ckyAcWlXC6TnptlcKqyKNJW/Gi+qu3yO69cQTSo8+SZDGfTVdIVm6m8SaYq\nwUoREujq5xB/dM9quhIhDF0hV7E5Pl0kqKs8PpiWsk4F8jWHx04u8MZNLXzn6AzFmk0woHPn6iQN\nQZ07VjXxiR+f4Sen5ODXjp7YYtB1HSAdT7AyFWEsVyNfdQgbKltT0D9dwXY9wgENT4DlevzBXasI\naAoTuRpBQ+PMQpmKLQ2BAoaOpiqsSARZntA4OlnEtmV0XsRQqVgemqYQDeqYzgvuYLZ7aXvfiuXy\nJ98b5NMP3EQkIH8nN1oVs9Qw6aWUrus0NzfT3NwM/hlXNpvlm9/8JiMjI3R1dbFnzx62bNmyeJvL\n1dUi7j760Y8u/rmxsZFSqXTDw3b4JbBfXJqmYVkWzz//PD09PXR3d1/1PtcTaO26LjMzMwwPD1/V\n6uDcHFPTdnlsYJ7pvHnR7SqW49MBgoihoaoKwqlRdBRaGyOkYkHOZqo8fSZD1XZoDBnc2h3i6HSV\nsi2550dPzBML6YxmKqi+9HHfUIbNnTEZa+d3PH2TBf7upyfIVWxpFet3z/2TBZYnozwykKVmuyiK\nw1S+RmPI4C3bOrnHdJnNV7h7bYoN7Q0oisJ3+mY5NllAIGWIqQbpYbJ3pMrRKVs+J/D44AJ3rE7y\n5i3t3LYySUBVeOW6FD8dTBMJ6r4qRr4O1ddk37E6hTObxRHwL89NYruCtsYAb9++jGXpadITeWlf\n7EEqBDenHDyryv97KMc/PjuB5wmaogbvubWHoOZTDL7TYjyss76tgQ3tDRybKvLRR4cwbY9bViRI\nRALULGfxu6lfgFPRAP/zvl6ymSy7Nq2lISh/gg8fm+VbR2awfM5j31CWbd0xNE3B88NIogGNmzpj\n/J9vWEP/dJGi6ZKbm0IvB5kuWtLrxQOBQFEEjw9mODFTAt9R03GlLFI+lo6jKByZtZmvKYtduKZA\nWIeY4VGtmWiK7NQNTfHzUC9en44rLZUfPTnHW7Z2wEu8Y79ahUIhOjo6+MAHPsDo6CjZbJZcLsff\n/u3f8ta3vpWNGzde9r5Xi7ir/zebzdLX18eDDz7I2NgYExMTfOxjH6NUKvGOd7yDLVu2vKj38LIH\n9mtZPEuRIs7NzVEsFrnllluu6itTr+sxDpuenkbXdXbv3n1VK9NzD0//9OEB0sWLQV0BdE1ywhg2\n4YBKtVqh5EgfkbmiyVS+hqErWLaHJ+Rj/mS4iGV76IZcCgslk4rpglBw/b2A6XjYnlRtaL78TrgO\nM5kCkaC+6BYpEDRFAkzlq1iOtxgYYTkeJ2dL9KQi/HRwnmMTeb5+eJq2xiBv397B/ZtbZVRetkok\noPGGm5rZ0NHAtw6KxfePDyCTuRpv3NzGmfkyH/7Baf7myTE0FX51dxevXJtiKm9SqNoIActTERZK\nFpMLDt96fpDRdBUUmC7UUIB33dxFV1OIwbkytuvxxo3NDGQcRueH+cen8hQs+cGWTIfvHJ3hdasi\nHMsoZGou8ZDBh9+4ls54iIlclT/8zgBTuRqqqjBTtHhgezstsSATuRqooKsqa1uirGyOsCwm2Dtg\n8fdfOoamKrz31h6OThaw3BcoFsv1UFD51V2d/MA3Odvdm2BjewMtsQA//VlGplxZNd68pYm+6QqZ\nigUCWmMBTs6UeOJ0BtutSzQlJ29oCgFNY/eyOE+cljsKgQRsHVAUlY6mEJ7jks2bWB4EVAhrENE1\nVBUWyu55B6ke4LguTwymF4H9pcSxv9jq7u7mjjvu4P7777/qba8l4i6fz/Oxj32M9773vcRiMTo6\nOnjHO97BrbfeyuzsLB/+8If5zGc+86J2KS97YL9a1UH3aifbdd24aZpEIpFrBnWWyLGbpsno6Cih\nUIjt27df0wWn/h6EEPRP5kFRFh0A8bXSAmgK61iuoGaDna/goGG7Hg0heeEwFEHFdOVFQBWLEr1z\nX4MCdMSDjGVrmD5NoqmwZ1UTxybzlGo2juPQ3mCwZ9NKlueqfKdvBs8TtMSCfPDulXzxuQlQ5CGu\noUlL3mhAZWShzKHRnLTXBQrzZZ4cyvCaDc3cv7mNje0NHJ+WJl29yQgbUgajBSH140LQENK5a02K\n50Yy/MkPTjObN1E1BeEJvvj8JO+9bRnv2tXJaEba7W7ujOEKwUxZMFO0UFU/uNq3ob1zVYrXrGth\n31CakuWiqwquJ5gqhqh5RVRFLPLhM9kivcsM3nr3MoKNKQ6M5Tk0lmc4UuHMgpy2rX+OFcvh6FSR\n997Ww8mZEgtlm7tWJ7lnQwuaqvCFJ4f4174irr9D+bMfDvG2bW0ENBXL/2yCukpvKsT7bl/Gu3Z3\ncXyqSFPUYH1bA5/48TA/HUz7Rl4eXzs6x6vXtzCaqRIyNHb0xPnRiTks54XhGlcIdnY3sqYtiq6q\nLJRMDE0OeblC0BiEpG7z2/es5+uHpxlJV+lIhJnO1XCEIBSQ7pa5S+ToeQLKlmAi90LDcSPzBm4k\nsF8uRvNKz70UVczVIu4qlQp/8Rd/wUMPPcTWrVsX73PbbbcB0N7eTiKRIJPJXDSQuJT6hQD2a8k9\nvdKXU61W6evro62tjQ0bNvDMM88s6fmvlYqpZ0bWbQGWOtDUP1VgKm/K7fo55fnRZkXTpWS6cjQ8\noKMjo+DqplCGphA2NBmR5tMJrQ0BiqaL5Um+uDFk8N/uXccnfjzERLaGrircsSZF1RG8fVOSp07N\n0hiPsWtFK62NAd6wuY37N7fzvb5pUGR2587eBP1TecYzVXQVdi1P8v49K/jX/WNYPh3getK7JVuV\nPuX7R7L85WNnmC9ZNAQ0/vMtPdyxLISjhzk+V0N48Nbt7VRsl4mcKb3EFQXPA01VQUB3IsTWzhjh\ngMZ///4gC6ct7lydJBpQCGpyFF/1A697khECukqmbPHIiXliQZ3t3Y1omkIooNIZDzGWkY6SqqJw\nz03tdDYWmJyZ48++MUTBUgkYKvesbyESNhapirrdbdhQ2bkszn2b2jg1U+LweI7nRnPc3JvgybMF\nX3Ujdz/Zio2mKDy0q5OH++cQAjZ1xnjbtg4KVYc/+f4gAzMlBHBzb5yJbAXwLXuBhZKN5wluX5Xk\n9GyJkzNFklEDzdex45+5vGZ9M7may9PDGVxX+MNIwp8GVohFBJ/52VnOZqq4rouuaUSD0hm06oDl\nKWiIi5RY+I2FvHBn2dHbdE3r+lrr5zHFupTb36hYPIAvfOEL3HfffWzfvn3x7/bt20c2m+VNb3oT\nuVyOfD6/KHW+3vqFAPYr1dW07PPz8wwODp5ngbvUuhoVI4RgdHSUmZkZduzYQalUIpvNXvb2l3r8\nctXkn4+MoyqCCya8UZGDJbYtpxA1ta6QgYagRtnnesOGwZ7VSSZzJoWaTSIcYHt7kJuaPD53uELV\n8ti9IsGzZ7PcvaaZx07Nk6/YnJwpEvAsmt0FZkyFszNVTqfHuXN1iuGFCl9+fsLXlUvN/Htu7+XB\nbS2cmU6zYXk3a9oamMhVuW1VkmdGsqRLsrMLaArr2qJ4QvDkcJaFkiXdKC2XLz4/yZ/fGeX9t3SS\nc3Wm/UPAmXyNaFAjbGjkq87iRT3VEKA3GaZiubzvi32cma+AIq0O3tircs+GJM+eLZCrOsRCOq9Z\nl+LMfIn//RsnOZuuoqpwYCzH+2/vpTGo87G3rOf/+on0fV/bGuW/3LGc8eHT/Nugx2gRFMXDq3l8\nu2+aX1mtsaM9wLE5qcZZkYrwkfvWkmoI8k9Pj/MPz4xTthziIZ0HdnYS8t0W62VoCo1hg/fv7ORX\ntncwnTfpaQrRGgvymSdGODxewPHX1xODaXqSofOagkhQZ0tXI5/dN8pMoYZAoasxyO7eBCeniyiK\nwtauGJ6AL+yfwPEEmh8ULteLSjys0b8AmlYFAVUbNFdSTqoKhZqN5cpd2IXrr16OgD/9zjE+clcT\ntm1Tq9XOk+1eb72cgP1KsXhbt25l7969zMzM8PjjjwOwZ88ebr/9dj796U9z4MABHMfhfe9734s+\nLP5fFtiFEAwNDZHP59m9e/eSvF4u9RxXisc7fvw4uq4vxuNVKpUlq2gKpstMoUbF8s4HdT+7tGp5\nhAMqhqIgPBchoCFk8PqNzWQq0tu7uynMeKbMrt4Ew/Nl5komsaBC0XJJl20qtsuPB+bZ3ZtgeL7C\naLaCpqiMZ8qksyrhcIiiVSEcgJrj8cTpNLe5Hml/WAgF8lWbvYNpXrM2zlDG4sdnh1EV2NDRyKvW\ntfD27R08PZzBcjy6EyE2tDUQ0FQM9fzdi0AwmnfYsFLjk4+Ny4QkV9AaC/DuW3p4YEcH3zgyQ9ly\n6Y6HeOWaJI8Ppnn81AJn5ivS5wSYLVgcnNX4i7d1ctvqFLmyQzSo4wnBn/3wDGPZ6qInypn5Ciem\ni7z71h6aIgb/7fWrOTxRQEHhJwMLxC2Hybx9zvcCVUehvauX/7AiRP/oHAu5Al1xQTkzS4AkXzww\nQcWWdFeh5vC9Y3N85LWdDM1XmKt4GKq0NnjjplaOThT41tFpDo3JFKw3b2njbLqC7b5Al7lCkIoG\nCesacyULx/a4a20TigKZsklA11CBXM0hFdb4r3uWoShSo/+bXz7mc/dSpmg5Hq9e38yyZJia7fIv\n+ydo0BUCqkLQ8PA86E2FGV6oSDUQAj9o6yJNO/7Ba9HT6S83sELkGRgYwLZt4vE4qVSKRCJxXcM+\n/57DTtczoHSlWLx/+7d/u+R9/vAP/3BJz3G1+l8C2C8EUcuyOHr0KIlEgp07d75oLvByVEzdv2bZ\nsmV0dXWdd/ulAvuJmRKHxnIXqRI8X64nkJrkzkSIpGaStgxWtcQomR4nZgrkqw79UwVuWdHEwdGs\ndBRUBCPzZcKakNOZqoLpCA6M5jA0lbCuUrMcNAUqno5negghR8mlB7mMmcP/kauKiqoKbNdjYLZM\n/5yNI+So+nNns3TGpTHV59+1hedGssyXLW5b0UQyGuBnp9NM5muyk1WgMx5C11S+eGiWvWeyeL5s\ncLZg8sMT87xpSyu/cUcvO3oaOeHTFCCthvGta+vgs6xRpTUW5NiMpFbqyhaz7v3i/50nYEuXtNoF\neHwwzULJojcZpikS4MysQ0djEMQLz9cY1njthhZSDUGCBZUfDThUxxxe0VXg1pYstZqN58qLAIrk\n8FMRg798bQtzSoKQoXFzbwJVVdg7tMBPTqWp2nIt/dP+Cd66RQZI1z/ngKbyli1tGJpCumIzMTbG\ng7d1c3CijKKoi9SR67oMzFVoT4R5aijDVw9NLcb/1e2GFVVa+/70VJqK7UhFjdRXEtQUwmFj0ZPe\n0BRCurQ7MDSVgK5QMV1M9/y1aLuCA5Nl1vUG2LZtG67rks/nSafTDA8PL2rEk8kkDQ0N1/Tbezl1\n7C+V+oUA9itx7BeCbp3nXrt2LS0tLTfk+S8F7LOzs5w5c+Yi/xquA9htT/D3B7Nc7icQ1hW6k2Ga\nY0HaYkF+2F9CUV2yVQfT8XCFtHgteoLHTy1Qsx2Cuhy+cFyPtOWha5qvmZYqGENVqJoOhqFKu11d\npaspzEyhhoLA9QTJSIhdvU0cmygwWzJBCLriET70+rV8+/C4dJf0X7XtepxZqLCho4Hf+UofB8YK\n1ByPZNTgrx/YxEfeuBYFOD1fJhUN8PqNrVCcJVtxcd26I6ME66aowf2b27Fdjz/+7imOThYI6Cpv\n2tzGHauT9E0WmC9J64LuphA3tyucmi3z6Z+epWy5RAIa79zRwd1rkyyULeaLJp4Hy1JhlielHO0f\nnxnn8/tGqdoejWGdt21rJyoEv3tnNwVLMLJQJWio/MaeZaQagkzmqnz4B6eZKUiaaTSr03X3CjZ2\nw/Nn88iZIkFLwKaQmePgrIMVNDgyUeCHx+f4g3tWMzhXoWK5i/44pu1iuoIHdnTw44EFVFXh9Rtb\neO2GFvafzfLtp8eZylo8NTfArStk4He+IndPjUGdrZ0xvn54hkLV8i+MCqmGIGVL2kBsaIuyfyRH\nwbeF0FRJp6gImhtCpCI6Y5kKluMR1FXa4iFprOcPktkXLGFXQMV0Kdde2NVomrYI5PjigUwmw9jY\nGKVSiYaGhsV/v5ye++XWsb8U6hcC2K9UdSqmznPPzs6yY8eOq/o3L+VU/1wP97pHe6lUuqyUcanA\nnq64WLZ3KVsYQjo0RgzmSzYzBYujXkFqjw0NV0DZcogEdKlBFyBM6R9T72xRIKiBrisIFDzhETVU\n1jZaHPcMarZH2FC5c00zq1JhKqUiZYK0N4b4/XtWM5Ku8MFXr2JwtsjIQpVNXTEOjudJRQ2Cuorl\nh1drqswVLSxMs/9sHn9wlIWizYe/f4ovvmcnH3njWkbSVZ49m6O5wWAyJ1jVHKKtMcisD5jxiMHd\na1IcmSjwhf3j7D2d8fNB4WuHpvmtu3r53161giOTBWYLFnetSTI+OcHfP3xapgsB+arD147M8KX3\nbOf2lUk+9+QoNdvjvk2tDMyWqFgO3zwyQ9X/zAs1h8dOzvP+LSHCAY3/++03cXKmSMXy6IxLMHrm\nTJaZc5RW567hAAAgAElEQVQxxZrDw/1zfPahTfzlY/8fe+8dLdlZnvn+dqicT6qTT+ecW+pWVgtJ\nVkAmyBiZYGMzGI9J1/FeDB5fxtcLMwZmwOPBXni4GIMNEhmEEBLKQmqp1el07tN9cqqcw873j29X\ndVCr6W7kC5Z5tbRWr1O1a1fV3vV87/e+z/s8p5nI1VnZFeIPdg3xxMHTTORqPDFdoeZS3U9la1y7\ntIMXJgpCsAsJVRH6OP2xACMdQbrDHq5d1sHjJ7P86555TmXr2BY0S02+dzjN26/qY+90GcOyWdcX\nptgwKdZ0t0kr5BQiXpnb1iTxqwo3ruzgz75znJCjCE0Z2WKkK8x/un6I8Wydr+6Zw3aEgUhds1go\nNYj4VZq6TckVaTu/3m46cDRVp7H8wtByvvRutVoln89z9OhRTNNsC3WdPdr/y4z98uM/BLDrus6B\nAwdecWT/QsdYlnXJDYxWxt4q8SQSCbZt2/aqGWaPztdoWLysDCMDugnpik7AKzJuwxK62l63pCFL\nctt0QZIkAh4xoFJsGEKqVZZY3+khFI2TKmtEFJOYorN55XKulWSKdQOvKpEIeqk2DdZ3q0S7eshW\nNb66Z5Y71yfZNhxnOt/gRFowMoY6gtwwEubWER9HS4JyuWMoxut6qmTtMEgVJNn9MLZDpd7gn374\nPCnDyw9Pa5SaFgGvwtoOhVvXRHjv9cM8eDhF07C5d2svlu1QqBtM5htnKJ8SVDUDryrzK+t68Kpy\ne7eQV0R9W2oxkVybvKjfw7o+D69f34N61j0xnmtgWrbInJ2WWqbMqg5xPzw3XqCimcK8utxEM226\no942S6UVEb9KuWly1XCMLYMx4kEVj9eLNxDieKFEw3JZOrbDiYUad/XpbO31cjxn4lFktg7FiAc9\nWLbNI8cznMrU8MoSq3vD1DSz/VksGxquuuNtazo5marh2LiG065BtSThU2U2DsYYTgR4YbLIXKnZ\npsrizgmUmib/+yfTzBSalBo6Qa+KR5FRZJu+qA9FkSnUG+178fy7WAJ00+L743DzdRe/ryVJIhKJ\nEIlEGBkZwbIsCoVCe7Tf4/HQ0dGBYRivGnXylxn7v6O42EU3DIOxsTFWrVpFX1/fJb3eldTA6/U6\ne/bsuaQSz+W8vmHZvDhTxadK6JZzzg9JchunrUZY2Kdi2XZbctYwHBIBlaBPpa6L2ugNKzrpDHmY\nLtapNCwGwgpavcKqoRg/OjBJqgFKZwRZUVgsNvnB4UU006Yv5ue3dw6Sl2y+vX9O0BSR2DtT4te3\nDfDVPTNU3YJrrmbgkWzuHPRw9bpBTi+WWFhcpGvzaq4a6OFzewrMF5vgToduX9pN52Cch1+codQU\njd+mbnE0a3G3ZJIIqLxr5yD9MT/PjRdQAgKEEwEPE05DmC9LEt0RP7tWdlLThI6LYdncvKITgIhf\nplB3J1Nth7BPdRc4kwcPpUGCW1Z1EvML6uLqZFj4pbqgfv2yDiRJo2lYfGXPLKfSokG7eTBK2K9y\n04pOtg5F2TdTwnGgP+7nj29dyguTBbJVg2/sX6CuW3SFPPzpTT1Y7qLjuPUlRZbwdw+xK9pkU0+F\nDqXJ0k6DA7kiM1WH/TPCAxXHoTBRZFVP6Mx9gEPE5yHok/nKnnkWSxqqyzha3x/lZKqKJIn3FPTI\n/K+nJl1nJgfTEhLPLf68YVmMZTShiGgK9k/AI6MoMhG/ykxBPOZVQEISGvBnheMOOR1IW9Q00ai+\n1FAU5WWj/fl8nkajwb59+y5odH25cbkZ+y+C0caHP/xh3vSmN3HNNdcA8NJLL/HAAw/wN3/zN694\nzGsC2F8pZmdnSaVSDA4OXjKoc5lyv47jkMvlyOVy7Ny58xWFws6OywF23bRJlzVK2ssLMZLrX2nZ\nwkdTkSXiQS+dXpOGoxLyedi1qptsVafY0Al5VVRFotrUMQ2HTKXJRMZkJGwz+uJpZqviRdP1MsW6\nRaqsUawLXe+JbI3/9fQkYcmi2HCQJXGzzxUa7J3KU2kKezvBRnFIV3QmSnBkcob9sxV0C/bmTvP3\nb4/wz7+1hY8+eJy6ZnPTigRreyNC1EtS3EVaNEoNCwqFIhE9x2TDx1+daJKtmsQCKm/c0stbtvZR\napg0TWG0/StrOnluPM8/PDvDWFpYt51IVbltSOEPdy3hS3sWWSxrxAIe7t2c5IkTwk7vVKYOwJH5\nCu++boirhuN86t5uPvPEBKNzFYYSfq5bGkevL/DYyQJ7p8uY7kTns6fzrOgKcsuqLj72+lX88Ega\nVYY3be5zna0cHti3wGK5CQgtmX/Ynea3tyT47AsFig0D2fWQdZCIx6KcLjs8MWXTm3dYFrM4sVBG\nNyxkWWTehmURC6isTYaYzpQZ6Azx+zcu4QdH0qQrGj6P2ImdStd521X9/OaOQXTTYqGs8dCRNM1W\nWc9xcCSJO1d3E/erPH1sjnRTfJeOBB5XSmCkM4hp2cwWNcpNHc10pQe8wj4v4lcoNs78XmzbpmHC\n06fy3LX+yods/H4//f39zM3NsX37dqrVKrlcrq3IeHbZ5t/KnPoXIWO/4YYbePbZZ9vAvmfPnvZA\n0yvFaxLYWxZ5tm2zfPnyV02T/ULnOXLkCIZh0N3dfUmgzmVOqh6ZzXNo4cL+kparC6LKMBD34/eq\nLEkEiEsN9qZFc2vfTImVPSFeOl4SdXbbJuzzUDNMHEcwW3IVB69XbdvpeRQFzRJu9jVdlFIkSaJp\n2gLQHNqaMQCxgI+OkJdSw3QbprBpIEyxkuPQvIWFhKJAtqbx1w+f5Dd39PO27QP4VJnnJwrsmykz\nmPBz9UiM2WKTuibeW2dQxh/rpB4K8I2DU2RrJjZQaJg8ODrP7103yEfuWI5HlZkvafgUmT1TRcbS\nNaFtbjuUGhbjJfjwsgSOpJxx7gC+fzjF6Uzd1ZmHTM3gdKbGO3cIfaAdI3G2DEaRJYm6YTOZNThe\nqbta6iKauk1ZM9k3U2K20GS4I4hmWjQMm1hA9Ffqulj0BBsHCnUTSYb33TTC6HyFld0hlncFKTWF\nefVDh9M0DYuJHMx1BFnVm2CmkncHy8Anw5ZIjTVrOjDKDW68biunM3UautgHyDhYtpAlODhXRpYc\nJnNNMQgly8KP3AHTbaorssQLU0XSNRutZZ7iCA38jqCHLYNRxlJV5koaYZ8HxzFxXD2ihmFTaZ77\nWzFs8fq52gXGVK8wZFluG123FBkLhQLpdJqxsTF8Pl87mw8Gg6+4i7+cUozjOD93OQOA6667jq99\n7WvU63X8fj979+49RzHyQvGaA/YWxXBwcJDBwUFSqdQlm1O34lKAt16vc/DgQQYHB4nH40xOTl7y\n619qxl4oFPgv3x49U+s9L1qAHg14mC820Ss6M/k6HiwqBoR8KumyxrGFCo7jkAh6qDRN8g29bZfn\n2A46oNiS65EKDcOk2pTpjfpYLDVdnrfQgen3mOgFhVLDAMehvzPY5kL/y54ZcGBDf5i7+zW+d9xB\nkhVw5RBkSSJb02iawjj6gf0LNHQLRZZY2xvmvq29KFuTjGcFt3x91CTsUwj5PBgWba0ax3HwyDL9\nUhk7leJg1Us4HEEJh4VBhsthb9EYQ54WBVLCct8HgHIWz0h2wT18VukgXdUo1k06gh7iQQ91w2b7\nUITHxwo0XEpIxK9ww7IOZgtinP+ZU3lSFY35YpPfv2kJu1Z28vmfTLvDVO4LS1Bs2iSjHlb1hPC4\nGi4Nw+LwfEXQMF39/Llik3dc3YdHVTi2WEFGfFeeRIDn58o8ftzgL194BkmWuWVFjKBXpqbZOI6Q\nRd7QG+bbB9PiegGxgIeIT6XUEIqcIwk/T43lxOMW2LKr2a9IDMYDfOTOFWQqOgdny4S8MiGfh6BX\nodgwKDXNdinw7HAAw4FUqXnJv4nLDVVV6e7ubpc9zzbSqNfrRKNROjs7SSQS5xAYLgeoWwSKnzew\nd3R0sGLFCl544QWSySTd3d0X9IU4O14TwN5anVOpFKdOnWLDhg3EYjG4AuVFLmNatXWeWq12Wee4\nkCPS+TEzM8Ps7Cy+QACp2jhnIMQjQdCnoMrCpm4638C0bbyKgixBsSFYL4YlMryaZhL0CDBuyQmY\nlthyq6pCULG5dX0PT57MUqob+L0q24bjjHQEMS2HfN0gHlS5Z2MvY6cn+O+vW8/jYzn8qsK9W/qQ\nZYnZQoMP7lpGulRnZm4OX7if25c7jJZMJvN1YbMmy6zvE9TPZ07nqWlmW5p2IltneU+Yuzf24jgO\nn31igpemsmxUmqwNh0hGvBTrYnRelmCoM8TVW9bzPx6f4KmTWWy7ztbuNEtiMn0RlYWqiWVDd9jL\n8pjEeLbOF56bYabYxKdK3Lm2m3fuGGCq0OB4SuyIesJeRjqD5Gs6p7N1PvfUFIWGQcSnctvqLpb4\nZF63MsEL01X2zZSQJYl7t/SxY0mcHxxO888vzHJkoYJtw6H5Cr1RH6/fkOTjbxBTrDXNoivsYXvS\niypLjM6WePBIhnLDoCfi454NPaiyWGBbYmsSkKuZbBmIcMfaLqJ+lbFMHZ8q880DTebrwh0Kx+GZ\niQq7+mF/2sGRFG5dneBIqkqlaQhmjOu9unNJnIG4nzdsSnJ4rsLfPjmB36MgyQ5en1hs7l7fw8b+\nKJ97epIXpoo4DmRrOh5ZZOFeVRELvi3hUbigzMXTpwu8f5eF3/NvX8oIBAIMDAwwMDCAbdtUKhVy\nuRwzMzMA59jiXapM7i9Ctt6K66+/nt27d5NMJn9qGYbXCrC3BLzq9To7duw4Z4W+Unu8CwHvK02r\nXom648U+S8vjdP2WbWgv7MF0zk3YDQdKTaEJ4wDlhoksCxs7yWVmKLLIPnVTOCAJ/1IwDIuIx6Er\n4iNbFyC5NqFw14YkN67o5OEjaZZ0BukMi8/27utHKDdN9k0Xmc03WRIBG5mmYfPMWI4XJwus7Q2z\ncTDG/okMPzicpmHB86lFXj8i8z9/YzNf2j1DsW6wsifMQMJ/Jk92mTumbaOZDk+N5dAMmwf2zfOj\nYxk00+FwVucNpsJvXTPIM6dynMrU6Yv5uXt9Nx97aIzHjmcw3MGa50yVdcv6+KsV8I0DKQo1jc19\nHmRL5y8eOsWJ9Jkp08dP5vjQLUv5f9+5mb/+0SlM2+bGFZ2EvAp7pkp85UUhk4Ak6I5Pncpz101B\n9s9WuGVVJ7ev7cayhTm4R5GJ+hXGs3Xc0jt1zeLr+xZc1gu8dVsfVw/HSUZ9fPnZk4DDYydFb0KS\nhG3h4ydzfOzulfzVD8eYKTaRJYn1fREG4wEs2+FLu2cpNsQu5p4NPVR1E87aBeiOzMZVSxjob9Js\n1KlUKpRKDUzLwaPK+FQFyXJY1hVkdXeI742mCHkVAh4ZVZZpmg4VzaTUEFLJPzyaZs90CdNyqOkW\nAY+CbgmHJZ8qk6labVmCC0WpIVQx77tq4MJP+DcKWZaJxWLt5O5s/9NsNovP58M0zXbZ5pXiFwnY\nr732Wr7yla8wMTHBxz/+8Z/6/NcEsC8sLOD1elm9evXLQPNKDa3PP0bXdUZHR4lGoy+bVr1cB6VX\nipaJdW9vL8PDw/zT89N0R4X069kyqa0zWw6U6gLUcWgP34S9IlvXTcGEuWN9D9WmxfGFElrT5P27\nluHxh0mVmhxfLNKslDgyV0ZVZaYLDUbnyvhUmdet7iLsU/nn3dPM5Ov4VIWhoEnOl+Whw8IZaKbQ\n4FSmhqnVefREnqYl3l26ovHAcegfLrJxIMrK7jCPnUizf7rEqp4g24dipCsalYagIS7pDDHSEeDQ\nQpnnJwptK7aGbrN3usSf3L6cWMCDdta+fyJbEwJWLpWzopn0xQJsX91DWQq3vS6np6fJVxpnvj9J\nfFf5mkEy6uOWVZ0oZ6FTy6KutQi0mtSqLAmtmZBIHBRZoqoJIvqWwRgeRWpfG1mW2tejFQfmytwd\n72Ftl4/D6QZGa/LVFWQr1k1OZxu8ZVs/AzEfM0WNqF/8RL9zcJHR+TKyBJYlADjoVck5Oh53d+ZV\nJOaLTR45lqFhCLrmVUPdVOwypYaObhj0BCUqxQKfOZKioQuTa68qoRkmDR06Iyo7lyT49v4Fpooa\nNU1QL1ufKx7wkAx7mcw38CmifNUSPjub0y4BlmPz7Hjh/3dgPz/O9j89deoUwWCwPW+iaRqxWIyO\njg4SicQ5FOcr8Vq9mC3e6Oho2xZv69atvOUtb/mpx7QiHA6zdu1aarXaTzX74LUC7AMDA5imecHH\nrhTYzwbqlufpypUrLyileSXlnvMjn89z7Nixc0ysy02TE6nqOaBOC9ilFr9aIuhTsG0BPj6PQldE\nZnmHn2g0xlS+hmU7dHlNZLOOJft4eKzK+27q5tM/PkW6omFbFpONNB5F4lS6hu3as/3gcIqBWJHJ\nnNAKMWybsaJDYL4sGnXu7qCpG4zOllFUL44utuq2a9IR8irM5Ot85rHTVJoGEhKbh6J8+s1recOm\nJF94boaQV+Ha5QlRz0RqS+VKkvg/5BNcao8iCXcfl5HTEfKCU2s/P+hT6An7sB2HQ3NlJnN1tg3H\n8Pp89CZkMo2qGNICbNPg8NFj6EM97JuqkKtb7FgSJx70EPDKrOkJMpaqYrvDT4MxH15FwivJ7J8p\n8dRYDtuBtb1h7lrXQ6aqszoZZv+MGBDqCHq4ZskZudZDcxVemCzw+Iks79wQ4palIY7lHZ4+lcd2\n3bAGEz6CXgXHljg4J2rtmQos7QoxX2oKmzZZQkLo87z72kG+9eIEks9PxKvwoVuW8sXdsxTqQozM\nsh1enC7yd7++noeOZpjM1VnbE+LbBxdp6AZNU0gdSI7CtcMhFoo1blrXx96ZEocXKuiWkIbWTDcr\ndxxWd4eEl65lE/IqxAMi0zcskb3XjTMSE0Jp9Gfjn1+uzO6lvF4gECCRSDA4OIht25RKJfL5PFNT\nU8iyTCKRwO/3EwqFLitj/2m2eF/84hf56Ec/SkdHBx/72Me45pprKJfLFz3m7Ojq6jpHFfJi8ZoA\n9ouVNq60FNM6ZnZ2lpmZGbZs2UIoFHrF519pxn72ROz5JtZPnEhRbr78vdsIlT0AVYLeiJ8bV3aS\nq2qEfB4WckUifpVnT+co1XX2TeWJeiWKmoQjGWRO53judB7DNPGoKrab/Qa9Kn6PjONqvTd1k1RF\nan+/hiUcekI+pe3qZNs2PkXmjVct5ZlTOfZMFtzyikPCL459/GSOYl0X2SYOB2ZKvDhZ4La1PXxo\n1xI+/fg4D+ydZ31fhBXdIbYMxnjqVB7HAb9HZmVPiP0zJT7549NkKjoRv8rbtg/w/ptGaBoW49ka\niqxw/bIE86UmX3phlqfGchg27JkqcuuwyifuWcmf/WCcVEXDryq8ZWsvBcXizx6e4dCihg08P57n\nPdf08dYdI6iSREWzmCs1iQc8/OqGHiBLZ0DlWwcXqbrXJVvV+NsnJ1nVE+Kt2/pY0hGgqlu88+oB\nqppJpmowlqnx9X3zNAybE6ka+6cLvGNzgrvWd5OM+JjINbBsmzdsEnLO3z2UZt90CQdBJfz1rf3E\nAmq7RAJCfvnu9T2slRdRe1dybLHKyXSNhVITGzBco5OmYfPYyRyKLOQVPB4FRVUwNAuPKrmvBjGp\nTsaxKOSyTGY0ZFlCdZvVAKt7wqzsCXIyXWe60ACXJRX0qlSazXMy91aYNswVG/ws8WqXQ86nL7aA\nvKXsqus6hUKBJ598kj179tDZ2Um9Xmfz5s0/ky1eKpUiHA63X2Pr1q0cOnSIcrl8USu9ViwsLLB/\n/37e/va3X9LnfE0A+8XiSsokLYmAFl/2UjxPrySzaNElZVl+2UTs6UyN6bzWLge0z+VmQ7GAytah\nOEcXKlSaBs+eyjFXbOJzhbt8ah3dljANE69HoaCDokjtacymqzho2bZLe3QIeiSyNRMkCVUG1auy\nfSTOI0fTIntzHJJBuHV1N5lyk/FMlUhAZdNgQrghbRtgKBFgrtjEdmxW+ERT0nTdl+yWrg9wZKHK\npsEYn358gmdP5bFtOLZY5d3XDfFbOweJBVQmUkU29UdY2R/hLx48yUxBgESxbvLUqRzv2DHAe64b\npq5b7ebgTKHBHlcsTQKKTYsTeeiO+Pjd64fPAZ9D8yWOZnQxoQuUNJtnT2VY48kyVlK4fiBKZG0H\nHtVDXbewbIdjmTrVpnWG7mgI0bQN/cKYZefSBJpps64vgu04HF2o8IAL6q1rmalZTBcN+pMOWwaj\n/Mlty3jsRFZ4qJriGNuxkSSZUsPi4aMZ/vNNI/zjs9PMl5oEvQo3LI/z2IkcM7M6z+4bQ1Ukdo7E\n6Il4mXXr844j9PXniw3XTckh6FMYjgeoNA0MU9Te1w/ECMY89NsFZhsKpmVjWxYhFZAEE+Zv37qO\nyXyD//L9kwS8CrppU2qY6GYTV/L/gpGvG+RruthdXUG82sD+0waOvF4vyWSS++67j9tvv52jR4/S\naDT4/Oc/z5YtW7j77rtf8diL2eIVi8VzNKNisRiLi4tUKpWLWukB3H///Tz99NO8+93vvmRK9X8I\nYH+lMs0rhWmaTE9Ps2TJEoaHh1+1ceazw7ZtXnzxRQYHBxkaGnrZ46mSENuSzmucDif8ZGo6PlVh\n90RBGDyYNqmKTtCrtGvOhYYlrM4U4WepGUKhz+v6kwa9wnDDI0PTsUnG/dy2tpuHD6ep6hYyDres\n7GRFMoJXkTm8UEZG4r4lGtcPeemomSxbtY2qrXJgpoRmOTiOzereCB983XK+u3+e3UfLbAR+9/ph\n/vpHY+SrAkRHEgFW9oQ4uljl6EIFXAlcw3J47nSRHSMJrlvWwcqIid/vQzdtarp1zgKXq4qST8Sv\nUtXMNnVRQkyWng3gTbejmQh6WChpeFVhMKG6te3W6zqA4guxY8cGGscWmM8WOTk+jexYxKIRekIa\nlhnAr0o03fqYqkgkI2dYFo7j0DREWcKwbBJBD31RH6OSy4Zyv/OgV3b58cKAcNeqLo7MV8jXdbyK\nRENumZGIBbHWtPi/717JU6fy9EV9BLwKi2WNb5200B3RFE6XNd66rRfdtMnVDYIehTvWdfGvexaE\n1IQsmt6LFY33Xj9CuiK025MRH98fXSBdMVBVh2jQR1SSKNY1HNthY6fEp77zAnvSkKqL1/HKEl5V\nwnbAp4JuOheWF7Acfng4zTt2/nTv4Ff6nbzaGfvlvF5vby9bt27lnnvu+anPvZgt3is9dilWevfd\ndx/33XffJb9nXivAfjHgvdwySTabZWpqiq6uLkZGRl6ld/jyc9Trda6++upXNPeIBz1iyOa8v08X\nxbbXtA0My8awJFfQy0Fzt8YSDn5FZOiOJCNJMh1BRSg92sLNfutQjN6on+MLFWrVEn969yqOLtR4\n9/UjNHSxCCSCHgHEnUH6Yj5Opqs8cLzE3tRRrtmwgpKp8pHvHKHQECDy6+7Q0X/65/2cSlexbYeZ\np8b54ru284k3reMLP5mmM+zl+mVxLHes/2zXoZYG8epkiPFsjWLDIq5adIVVIj6FbJV21ivLErpp\nY5g239i/gCRJ3LWum9vXdPHwsQyH54W0bsSnsDQm0zQsvjea4sUpYVt275Ze3rljkB8dzzGeFZOn\n8YDKJteQYuNwJ595Zp50xcSrSPz6Rg9H0iWaZooNXQonChaSJHPVcIz/4xYhOlZpGnzlxXkahsU/\n/mSG65bG2TYUY9OAkBaeKzbxKhJLEx6G414cx+HHx7M8sG8By3L41Y093LW+h+0jcZ44mQPHwedR\n2DwQxe+RmS81Ob5YZSJb57rlHYzOlmlaoKhit9IwLA7MVvjwHSs4nqpRqAnuuipD0OdBN213BkDi\nHTsG2nz+f90zR65mCLNqbLJVnWuWxjBtP/1RH0cWqxxd1PFIQptIwsaS3YVQFjswrwKadW4S4riT\n0xP5+hX/Vv4tMvZLbYhe7rkvZot3/mP5fJ5EIoGiKBe10rvSeE0A+8XiUsskjuMwPj5OPp9n1apV\nVKvVV/29OI7D5OQkmUyGcDj8Mjnfs+OxExmWd4c4OFM+x4rMdsQPVTfFWLhpOyiyg+pSHy3LxLZt\nrhkKYqlBJvN1196uC1WCzrCHgEd1dT8a3La2mx/sLfG3T0ywJhlmTW+Uw/OiBq7IEtuG43zkzlV8\n6P5RjsyXMC2YrEMiWed/PjXFQqmBg0S5bvCNfXNsGogylqoIpUhgMlfnk4+M8clf24AiS3ztpTm+\n8uIsK7pDvPf6IVZ1BzkwVxHerAGFu9b38OixDP/4kxlKdY2OYJ2/f9sgv3PtIF94boamaRMPeHjr\ntj4eO5HhUz+eIONm76WGyZ3re/i9G0b40bEMuZrO9qEYZinN55+b49sHUxhuQ/CBvQu8cVMvH7hp\nhIeOpqlpFjcsT9AZ8mJYNv/t0XFOZ+vtkst3jpV44zI/y5f1sWwpFEpl0oUyO5N1tPwcVyXjfOzH\nKSGsJUnYdUFf3D4cJxnx8a6dAwzGA6gyHJ9apGmKxumeqQK6BbbtMF9qolsOv3fDMINxPy9Nl9g0\nEGFdb4RMVePrexeYL4uF/chChS2DUVSXsWO6VoMb+iMcW6jyjQMLGKbNtcsS7FyS4ImxnKDHSuKa\nHpgp89J0EdMWcwoNQ4C+BFiWzXi2wT0bkzgOzBSygtrpVfCpDqbtEA95UCWHVMXEclUeFXfnpZ+d\njTi2cLO6wvh5Zuyvpi1eT08PjUaDdDpNZ2cn+/bt44Mf/CCVSuWiVnpXGq95YL+UMAyDQ4cOEQqF\n2L59O4VCgXK5/KqewzRNDh8+jNfr5aqrruKll1666I1TaZocW6xc2F/SoU1xlCUJRRK/qOURm8WG\nTDIRoC/iYdVwF3PFJvOlJtWmQWfIw+lMg2OLFaqaycb+KCdSVSbzDrJSYTJXJ1c3eH48L7jPisST\nJ7MsFOscna+ALCHLDnXdYvdEgbphuTsioTlS1Sw6gx5sd5JTcsRuqiW5+/DRNE+PZTEsh9OZOjXN\n5Cvf0YEAACAASURBVM1be9k8FCVV1lndE2JJR4D/+tAYC6UmDlAr6vz1I6f5/ZtG+MDNS1BdueGa\nJmRx066dHsDxVJW90yV6Ij5uWtGBT1VwHIexCpzKNjCsVusR5kpNTqaq9Md83LGmG5/rBduK09na\nOfr3pYaBYcnYNgT8Pnp7uuno6GT7qgS7Ty4wd3Se6UxRlILc12kaNlXNxKd68SoK24ZjeBSZbqmC\nono4tLuAaUvt7Xe5aZKuaoyl63xw11Jemi4ymWtQ0y0Oz1dJV3VU16c0V9NZ3hUi251nsibKNpsG\noty2tps/fOAwZV0YgM+VNN5/0zALZY18TScWUFndE+RzzwiNHNsWRuOqImGYYjsU8qskgiq5qi7c\nn4QKkFAH9Yoa/KaBKKNzZTpCKrrtoGkWunUeqAO6de407+XGzzNjv1y648Vs8Xbs2MF73vMePvvZ\nz4LLS+/v7wd42TGvRvyHB/ZKpcKhQ4dYtmxZ22T6Spg0F4sLOSn9tBLRMyczNIwLCH+16sgOJCM+\nlveE8EgORq3E1iVJFpsyB6YLPD1VY6y0yFypKbRJJKH90XC5044jBoIM03K1usV/88Umti24zbop\nSiPzuQqOJLtbd/G9yJJEyKtQaRioiqgdj3QE+MAtK3jkWIZ0Vcdx69o3r+zEsGyeHsuhW25W6MDJ\nVI0bV3SyOhlmdRJqmkXAI1Nosz/O2O2t7Y2QrRqu2BgMJwKcvxGTJQEEa5IhTMsmXdFQFZlN3R5m\nDW9rHgpcL9hURePqkR7SVZ3pfJ2RjgDXLE1wYLbMQMzP6UxdUBGBZNTHzn4vVUW4CM0Vm3QEPTw7\nXkLHT7Kvn6F5mK8V29fHK1nUi1kwQvR3xpjON3hxqkizUiHk99Id9rr8IxEBr3JOvX5tMszyrhBh\nn8JMoSFYSGfdB15V5vZhhYK/DxzoDHt5dixDsWkKMJQkNMPiuwdT3Lu1r12y/MnpPMcWz+gPFZsm\nnX6VaETBHwiwbTDCM6cLfHs01TbDDnslV6ZB5o5VnWwfiXMyXcOnKlQ1g4Zmn/NZWmE6cHKhwPjE\nJD3dXYRCocvqWb3awH45Pguvti3eunXrLkhlPP+YVyNeE8B+pc3N+fl5Jicn2bRpE+FwuP33K6Uv\nXuimOV9+4FLOMVdskHoFASVFFtzwzrDgVUu2weh8BVX1UJyska0ZNDQDx3GYr5QIeGQ6Ql4ahkWh\nZuDzCNEnywHNFAYkOK3mpYVtO4T9KnXNcu3ibDYMdjBX1oX+uauncu3SBOv6IvzzCzPMFhoEvArv\n3DFIyKfwkbtW88DeeXL5HHdvG2Z1MszjxzPtjNh2hNSs16NwzdI4B2bLVDWTbUMxfKpCxK9S0844\nCbWmYEfnSoyla6zri3DPxh7esDHJiVSNdFVHkWB5V4glnUEOzJb5+I9OUdVMkhEfv7tO4g93DXE8\nXWexrKHKEjev7ESRZf7u6Sm+fWCRctNkMBHgf3QE0UybN27uxbAcZooNZEni/7lnFVJ+iq3L43z6\nyRkePJyhrlt0hDz89s4BhjuCvGVrH7rpoJliMOl3dg6gNWsY9QpffGqeQzkHG4meoMw7t3azvi/K\nfFHj0EIZx4arRmLE/CoDcR+//eUDzBWaeFWZ+7b18Rvb+/nB4TT5mg6SRFfIx6b+MI/ucWgYOsW6\nwXoF6rrjLrSt+0wi6Pece1+6uv2elo0gEt1hhfXdXqLROBXdpKpZRH0qhmt8vbQryLreMMu6AvzT\n87M8djJHsW6iym6/w5WvOL/ZD9C0FRZqNvXaJLVajUgkQmdnJx0dHRc0ojk7/i2mPy8H2H9WU+mf\nV/z7fNdXEGeDbkuCQNd1duzY8bKL97MMNbVW+LNr9hcyy74YsOdrOjJSm9rY+qEMxb1UmhaSLJOt\najR1ixMpUXMPSw4T+TqabrW1xh1HTJ/arp+nLJ+hTsqSRCyo0h/3c3y+1DaTuG55B+WGwdMnUhiS\nw+q+BLvWJtFMm2LdILcwwztv20Z/PIAEFOoGAa9K07RYKGmMzpZ43epuusM+vvV0kReniswXGyzr\nDnPdsg4ePrxIw3AIeOCqhMb3dh/nWycaNEyH7rCPj9yxgrdf1cdDhzNUGhrJsId3XD3In3zjME+O\nFbBdo4tsVecdVw/w+zcOcyxVJeRVWdETJBZQ+dDXj7br47NFDbOp8o/rFf7odcsouQYjiiyRrmh8\n7+AiWbfJOJ6t84lHxvjAzUtZKGm8dXt/mzWztjfM/cd0DtZTPHQkQ8MQC0+uZvDg4TTvu2kJqizx\nG1f1cee6HkoNg1RZI5oMcyId5lC+6A78OMyWLX5weJGbl9X56K5BgpGVpN3dSF/Mx397dJyDs+U2\na+LLe+ZY3h3i7Vf1MzpfRZbgumUJFssaz8yZpLUUjgMHZsu8aVOSrYMxTqRr4MBgwsebN/Xwo2NZ\npguCaXXNkgTdYS/5mo4kSfg9MretiHHtgJdEsp/JXJ2Hj2SQXXEy24FsVcd2HP7uySlquoVhiwXE\nsBw80pkF+3xQlxHG5/Oaj+u3L8NxHMrlMvl8ntnZWXB1XDo7O4lEIi8D8Z/nWP8vgmTvlcZrBth/\nmu9pC9hbY/vJZJK1a9decPX+WYaaWvTK0dFRgsEg27dvv+CNeTFgH+kMEvUrL6P4zRZFPVlRbGzb\nwa+2lPWEFrtttRYCB8uyURVRjy01TFRJiFwlo37m3fr1Gzb1cv2KLh57cZQFJ8HavgjxgALVLHev\nirBpxSCH5sukShrDnQFuX9PNX359ij/95hGCXoU/vn05puPwxIkML0zkMWyHbx3w8uXf3s5Urs4P\nJ02aVhaAnoiPNy738NYNUSpOgOXdQa5bGud3vjxK0S2vlOomn/nxCd5+9QDv2jlIoZADWWFFV4D9\nc2IKVHIHX16aKvJf7lpJpWkS8qvIwKqeMCBRahhnS6iQqovFbW1vmOcmCpi2TdOERFClpp97nbNV\ng/V9Qo4gXzfxqzJbh6Lsny2j2+BD6N+3pAZk18GoppkoimDJzBebvDRdbOuxn0hV0V3FRskRBQtH\n9ZOIR8nl8/xw3xg2KsPJOCsSfcwVG+37UpIk6rpFtqoT8qncvkYMuNiOQ003yDbAcamUVc3gwFyZ\nj96xgpemS1i2Q2/UR9O0OLpQpWmKuvvzEwX+4s6VfG3/PI4DV4/EyeaKfODBHB5vhqB6po8hKJqw\nbSjiTpYKUAfRtHVwUCQJ2SNhWU77sVa0Zi7qrhSEJEltHZelS5e2dVzm5+cpl8sEg8F2Nu/3+38J\n7FcYrxlgv1i0gLpQKHD8+PFzxvYvFFdSimkdU61WGR0dZenSpRc197jYOY4tVFjWHSJT1Tkbd1rZ\nu205yC3d67MyesGp9hPyymQqDZJhPzuWJDiRriIDf3DrMuaLGooso5kW04U6h+fLVA2HSFjhkSOL\nNBp1bljeSUciyhefm2am2MSvyrxpcx8HZkr8ZN7Clmo4ts0ffeMIb9zUy09O52kYJo7jMJ03+eAD\nh9AMi4oulAdlSWKhqLGgB9m6NIkiOVy3LMGPjmbEIFEbxKBhOvTaWabzDcKSwsqeONWmgSsjLp7X\nKudIEluGYqw2rLb1m+M4+D0KDkb7uwmoEuWGSSjkpVjX0UyHO9Z20xP10fXEFFVdDD55ZImhhJ+m\nYbN5MMZkrs6/vjTPvpkyy7uDyJJEZ8hDb8zPuLsjCPtU3rKtj1vXdONVhSHJZ56YJORVuGV1Z7tu\n3hf1Cc9VSSKgwKa+ILdvGGT3RJFqwINtmcwUDUovncBn1V0VS2F951MVrhqJk65onEzVQBL19bXJ\nEB4FHEdqSxpHfCqrkmFW9oSw3b/9X985hmaKASmPIpOq6HxndJHNA1E6Qx7yNZ0HT5TE/ILuYNsO\nyaiPvpgfzbQwTIvpfJMXJovtZCPoVWiYNgGPguyys8JBlWrDxHKctpSvAzR0i3V9kQve62fruDiO\nQ61Wa8trmKaJ1+vF6/VekW7Lzxq/BPZf8JAkiYmJCQqFwsvG9i8UV1qKSafTzMzMsGnTJiKRC9/I\nZz//lYC9WNc5la6jX+AttMCqdaRHEfohAa9CxKfy5i197BwK8bWfnGRwsB9FkhhMBHjmVI5v7V/k\nV9b1oEoSf/79MXRTcNqXBm0OTS3SNBxkReKhEyWWdhmcTFdxkGjqFt/aP0/Ep2LaICuIclBFaKs3\nDPMs4w2Hhmbi87RkXRFCUx6ZOzePsK4vQq0pSk0Bj0ws4KHS8u90HNYPJOgcGuRr45PMZkssS+W4\nvi/LqpjDQU2ibjhEfAq/uqkH23H4s+8e56WpEpIksWtlB39+10ree90gX9g9i2aIAaHrkw6FhsH7\nvnmAUxkByE+O5fjHt2/iQ69bwpdfmKVh2KzoCnK9q1kzOlfiD75xlExVlGmWdAS4a9hBkWX+8w3D\nfHc0hd8js6QjIAaQ5sp4FZkPf/c4iy4L6ESqyvtvXkIs6OETb17L3z89hWHZ3NAnc8+mJLIs87ln\nppgtCN3y4Y4Av3fDEJ+9Os4H7z/EdKGJItm8eRlY5TTjaYdvH8yhmzbXLI1z5+o4gxGJyYq4MeJB\nH7tWdvCN/fOcSNWQgV/b2kuxbmDaQmKg5eXaG/MT9CpM5RvMFZuuxLPk6qs7mJbNrWu6cByHbx1Y\nZLogeg1CcMwm4lPoCHrwKRIzJWHi7VNkio6Ded5tXdEsjqeqXD1ycX62JEmEw2HC4TDDw8NYlsX4\n+DiVSoW9e/despnGK8XlTof/ssb+CxymaVKpVPB6vZdkZM0VZOwtt3VN0y5YT3+lc7zS4rFQarbB\n4fxQ5DOMiKWdIbweGcsSo+lHFsrsnihwfKHET6YaMCsEtlr0uLFUhefH86gy7eZkuWGwr2pjOxDy\nqziOyL5m3UEoSRLAXGoaxEPeM1OajqixXr+8k2dP5Zgp1NslryVdQbYMxRlPlSjroCqwvj/KbKHB\nf/3BCeqaQdSvcsPyDn7n2sG2H+iyriBv3tTD//md4xxbFANGR7NAKMnv3BDn+bEU09kagyGHXT0G\n//upUzxyLNOWyv3OaIprlsa5dW03Pq+CT1GwbJv0/Axf3ZtqW+A5wL6ZMvfvnedXNyYxLBtVkjFs\nh76oD9O2+eSj421QB5jMN5jr8DJi2QT9Hj755jUcnq9QdcXQqprFl16YJFXW2k1fofVe5bqlCRIB\nlddv6MGyHfLZDMWGxbOnFpjOnym7TObqPDde5OaVnfzx7SuRgLV9EbAMHh2d5lNPLAjhLgkWyw0q\nDZ3tSS9DPREKDZPfvLqf2VKTHx7JMJauYTkOPzqW5d4tSQoNg3RFxzRtlnYH6Ah5+OGRNOWmiSpJ\neF1NdcflovtdVUrNsOmP+ahqopwV9qqoCvzWzkFOpKvsny4T8irkazoVzeJCUOsADx9J85s7Lm/6\nVFEUgsEgwWCQgYGBc8w0Go3GOWYalwLAV2KL94si23u58ZoB9gvV2FtlkWAwyJIlSy75Il1OJmAY\nBqOjo0iSxOrVqy/ZZPdii8ePjmbOKbG0jwGG4gEcHDYMxAh6FEbnymimxTOncmRrOopUp2HYyDgE\nfBb5mkVFMwl4FEwbDN2kaYgttO2KeNmO2KK3Mi1ZckhGfFSbZtuNPhbw8Od3reQPvrqfkiGMPF63\nphvNsLh9bTePHssQ9CpcPRJnuCNAOZ/ljiFoBpOs7QsTDfj40vPTLJQa4Aie/jOncuxYEuc91w3R\nGfKyaSDCQ0cyLJa19me33GGcv7xnNZuGu7AdMVVbLBbZ/eypc7JDzbR5aarEbWu6uXlFJ7NFwSpJ\nmh4On355tnYiXeOtXoVdKztJu5IMPRFfezjr7JCAJVGF21Z3to0aqprV5tUrrvcsZ+2qZCSWdQbZ\nNhTlh0czBF3DiZoqcyRdp1A/x6kPEKJnjxzLthkrM4UmN63o4IVFC82SUFz7wqbpcGAqx839DqsT\nIdSeELm6TrZqiElaSUKRJKq6wXPjBe7b1kddt6hqFppp8839i6QqYqcgOTAYVVEVGUdS2Ngf4dbV\nHfzLngUkIBJQ2/LBdd3CtmEiV+elqZJgGbnnMnBQZF6WscsSdP4MWjEt0D7fTKNcLpPL5dqqjK1s\nPhKJXPA3/O/R7/RK4zUD7OfHwsICExMTbNy4kZmZmVeVl96KFgd++fLl5PP5y9rqXQzY/R4ZVeYc\ncSUP0BX1kKpo4Ng8WhIZddCrYDnC2CHsU1AUIa8rORCRFXxe2S11nFmwPC4vTbJtZAlWJiTK+EmV\nxdRkMubnznU9jM6VGc/WBV96TTfbRzr4m1uiqF1LiEcCFGo6s8UmS7vCvPfGMDXd5J713RwYPcRY\n1aZoKPzRrmWkKhqFuoFmWkiIhpvjiAGeNcmwkMr1KO3Jx/NBVZXPgOdCoUlX2EtXVxfXr6lzODvd\nNmcOqBDR05w+LXG4oLA/pbFlMMYyCd6xvZfnJ8vk6yIL74362NwfYXS2xKcfn6DcNOkOe/nUm9fi\nAK/fmGQq32gzZtb3R9jYLVyElKbDZ56Y5HS2xmDczz0bk8iSxB1re8jXDOZLGrIEa5Ih7lzfgwOk\nKzo/PpHBsmBZ1OGqkQD3bunl0eNZUmUBsMmYj+3DMSwbKprJ6UyNmN/DsVSV3qiPgEdGM21kSZiG\nD3VHmazVODxTQjcLhFSHrb1+LFu0mR33u7McXDqizFDCy3CHn28fTCEhynheVcarynz8dX2sXdpP\nvqbzZ987Sa6mo1sO9WydsFfBtB0CXhmvIvPQ4TSmLXodJg6mO59A+wqfda8DQ4krm6a0LOuCyZIs\ny8Tj8fb4va7r5PN5ZmZmqFarhMNhOjo66OzsbB9/ucD+86jrv1rxmgN227Y5ceIEzWazTWV8tQeO\nOGvhaHHgi8XiZZ3jYsC+a1UXL00Vz/l5OBJkqoagLbZEs2yo6hY+V+irYVp4VTFIZAuRb3TLJh70\nYJg2luMQ9MhcuyLO+HyOYCjM0p4o63w5yoE+0TyTJJJRH35FZufSBNtG4qiyzA3LOvj0oyd57kSN\nq5dlecvVw+RqOl/dM0umqqHKMjcuj9NRm+br4zIvzdXQDIfj/3KA990kdkvJqI9ZV8bVdsDvUdg9\nkeepUwXyNYO1vWHuXNvFtUvjPH4yR6VpkQgovOe6IXaPF/jzB09QahiEvCq/f+Mw927p42S6ypGF\nKiBx1UiMd90ywj88dZr792dp2vDdAyl29kt84s3DfOSOFXx17zw+ReL1G5KossQnHj3NybQo0cwU\nmvzJt47y39+ynkxV5wO7Rnj2dJG4X+H9Ny/hm0+PsqiU+MLueSbzTSRgLF2jqlu8ZUsfb9iUJOSV\nefZ0gVhAZftwjJPpGv1RH/+yZ5Z0xUCSYDwDvfEgWxx40+YkT57ME/DI/MltS7EciSdPZPnmwcU2\nNXOm2GDHSIybVnayZ0rIAKzrDXPdkgh//0wZ3ZHAkaiYEiVLpSNgkKoIh61wQOa3tvfQ1xFkItdg\nJOGnN+ojHhSzApZt09AtqqpNzbD53mia6UKdiVxdKHLawqZPlqEv4qc36hXMIrcmb9mOq0l0bnPb\nOevftgN14/KE+Nr3veNcEhh7vV56e3vp7e1tl0ZzuVxboTWRSFy2vvovM/ZfgJAkCU3TOHjwIF1d\nXaxZs6adob5aDke4F3tsbIxarXYOB/5y6/IXe36hUGQg6DBVOdMkNc8itIt7U2RGMhD0etAtw83R\nHOIBFdsQPpcBr8KuVT3UNJuaZtLptdFrRT751i1kNJmgR+Gx3RmOZAqs7Y3SF/Mznqnx5FgGRRbK\nf5+8dwN/8eAxnj2Vw7IcZiopsnWTUkPn+GJFlMFsm4dGG6x73VL2zU8LD0wJ5osNHjqS5m1XD3LP\nxl5MG2pNg6BP4a513Tx6PMcLk0UMy+HgbJmZQoO/uHslt67uYmYxw8beIGuWdvAbX9hHqiLonk3T\n4PM/meENm3v509tWcCpbQ0JiXW+IsN/D05M1mu4XZwKjGYfDx0+SUCR+bWUYQxUKjauSYWF/d1bM\nlZuEfSo3rehgOt9g80CMZV1BXpwsosoOkiRTqAuQclzQqjZNfmVtF4blEPAovGHTGaPhVFljJl8n\nU3EpmI4QyzqaqjM0V2ZZV5BlXUF0w0aVZVZ2BfmL75+gVDdEs9N22D9T5l07B/GpCjuXxEhG/Fyz\nNM7B6Zxrzi0L1pAkISkqD7x3J//0/AyZisbyKEzNp/jsExNUDUE9WtIZYDDu5+hChZpuEfN72JL0\n8qmnF3AkhTXJMH5VptwU7laSI3o6HkX0AWSnBbgSQTeTj/hlLFsMPjXPL8XIEkfmr0x76Urq3JIk\nEYlEiEQiLFmyBNM0KRQKpFIpCoUCo6Oj7Wz+YrosvwT2X4DI5/McPnyYNWvW0NnZec5jr1bGrus6\nBw8eJJFIsHXr1p/JHu9CwG7bNseOHSNTqrHQ4GXKjmeeB7IiJgJlWWzLl3YFCagyGwZibB2KsPvQ\nKVYuG8Z2HGYLdUYSfiJY7JsqMdUM8N77j7M6GaZhWOyb1HGkIvtnylzrjtQ3dFFfnys2+YOvH2Y8\nVxP5l+SgWTaH58rEgh5kWewOHABFZbxstRkyjsvZtm2HXau6aBo2b9rSjyI5vDiRI18zmMw1MM/i\nPp/O1okFPOxa1cV8WMe2beq6hW7Z52SETcOi2jTpjvjoCp+7VTesc785WYKuoeUs74kyn86RzeUw\nKylqThjveaXYiNdDuWnQHfaxrk9lMtdgMtfAsgSrxKdKqMqZgxyXmSRJov59jrqh46AqMvGgB68q\nmrMtLRm/R0E5C6+8rpTCKvf5clGIR8iAadn4VJlVyRAP7FvgyGKNrrCH+ZJGyCNRNWyQZExLlKR+\ncDjNjSs6UCWJg/Nl9kw1qZgSFg6S7TCeqbMsqHPNgI+qpbBtpINv7Z1lsWYhYZKrGYx0BARIGzZR\nv8qaniD7Zyri2srgR8bj8t0TQRWPqtDQhdTC2dG6/tr5hfdLjFejgamqKt3d3Xi9XlRVZXh4mFwu\nx8mTJ9E0jXg83rbGOxvIr+Tcpmnyuc99jkwmgyzLvO997yOZTJ7znOeee47vf//7yLLMhg0beNvb\n3saTTz7J/fff337upk2buPfee6/8M1/xkb9goes627Ztu+AKfCXALknSORf21bbHk2UZwziTLbZ2\nG93d3cxpDZrmhRXxPLIYiAl4ZEJelVjQy8aBKMmIj6ZhccOKLv7p+SlOL5oU5Dwz+SaL5SaSYzMc\nU6nZKsVGA9tx2DNZEDVSB8JeBQeHqXwD9awGmITEYrnpDuW0YEsA9mDcz/EF4cOpKApdYR/LukL0\nx/1M5sT7D3oU3ri5j08+MsYjx9IA3Lyyk3ft6Ge20ERxHblbUKnKEpPZOmXNJJerMxRV6e5VGUgE\nmCtpbWu7noiPzrCXXFXn/2PvvcPsOqt7/89up585c+ZMb5oZjTRWGXVZtpFl3DE42CbGoRkCgdBD\nICEFboCbdkMwIXBDQhohCRiCKbaBAC4ytuUmWWUkjWZGmt7b6X3X3x/vnmPJllWM8wvXYT2Pn8ea\ns0/b++z1rnetb/njH58kV7a4fWsTN22o5+o1Mb5zeI6i6eBVZboiEn5V5k8fGOWJkaQQzGoO879v\nbOXOLVP8y8EEugVVfpVbNkQJaAoT8QK/f+8go/ECiiSxrinE9moHVZa5anUND5+Kix1Q0MPurhp+\ncmKRNXUBHhhYYmA+hyJL3LCulndc1sbBiRTrm0IMzOcwLIdVEZX3X97MQNKmb1ogmWwH7tzVwqGp\nNC3VXgbmJAzLxpagJuhn79Aydz87S6Zkokjw8OAyb99Rz7WrvOxfErK9dSEvN62v5/HhBP+wbxJw\nWFUTwLCEaQe2hSQLTaCqmlqCksnQXJaxiSkSBaviWeo4kCubvHFrM50xP0+MxHl8NIUmC8E5VZap\nq/JgO5As6EwmS67KqETZeuGcyXQgFnhpqeblrJpXXmsFadPW1oZt26RSKRKJBGNjY6iqitfrRVVV\nTNO86Pfet28fgUCAP/mTP6Gvr4+7776bj370o5XHy+Uy3/jGN7jrrrvw+Xx88pOf5MorrwRXGOzt\nb3/7y/JdXzGJvbGx8UUT60vxJF2pqGVZZmZmhsnJyZfVHu/041cWjZ6eHmpra5m+b+aszwloEp21\nIYq6yeVdNSzldBazJR4eWESRBUHnx/3CTs8wHJZHk5iOoHwHPAqjKRMkE6/bPrLsM5mCiiLjd5Eb\n8bxRceGJhTy0VPs4NpOhpFt4NJnbNjew2pPixIxK1hDDt/fu6WBdQwhjZyuPn4ozsRDn9ss6KZoW\n3zk0S8EQ1NjvHp6jrdrHVWtiLGRK3P3sLImCSW3Iw2UdQjvma89ME8+V8WsSb79M5o9ft5Y//8kw\nU6kS1X6Vu96wjqJucee/HmEqJfrd/XNZdNPmd69fTSzk4fBUhlUxP6u1DH2zef6zf4mSy5x5dDjB\nl6u8/MEN6+luT7GULZPLZqmRc/zsqQP8cELixLxeqcAPTaZp0zS2eWVu39bE+65s5+BUBst1KQK4\n66ExnnEXS8eBBwfj3LS+jrLpcOfOFuazZUqGTbWVoqHKw2i2zPePzAv2qwNfemSct13azJXdMQKa\nwom5LK1RPzvaq/nZqThptzViI5Eq6ByazrGhWuWd3c0k8zo1QS+TySJPjycrSpYD8znWNQTxKBKW\nJT5XLKTRGg2wkNXZ2h0UrNCpKWTAKzsYpolkS7xmTZCOxhhPjiUJeRV008GRhGxvW7WXZ6cyYqF1\nHCybCiro+aFIkHu+7OMFxvkcjy72tZ6fqE9H0+Am3hMnTvCDH/yAxcVFhoaG2LJlC729veflpgAc\nP36cPXv2ANDb28vf/d3fnfG41+vlrrvuqhSg4XCYbDb7sny/0+MVk9jP53uq62cX1TrXcwzDqDiZ\n79y585xY2ZXjLzRWEvvs7CwTExNs3bq1YnslBqBnekhqEjRVeSjqJks5nfv65vCoMtmyheoaQu5H\nUwAAIABJREFUPud1IRMb8qpYrgykZThEgmqF7GRZYCuua5DLpEzkSpi2iewodMT8vGFLC5+8/wSm\n7VAT8PC6jY00RbyUDJsnjo9yw8YWfPk5TpbCfOCa57DJlm3TWRtkOa9TE9AozeW49YoO/ui+E+R1\nl4QkCaekw9Np3rKzhd+8soM3bG3m5GKe+rCHE3M5vnlwhrm0wPGXLYdvH5zlts2N/N9f23jGOfzJ\niUVmM6VKtV/Qbb5zZI5bNjfyrsvbKO4QZJyRoQF+OleoJHVcGOXIUp543uCyzhoMy0aRG5EliQMT\nSZyZCRz0M47Pmzbb2yIVlEV9qkT+tIS1kC1XLPkkCRazZWYz4jUkSaKpyoftOBSTGQzb4ZGTCYqG\nVUEBJQsGQwsFWqMBtq+q5pLGMLVBjbxuoSkv/H1rMkxnLH46Po0iS2xsCVMybHTTqbBMddNCtxyu\n6Ykxly5T7VfZ3FrFD48vVgTRehpC7Gn3c3DBpGw5NIQ13rm9hr96eIRCcYClskOyJPR1SqZA3Gia\ncOuy3OGmB4ey5aC6c42VkIDqgOpe9+eExy40Xk4s+YW8ltfrZevWrWzevJkDBw7Q3t5OX18fw8PD\nF1RNn26BJ8uymJOY5hm5YyWpT05Osri4yJo1a1hYWGBgYIA/+7M/w7Is7rzzTjo7O1/yd33FJPZz\nxUvtsR85coTGxsYzBrEvFhdbsUuSxNLSEj6f7wWLxlXdtcwmpzFtUR2tJPmReBlpRZ7WoSJQZbie\npYosnaEt45NsZK+C6RKNwj6NtmiA8USeKp9KR02Q9+5Zxff29TOYUVnXHGFdY5iReJ4v3dHLQddQ\nOeiRqfKqDM2lCKkO+46Pcs3Wbn68b56CnqW52seN6xvIly1+/WsHGVzIIckSa6osXn+tTVddAL+m\nuElBDH976kPols33D8+RLpncurmRiF9jYD5L2bDPQFbkdYt00aAmqLlGI+JaBD0Kqiyhuyugw3OP\nlU2bmVSJWFBU01d2VfO9o8tkXF2agCbw2vmyyWefmuLUYoGmiIdPvmYNfk3h0s4ox+cLpN3ja/wK\nmyIW9z/6LFWRML5AFc/OGwS9GmsbhDJoTdDD8FKh8rmrvApr6oKMLBfIlw3yuoXtwCo/PHIqheH2\nxHGvjyJLVAdUZtMlvn9knpJhs7ouwJVdUa7srmFoIcd8RkApW6r91AY93N+fwrAkNFUmnte5em0M\nv0cMMmVJSB68ZkMdr+9twKcppAo6e0/GWciIRais2xycTHN9p4fdnVUULJloQONLTy4K2WhH6A1J\nOOimjWmCKjscn06jmzYSjihqHAGdVWUJ23pOXtgBsiWLXav8lWtzMfFyJvaLqf4ty0JVVdauXcva\ntWvPeszDDz/M3r17z/jbqVOnzvj3i0Gg5+bm+OIXv8hHPvIRVFVlzZo1VFVVsW3bNoaGhvjyl7/M\nXXfddaFf7QXxy8R+lkilUqRSKXp6es7qR/pi73GhiV3XdYaHh5FlmS1btrxg0fjw1V38uH+OhYzQ\nJT+9bXn6oWVLuObYjhhoqrYkoI2GgeRAQzTIHdtbuK9vHgfYuUqYTmdKBm/b1UbE7yFXMon4VF7X\nVkfA72MqWeDRk3H2Vnl55+XtbGmL8KkfDPLI0EnKhkXEA2/d2cQfPzDFbLoISIwnCpQMC5+m0DeT\nxnEts48uOtx9YIo7trfSP5vj6fEEOLCjPcKbdzTxlq8eZngpj+3Atw/N8Y9v2UR7NEBb1M94vFDR\nG2mu9lE2LP7q4VGeHE3iUWQ+em0nl3dG2dgUpm8mi2k71AY1PnFjNycXc3zknn6W8wZ+VeaqVoU/\nvDnEh/as4t/3z7jOUBHWNYX520fH+clgvHJOx5aLfO0dW0jkDW7b3MC+0SQBTeY3d69i4OQIdY2t\nPDwU55GRCYqmwM5f1hbkpo0NfOqmbj5x3xBTySIeVeaatTFOLeXZ013Db337OP1zWRRZos4Hb9kZ\n4sb19UynSkwming1mZ3t1fQ2V/GlR8ZYzukoikxiPIVHEa2v3766k/lsmaBH5aYNdfz1QycxTdA0\nkaxyuglI/O61XXzz2VmyJZM19UFW1wb5A3de4FVlavwqJcM+zVzcYf90mVs2RwkH/RyaSpMsmPg9\nCrIso+sm9WEvW1ureHYixXJeJ1U0wHEwHNBkwU/QZAh6FfTCmdBG3XJcrZr/3sR+Mf36Czn22muv\n5dprrz3jb1/+8pcrVnemKfSTnr/Tj8fjfO5zn+NDH/pQRa99hXiFa9iRTqd/ru/+PyaxX2jSnZqa\nYnp6mtra2nNa1z0/LrSPv0JqamxspFQqnfXHvvfkErmyfVZUjOTCxyRXYbDKrwrtDp8KjsP17QoN\nkTBHppKsaq9lKafzqu4YqiyGcT86Pk+VT+PVawp88fAIjw3HyeZLRIIGN21o4ntH5siVTeYzJT7z\noyF+44p2HjsVx7CEBEHagJ+NZkkWjIqbzwoB5xJXeGqlMLOBwbkcwV0qd92+Ed20UFw9mbv3TzKy\nJAStZEk8/wt7R/nSHRv5X6/p5u/3afRPJwl5ZH7/tZfw0xOL3Nu3UKmgf+/eQf75rZv4p7du4qcn\nFlnOG9y0oZ76sJe3fu0w0ymxuykbNo9MWrwlXuTNO1t4zfo6RpYLyLLEuoYgX3xk7IzzO5kqsJgt\nsbu7hu3tET54VQc+t989JIOmKByey1N0c1fJhJGETquUZH54lutXeQlvbCQcCiHLMgXd4juH5jgw\nman0oFMFh4PTea7qCfGeV7UzlSiyu7uGzpifuXQZGyqMVkeSmEoW6a4L0hTxsZgtMzCX5aHBZcqm\njaKIndvKaycKwonqlk2NeFSB1vncQyPMJIsVyQfTcn9b7rXzqQrVPpvZjE6LqgnlytPOiai0Hdpr\nhNa93yNYql4PBDUJFZuibrBUhHjhhXh1VRbX96XEy53YL1T75aW+7+bNm3n66afZsmULBw8eZMOG\nDS845itf+Qrvfve76erqqvztvvvuIxaLsXv3biYnJ6mqqvq5vvcrJrGfr8dumucmSNi2zYkTJ7Bt\nm0svvZShoaGXDZe+EvPz84yOjrJp0yZs22ZycvKsx/3w6Dy58tkXCcsRFy3k1/AoEh11Qba2VeNY\nJhPTs1y2tpWJnEzYk2J0qcDAfAbTdljXEGA0XqKoW0gUee83j2IYJoYj4diwnDf4ft8subKJqoje\n4FK2xDefnaJQNlBlsF2hLssSZtemDYpLhooFPdy8qZFHh+OUXT/WkAcuaQxxX98sPz2xiF9T+Pj1\na6gLaRTL1pnZAzDc81cX9vK/blrLwsICpVIJr1fl8FSmMjwESOQNfty/yIdf3cnrehvPeJ3C8zRL\nTBsWczrrgGjQw47T6O3K824eTZYpm4J8E3yepdvKtvr5u2tHVuhYcwkBTSZ+bJp4Ms3S4iKKouD1\nhxjNOm7bQoQNFS2g5WyZbNlkLlXixFz2OcXO06CiHlXmR8cX+VH/IqmigSbLvHZjPevq/PTPaszm\nbRRJoi3q56o1Mf75ySkmkiWiAY1remIUdYsKL1QSyJWdbVXMZMoossSm5jAP9s8zlkng09J0xwJE\ngx4X8ipMx69eE2MmXaQ25BEqmq64V6ZkC81/FISNyAt9lBwHgt6XlqRe7lbMihzEf9X7XnHFFRw9\nepQ/+qM/QtM0PvCBDwBw7733sn79ekKhEAMDA2fM426++WZ2797N3/zN3/Dggw9i2zbvf//7L/q9\nT49XTGI/V5yvYj9do33VqlUCk3yR7ZtzJXbHcRgeHiaTybBz5040TSOXy73o8emScSZ9zw1VgoaI\nD02G9poAlm0zulxgKV3ERwld9vOne2cpGxayZWHISXB78c9OZFAVmZDrTqQbJqbl4NVkTFfaNuJT\nRQKSJcqGjeOA3y5R5VNc/RmB1d7cHOJ1tVX8+/5pknmdkE9jS1sVq+tCvHt3Bz88Oi8q4lCZkmHx\n5UfHyJZNHAcOT6b5yxvqWBvSqQ95mM/qYufhU3nHrlaOz2b51A+HKOgWDUGFP9hdQ4NfJRrQzjAe\nUSRojvgwLJuHBpdZzJa5ak2MjliASxqDjC4XKseGNInOmI+jMxm+sHeUbMliW1sV79/TwfuubOcv\nHxgh7bakrl4Toz7kYTxR4LuHZvnZqQQeVea6nlqwhUBaV22A5byOaQup5Pqwh5+dSlAb0giHQ9x9\nJIGq+Lh+bQ0bojaTy4v4FEFMcoAqDW7ZWMvx2Yy7CzG4R1O4cUMduzqi3NxbzwMDy+TLFtUBlTdu\nbeQbB2aZTq4Ihtn89MQi79pRx6s7/HhDUTRVpiag8dRYisdHBaRzbNlhMVvG6w7jV36LXkXm6ktq\nkRxIFA0eGlzGtCHgkTFtm7FkkS/86rrKcLdvJsN/nlhGcQegsiyTLZnCRNsRw9qV/vnZOsqWA6s8\nOYaHh6mpqaG6uvqCk+bFWNmdLy4mWb9UOYEV7Prz49Zbb638/9e//vWzPvfTn/70Rb/fi8X/iMR+\nrjZJMpnkxIkTL9Bov1jC0Ysdv2K6EQwG2bZtW+VHeq7PtKW1mlPzObKnIS68ClxS6yMY9AvYoZkn\nWzIwTJu0BLKqYFol/B4Vy7YplEFVbHyqwC3LkpDX9WmyGNQhoWkylrMiXCVxy+Zmjs5mODiRAhxi\nXofrNrSA6uWRk8vUhbzsqLW4obeZ2tpavJpMrmxTExRV3MHJFO+4rJ3btzWTKhhMn+rn2xPpSlKX\nkJhPl7i/P8G7L2/hd3aU+MYxHVtWuXN7I1tawrz+7w8x7yokzqbhs4/bfG1NFx+7rouxeIHxRBFF\ngp0dUW7ubeD3vn+CJ0eTFAyHf35qmr+8pYc/vrkHWZI4MZ8j6FG4o1vCQeLj3x9g1kXbTCSKWA58\n9JpO1tQF2T+Roj7k4dKOKCXTZu/gMt/rW6wMW2eSU7y5R6O9xs/vXtfF02NJnh5PE/YqXH9JLZIk\ncXAizT2H50kVDHdoaHLjm3vZVPahhbPsG0lgmRY9YZNmZ5l/GtLJlk1kSSJv2OwbTrKrI8q6xjA7\n2qtZypbxuyqLJbdHvUL8Kps2pm2TKNjYVpmARyEW9HBiPgfOiiiZaIH82vZGDk5mWMjqqIrEr21t\nZP94isWsTpVPpcqroshi9yJLwqz84cE4l3dF2TeSYDJRQpMlsrqFR5FoCqp4FUgUTLHYS47QojnL\nb1mVoDqgIYViVFdXs7y8zPDwMD6f74LYn/wc1pfPj4sZnv6/rOzIKymxn68V8/wk6jgOk5OTzM3N\nnVWj/aUQjp5/fD6fp6+v76ymG+eq8N/9qlU8MrhIMVkSUgKu2/uxhRKKJP5mWjaGK7Ma9KqUrRUE\njYSsKChYqLKEqshoiqtjrsnkXO3zWMjD9evqeOzUMqauc0VXlM7aAF31QV7THeSnfVPsXNeO3+fD\ntGzee2Unu7tjQofHsPjLn57k4GSKjc1ChqBkWPzLUxP87aOjeFSF9+zuoMUju+JergCCI0yy6+vr\niNXVcYknwv9ZB0FJZ3l5mb1PHSZVeE72VpJgPicSa1OVj2+/ezsjSwVkCbpqAwwv5dk/kaZoOBWb\nvr/aO8a3372dP3v9JZXz2d/fz8GpTCWp4ybKoYUck8kS6xtD9DQ853l7Yi7L6HKhktQB8oZDf9zi\ng/VBgWKoD7FjVZSp5HOyu0+Pp0gWDOH9CZxaLHBwKoPjSGxvj7K9PYrjOMzPzVDf1EzBGBaaPtKK\nD6mFYwuS2Gi8QEBTWNsgzKyr/RqL2TKK5BLKvCqHZvI8O1VAd4poikSqaBDxqcRzQh9dlSVCXpXr\ne+q4Y3sLNQGNsmHxvm8dZ2Q5jybL2I4tjFcsMHQL27Kp8qvYDjwwsMREoiB09d3rISzx5IopuSJL\n2LaEjUBvydKZ6o4OYFoW0aAQbqutFQ5QhULhDPZnNBqtVPP/VTT+l3t4+oscr5jEfq54fmK3LIv+\n/n5kWWbnzp1nvYA/bytmxcS6t7f3rEPYcyX2mqCHsN9DIKeTcav2inuSm+hLpriRHNeYWEZod6z0\ngf0e+I0rO3hyJMlCtkRPQ5idnTWcWshRNi3ev6eTVNHg9ZuaSM5N8uyyxGy6yP6Ts+RLZd6xZx2T\naZ29A4sMLuSI+FXu7ZulxVvmJ8OLLOYMkCRGlgU+fDSeZypRFNKvjs7nHzrFe3s1PnZND4cmUyxk\ndLyazJa2apoiXj7wrX4GF3IoMuxaFeX/3NJDc3sHnzu8n1JeiGU5Dngli0QigT9UxYm5HB5VZkNT\nCEmS0C37BaQY67QGuGHZlfPV7KojFk/Dsoc8Cn5NZv9Ekv88vkhnLMBbdrYQDWjUh734VPk5iCZQ\n55c4Mp1BkmS6agNU+1WGFy1Utxdf8dSt+MoKbH9rtZe/fXyCgm6zuSXMrmqJJ6eLtEQDLBeyrvuR\nQ0NA4kD/SR6acsgZAlu0diHA79+4hr+4pYe/3zfFdKooJJRfs5p3//sRioaNoshYtsSxmSw3rqtl\nOlVy+QwKXTE/PxlY4uBkmqBXYVtbhOVcGQlx/mxX52Vjrcyy4SFTMqgJern/2Dy2LfT/o36NtIuC\nkSQJy7JxXDSWV1GQcLCAupCHom6RLJqnXQ/hinX71jMLm9PZn5ZlkUqliMfjjIyM4PV6K/Z4F2uO\nca642Ir9l4n9FzxW0AAAxWKRvr4+mpubaWtre9FK/2Jx6SutGMdxGBsbIx6Pn9N041yvH8/rpArP\nJfWzheTqxFi243pvyjSHPYTdJNPpc7htcyOv3djIU6MJCrrFZKKA7Ti0VPsoGhb/uG+CbMnELBfZ\n3VXNV/eNkihaSMikfjbO+/d0cmxO4MrTRZPJRJGdzT7iBaEyqbk6MQPzWeHk5Hqs2ragpJ+Iy9SM\nLvDxLTBkNuPz+mip8XN0Os2hyVTF/PjhoWW+ss/P+65cxQf2rOLv9wkRsZAGH9rpZ2x2kT988DgL\nBYGwWN8U5p/ftolLGkI0VXkZXhaKkR4Frl5bi2k7fPQ7/ZxcyKEoEnuaZT54XZDX9zbw4xOLGJbQ\nm79jezPPTqb4q4fGyOlCDfHRU3H+/i2buKYnxsB8luNzwjx6c0sVzf4ciYLBct7kD+4fxLRsgh6V\nN25tYk1DkD+8YTUf/W4/s2kdVRYerGXT5vN7xzg+I9iF08kCuTaVnWsU3rSjmVhwmalkie1tVfzO\ndav5yD3HyZST7lV2GFrI8+jRUaJVYba0hHjN+lqu6Iry2HCCvC4WLsd2UB2LXFmiNerjN65o5ZSr\nKmk58J3Dgt1q2zYDCzmqvIJGJEtgOGI4uzaq8qrGeh4ajDOZKrm2fAJG2+5XaYv6mEmVSOR1lguC\nlVwb8qBKDvG8oNouZ/UzmMwrRK2wV2V0KU99+OyDS0VRiMViFY2nYrFIPB5neHiYQqHAyZMnicVi\nP3c1f7EV+y9bMf+PRDweZ3BwkPXr1xONRs95rKIolMtndzE6W8iyjGma9PX14fV6X9TE+vTjXyyx\ny5JEsvDiLFaPDB5NQZMlNjSHqQ0J3ZSZZIm1DSG664IcODbIB755FFWRWFMfon82y1RKiFmFfCqP\nn4qzkBVbdsMwmD2ySMGSUBXROplOFfn6/imKrp+ojfDCXMybzw3iXKyFX1PorA1wajHvIkYcqnwe\nIorJT49NE6iupT3m59cvb8fvUdh3Ki5cjyRx4wvHpiIT8QJv3NbMazfUkyubWMUMpXyOr/brzBWo\n+Lwem8ny+Xuf4de2NfLl27r44hMLxAsGV66u4e27Wvmzn5zi0VOJyiDvh3nYfUlW2Obtbmc5p9NY\n5SUa0Ljjq4fIubRcy4GTi3mOzWbY1lbNl9/US9kUVW08b/DDJ/tQZIn/ODTLvMsojedN7ju+wPcu\n3wHAx67p4vBUBr9HZkNTmJGlAiOLeWT3pGXLNscWTS5dI67zjevryJctruiKspwrk1jZrZx2vRO6\nwuREguOLou1zY0+UWHWYNbU+Ds/msRzx2btqA9gOld655cChqTR5XaCEJCBXsljfGMayoaCbaIrM\njvYqnppYQl4WyCXb1YZWJImoX3i8vmFLI998dhZVkSkZwqwjU7LwaXLFN8C0z0TEOC4iRpEkqvza\nBd1HuMzM1tZWWltbeeaZZ6itrSUejzM6OoqmaZVq/mLt8f7/GJ7+osQrJrGf6wI7jkO5XGZ4ePiC\nPE95Ca2YcrlMNput/CAv5PO+2Daz2q/iVWVyZesFKAOvIlEb9HBZV5ShhbygyUvCTq9/LkOyYFAy\nLH4waiLJopKdTZcp6iaKLKN5VLGriBfwagrYNqbFaYM5sRNQZOGPyUqrR5KQZOiIevF7VPoXhTBY\n0Kuyq7OaWNDLYrbMWLyApkjsalQYi2d5Nq5gzCwiSUscnkrxlbds4TUb6njk5BL5sjBGjvg1NjaF\nKZQt7j4ww3iiyE3r62jzy5SATPE5mKPkwgV91fWEQiGWlxd4Q3OWcDhMLObBNE1OLubPOG9ZA8YS\nJXaviIcFPYJNKUkvhC4C5mmMMI8io2gSmZJZabEUn2dGmyoYnJjLsLouRH3YS29zuGIt59VkVEWi\nZDkV3HhQg6Jhs3d4kfFEUTBdV0WYSpW4cUM985kyqaKB40BXQwCf38+DwxnKhlhg7zmW4NWtWXqC\nNr4mhaTlpT0miEhfPzDDdLKE40BHzO9W5y5U06X+Bz0Kt29rRJNlblxfy3u/eYyFvIPPMsUsxqci\nIQypLVv4vT44uMRUsliBaWqKTMm00C1hDSjgr2cvVGIhD+saQ2d97Fyxgog5XculVCpVWjalUolI\nJFKxxztfIr6YZP3LVswveJimWRHbv1DPUy6yFbOyE/B6vReU1DnPQiTLMld21/CDYwtnDKJqPNBa\nG2IuIzTOJQQx5eh0GkmWiPg0ZtJFjs2kMS2HoE8MLfNlE9txCPvF5S7pppDbtSxXVxvaIl50FOK5\nMrIrKHZldw3VAQ/HZzPIssT29ghrqmw2NKm87fJODk9laIv5KiJYr+6p5cNNQX6yf5CAX+OxccV1\n7pGwHDg4meJfn57kup5aPnxVB986OIsiSVx3SS0Bj8Lf7ZusCFj96Pgit6yv5pZuD7dsamD/RJqC\nm1BjIY3d3TGSjsbnDhqkigqtVQZv7EkSmJrCZ5+50/KrsLbOT0G3+JMfn2Q6WWJHe4RdnVHesLmB\nv35kXPSq3aHs+qYwQws5Dk+n+eExIbD2jl0thD0Sed2iyq8x51bsDkJpczJZ4kuPTDCeKKBbDt21\nAW7f1sRrN9Tx6Kk4R2dzmKZDNKhxRYvKZLLEEy4sEeCj3x3g967voiag8Zu7hcCYKku854pWPvOf\nw5RcmQUJiZLp4ASiBEIWrUqRZsdhU1WSxyfTTCbKyJJYTOZSJS7d3MhirsxS1kCTHNY3V/Gxa7t4\n9OQysixxaiFPtmQhy2JBsyyLNfUBsiUTw7JJlUz+9RmhRRPxq4L0ZdnoltjBmY7wtD0bzlEGokFN\n7OxeArLlbCYbPp/vDHu8dDpNPB6vKDOutHTOVs1fTMVu2zaaduG7jF+0eEUl9udXwYVCgb6+Ptra\n2igUChfVM7uQin0FWTM/P8/27ds5dOjQz/X5T487L1vF3qElMqXnhqdJHfKLecEcdASWW1VkZNlB\nN4UgU1EXpsMr1ZbqGjA0hL1kSyYgUA299QoTyTKS4sEjO7xtey2vWt/BPz0xju1ALKhRG/ZxdY+P\nV6+NoZs2b93VztDIGLMZC82n0tMYQlVEn//bz84wmSwQkAzevK2RV/d2snf4AEtFG9sR10WWZDRF\n5unxJLdsauDG9fUMzovecyzk4a8fGcd0CTr5ssnjYxnagyHetKebbNni2wdnkWWJd17exrrGEG/9\n2hHG4kUkCcbjICkxfvvq9Xy2B97/rWNMJgWKZE+LRL3H4F3/foT++Ty4uu+W7fDa3gY+f9s6vn90\nntZqH+++og3Tsjk2k+GrT04zlxEM1pHlAu/okbiso5re5ghf2DvKVFJIKty5q4Xjs1menUpjurrt\nR2cz3NxbT7VfLEw7V0VJFQ0uaQiRXJjm0EIBy3Equ4DxRAFVlvBrMrohs6ujmvaoj666ENvaquif\nE1rosgQeTeWKrmq+9sQ4i3mTgEclVttCY20ZbXIe27KxbbAlMAydr7xpI//05DQ2DhubQnz42/1M\nJ4sgSdSHPJQMC8sGSQHbsVnKlbl5YwOHpzLE89nKbilXtmis8rKc18XgVZIxTBvDfI6qKkyxqfxm\nLcuuKIZebJwvEcuyTDQarbRVy+VypWVzNrPri03sv6zYfwFjBZWyceNGIpEIU1NTF3Vhz1exW5bF\niRMnkCTponYCFxrxZArZsfEoz2lcO6641UrYjkCB+FUZ3bIwLDEI83tUVMnAsm1UWWF9U5jXb2rk\n/r45ioZNRC7RGtG4ar3QpijlMmxuDNA3naY54mdtQ4jZdJFM0eCBATFsXNcY5tBkii89MsexhSKG\nNUFDlZfr1tUxupTn+EwaBygoEv92JElVdZSN9RrLZYl43kSRJdbWh4gGNPYNx/n+4Vm8qsy7rmhn\nV0e1wK5zJq1TliRyuthV3Lq5kVs3P8cw7Z/LMpd+DhppOzCbKjGTKtLVHeNb79lFybBQZTh29CjH\nphMMuEkdlzX5zESKPWtiXOn+txKTiSITydJznwnIlEyemJX5jZCXelnmS3dsZCpR5OhsBp+mMJUs\noZt2Zf5QNGyOTGe4ubcBSZJojnhZUxfAAfKy61VrPVfJehWZsXiR5bzOj48vYjtweVeU3pYqPnhV\nB6PxIn3TaRwHepvDPDuZZiqtC79b0+Bfnp7ij27qJhpIspQrg+PgU2UiTp5/fegQVT4fVVVh7j+6\nwFSigKqKpLWc0wl5ZXKmYE8FPQolw+EHxxdd6V+BtrIdB8URC0GyYOBRFCTVIaApZMoGYY9Mtmxz\nepdqhZ36m1dc2C72+XGxA0yv10tzczPNzc1nNbsul8vk83mCweB5dxC/7LH/goXjOIx0GenUAAAg\nAElEQVSOjpJIJNixY0eFQrxSgV/oD+VcFfsKU7WpqemcyJqXGlNTUwyOTODIKmXr7FIIK71myXKw\nVQh7FdeHEtpqAnQGyjjeMNeub2Jre4T/eHaGq9bEmJ6epqqqivmyyqMn4yiyxJs2hPiHZ+Z5cqqE\nbtmC1LOtmXsOz5HI60iSMNso6CZDy2W3Jw9LuTLHZrKVIbNHkbFxWM7pzKZK1AdVbu2tIaWLncO2\n9igD81keOLGIYQtm68jyIJ+4cTU72yPsaI/w8ElhvxfyqexqD6FIFl98ZIz9E2kkB964o4kbLqmj\nLuShyq+ylHNbIo4QoFJkmclkkZ+eWEJyHLa0RSjbKm3NDfi0rNAedyOXy1NKLnDMKfGz8QLVAQ9X\ndEZprPLiUUTfeEXXHFd3/JGTyxyayjCRKLG5tYr2GsF+XVsf5JnxFCXTFjBAVcanynz1yUm+d2SB\nTMkk7FN4x65W1tYoXLVlFSeXCqSKBl5V5orOKOPLBe49tiC8SB2H2cMldNPiPa9q5z1XtHFgIoRP\nU/FpMt89Ml8xxZBdOd1jsznesKWhMji+oivK8ZkMgwsGDjp1/gSGyziWJXEv2Dg0R/w01lg0NDXw\n8FCcdNGgaAhbPsdx8CgyHkWiaDpkdYtNLWGGl/JYlkPRcjAtyBkOZwNxRXwKqdJLcy/7ebTYn292\nXS6XOXjwIOPj4+Tz+TOq+bO1XBzH+WVi/0UJy7Lo6+vD7/e/AJWykqgvtG/2Yon9xZiqL0esGHHr\nus71l2/hqycOvuixmiIJFinQGQuyq7OGoYUs6ZLJ5Z01TM7Oc1NPDZYD3zoww3cOTmGZJnURP2s9\nGo8NL+PTFBzH4Yv7cqTKNqYjFqhMyeS7R+YolIVio+Riwk8u5CpKk5IL3SiVSgQU0bN3EMJkEZ9K\nbchDsighS3Dr5kaKhsNCtsyhyRRlU9ywjrsIPHBikVTB4OPXr2ZLa4SnxpOsbwhS63MYnktx/6lZ\nirrQn5l4qECmYHDV2hjvuKyVrz09TVG3iAY0bultQJbgPd84yly6jCLDhqYwuxtsrmmUuaIrys9O\nxl1HH40PX9uBjcH77jlJRhdthL0NAT752rW8cWsjBybS9M9lMS2HjpiPdTGLhwbjPHwyTsmweXIs\nyavXxHjf7nbao36CHoXvHJnDsh22tUbY1FrFXzwwQroo/EtzZZOfDixx5xqbhiovH3XVGsM+Fb+m\n8NDgsjsPoXLOp5IlDk6lmU+XMW1BOJJlaAh7Oen6zeI4VPs1agIaVT6VN2wRmPHpZJG+2VwFEjuV\nETuvuF6gbFiYlkVQhVUBnWTOpqCb5MsWIa9a0V6PBTQ2toQ5OJEByWQ2VWIsLtpGZcOiaDgu+uXs\nQABNkYhcBCLm+ffDy7UT9nq9aJrGxo0bcRynUs1PTk5WzDZisRihUMjF6l98xX4htnhvfvOb6enp\nqfz7U5/6FLZtn/d5FxuvqMR+9OhRGhoaaG5ufsFjL4f2y/T0NFNTUy9qwffzxIqfaiwWq+i/t9f4\nSc680F0l7FW4tKOa1miAw1NpLu0UDMjlvI5p2ixkihxZKPHEj4ap8msUygbpooVXk5lJ68xnl1Fk\nSehr2w4Zw8R2zxGnDXYlyTmNoOMQ8KhE/QazhoXsgIKDV7b5lR2rMY7MM50s4lNkrlxbi1dT+N5A\nnmQ5x3f7lnjtpkY+ek0XwwsZjs9mwK02NVWmvspHwKNwdDrFjetquGNbA6Yjkc+kXRVDV/ZAgmzR\nYiGn0z+b5c5LW7l9axPLWZ2AR6bKr/GRe/qZd1s0tgOnFvNsrfExmdT5/K+uZ++QgHle2xOjscrH\nO//tMBl9JZHCwFKRBw/0c2mTh/+9p4Y5owFT8lAf9vDQ/uM8Pp11JWiFBv6xWeFyFPCIlld3fZCy\nuytIl4xK62wl8S1kdI4tQvlknIZIgJxu4VOFqfjrNtTx7GSKnCtipikyq2J+/v2ZGcbiBWwHWqp9\nvGNXK5d1RLDLBYbiOgGfh+t7alnIlnnkZJxU0WRraxUl06qIiOnu57Ac+MLt67n7wCy6aePTJA7M\nZMiVIJReQHYkdEPG61FRJNHq86kK6aKB5QhNGNMdnCJJeDUoGw76i9xa7TUBLu88N7T4xeK/Cksu\nSRKRSIRIJEJXVxe6rpNIJJicnCSVSrF//35aWloqLNkLjfPZ4uESsz7zmc+c8bfHHnvsvM+72HhF\nJfYtW7a86GMvRftlZSGwbZvBwUEMw+DSSy990ZX8+T6p54uVYW8+n+fo0aN0d3ef4ad65652+r/f\nX5EVAPCpQnP9yFSap8eSWLaopGXJIejV0C2bmYESPkX0OBP5MiVDWONJkoRHlfGqQk7WsEQlhwR+\nRaLkDv4cB9Y1hUgXTAYXhE9n2K/x8eu7GZxc4CcDcUq6Tm9LhLWt9XhUlTftEH3UiKv1fff+KeZy\nosed1S2+e3AGr+zQXO2nMxZgMatj2g6XNITobYnQP5flR8cXwIFY0MNnb12L3zKpD7huUu7393tk\nGsNebMfhwYFFZtJlXr0mRsinCZMH17Ri5ZStGJLIsoNhOWxurWIhU2ImWXKZ/M9DTjjQ1bWaDasj\nPNo/zfTyDG0+g0yhCt20kKQXXvunxpIUyiZPjgnzjI1NIdqiAQKaQpVPrcAjHQeaI14sp8QXfjZJ\numgS9Kpcf0kt1/TEkCWFX93SyI+OL2E5DusaQoLVu1wAHCwHJuMFHhpc4oN7OtgZMzm2ZOB4QyTy\nBo8dW6SgW1i2zaPDcX5tWyP9QY2CLgaYDg69zWGiAY2/uPUSvn9kjr99bAJTwNbJWQqqKuPYNplC\nGcMWBceDJwxyZQNNEcYmDkJawCNLrsSwWBQ5DRyjSOK3sFL9v5R4Odsh52KwejweGhsbK/aaVVVV\nPPHEE3zlK19B0zQ2bdrEbbfddt7Pcj5bvJf7eeeKV1RiP9fA82Ir9pWFQNd1jhw5Ql1dHevWrTsv\nTPFiB7QLCwuMjo6e1VOxIxagJuQhkdfBNZ0umQ5zqRKWy9r0KULu1nZAUywCHoWFrI6lgO0I0SbF\ntejSFBmfqrCrM8qJuSzzGcEwXBXz0l2tknG8ZMsm6xrDbG+vZimnc3muTMm0ifo1/B6VtTUqg/4S\n27as4lXr23h4cIlHTy1zeDKN7YjE+ddv7OVHx+ZRXWEpx3EoGDYlU9zsv355G7a9gp0XGjf3H10g\nVTSQgKWczke+c4KrG0xe29tOyk5xfDaDg8Oujhpqghrf75vn6Iyonv/5ySlu39rEusYQr++tZ2gh\nRzwvCF4t1V7CHpmB+QKfe+RZsiWTWFBACucygvE5MJ+lYIgbvykivFj/8L5B9o+nMG2burCXP72x\nhuZAnNVBnaUMFE2hhthV6ydXMvmbR8dZzOpIEhydzfLBK9tpqfbzd2/ayGcfGGE+W6YmoPGGLU38\n46MnWcoKKYBMyeT+Ywu0Rb3UBD2sigW4973bGV4qkC2ZPDGadDXrZTTHwUb07/9t/wyDs0k8qsKd\nu0KMxQskC7ownJaFJd7+iQzbWqs4uZTHsIQRycB8jg/8x3FwYEtLGCQJyXEomqCpDrV+jddurKdv\nKs3+iTS2JFE0hPNTSbewHRcFA5QsB6+mYCPuKxk4/Q6TJYmA56Un5pfT7/RCVSIVRaG3txdJktiw\nYQOSJDEwMHBBC8yF2OLpus6XvvQllpaW2LVrFzfffPMFPe9i4xWV2C9WCOx8r2UYBgcOHGDt2rXU\n1dWd9zkXg31fIU1NTEywY8eOs0oPVPk1JMCrymd4a55ewVtIqIqEYdp4NRnDtdKTXENlC4mehiDx\nvEHYJ4hPPQ0hIn6VgCbjUVUsvcBSKs/OtmqmEiWaq33kyiY/7p9nOafj1xSuWlvL0PQin31ogqIF\nP56eZtdonp3t1Tx2clkMGSXYPy6w6rGgR1DWbRsZiAQ0OmJ+yqbNEyMJDMvmd65bTcmwWciWXeEs\nV81bgmyhTHdnF0u6yp/fug5VgvF4nlTBoGxanFrMVwab6aLJ4yMJ1jeFCPtUPnfbOu47ukDIp/LG\nLY1MjI3yJ08tkcibOCszhMPzvO3SFra2V9MS9fOzU3Eifo3fv66LoYU8+0YS6O6JnkyU+If9S7xz\ntZ87btjO0akEPxuYwy4X8Uh5Hjg6WUnqSBKLmTJ9M1miQQ/ZhMlvX9NFc8TL3pPLKLKobiVJuEzZ\njoNhOhQNm0LZ4pFTCfqm0nzgqk4ShQzRgOi/F1z2qFdTWcrqDC7kcXBQJIPPPTzKntU14Ai3Itky\nsZGoC3nY0hZhTUOQsmlxbCbHwck0SKINd2AyQ5VPrSyCDg4BTWZoPkeyYLiSADKqCgFZoi6gsZDV\nCWgOCpA3oGxaFWmI0+8uy4GSYfM713bxUuO/yxbv9PcOhUJceumlL3j8pdri3XnnnZXq/NOf/jTr\n1q17wXEvhz7OKyqxnysuVq1xbm6OYrHIq171KoLB4AU950LbPSsiZLZt09vb+6J6MtGARnXAw9I5\n3Gcs28HvlXEcMC3x764qCRMZZJXmaJCPXbua7voQ9xyaoWyKLb2MxHiiSGcsQLpo8thEnu8NjiBL\n0O72jIfc5OE4DsWyjl4uU3bNNUAQjlbXCdckVZGQJcFWfXhwiTduayGZyXN0JoVHltjTHUJyLP5h\n3xRTiSKyJPrfn7ppLbbt4PcoJPK6GMTZ0FoTwuf3MR4v8Ef3D1Ll1/jAng56W6OMxws4jlTZ9kuS\nMKSQXDjoro4o29ojghhlOxw/6ZAuPnftJQlXSliQp96wpYkb19VRMCw8qsJcpiRE1k47zxkX2TGb\nKWOi8q6rLiGnWxwYTzBxagmHknht96acSxdJ5HXu7VsgWzbZ0RbhfVeuYngpT0+NTNIA3RTaQrVh\nL0FN4R+emGIpJ7D3z4yleOuuFpojft6yvZmHhsSwe1NL2E3O4jzZrjxwJKCxoTnMqcUcliPREfXT\nUu3j3r55bBx66oMs5vSKt6IkQU63uKanhvFEidnFFJbqYTxRYiJRAgnCPgWXfIwqy1zdU8v9RxeQ\nUNBtG8WyKFlCKOz5BCVFhrYaHzXBs/+2LyT+u2zxLuT4l2qLd8MNN1T+v7e3l8nJSWpqas77vIuN\n/zGJ/UIrdsdxOHnyZAXveqFJnQtcPE6HSp7v2LBPpSPmZ3Qpx9nWC9XV85Alic2tEVTHYjKeo6k2\nSnvIQdM8rGmJsaYhzJMjcY7PZllTH2JoIctTI0kM22Y2VaIlpJAsWiiyQMBMJosENAVZAk1VMEyT\nVEEnGvQjFUsVrLltO3TEAnhUmaJhAcLEoTniw3EctnXWsr6thrAKW2I2X31mkqm44cq7Sswki3zx\nkVHuvKydN+9o5u5nJnFsi5pwkDdd2spitsy/PT1NtiQqyv3jST6wp4PasJeexiDPTgghsaBX4bKO\nagplk28dnONzD40i47BjVTWXdkSZz5nUhzVmU3rFiq854hVOQs0hDk2l2Tu0TJVXpSXqY11jiLqQ\nxlJOVK0eVeK6S2Lsm5nmP5/qI6dbeFWJj1/XRUt1gF1ddRxfKDObFsm9NaLR7inwN3uHWSoIZu9k\nokTYp/GmHc10VctooQgTySKNYS87V0V4clTgz2VZXM/5XJlnJzNc11NLLOThV3obaI54yesWE4ki\nI8sF8XsFQl6FupCH7t4GkoUaAprMdKrEfUcXKRmCsBbP6tRXeV1jaqHvo8oSVT6Nq7r9FCJ5vjcm\n8PW246DJYpYjSxKjy3kk4D8OzVEybPyamNGskMnOxjqVgKjXXX34ryEo/Ve+1kshKJ3PFm92dpZ7\n7rmH3/qt36rM7S677DI0TTuvnd7Fxi8T+2lhGAZ9fX1UV1ezdetWnnrqqYt6j/O1YtLpNMePH69A\nJZPJ5DmPlySJj17bzRPDcYzngYR9qkR3XYCe+jBjiQJh2UCxDTZ31DG6VGBksUzIp9LREOW2rzzD\nYraMbtr0VafJl03Kphicji7nGVlyK17JqcAYHXdrni/pgIRH1dixKspMeg7TEi2E5oioCl/VVcOR\nadFj76gJsL0two/7F+ibyaCbDvVhDze8cxt7Nvv5yfggK147lg3lUol0KkUxk+F13X5+9Yr1pFwl\nycdOJciUDGRJQCMXMmWeHE1w3bo63rCliS2tEUFIqg3SXRfk3r55+udyglBjOzxyMsHGphCqDLdv\nqmXfeB7dsllbF+Q3rmilLuxjNlXkd793gnjewKPIbGurosqn8X/v2MhnHxhGNx2uWlPDG7c2c8vf\njrNUEFkrX4a/fmScBz60iw3NYfZ01/DAoEAbXX9JLT84tkh+dBJJtirSyo8PzVGt6uCI1zRtaAx7\n2NpezWSiiLxS8btVtWnbfOPADDMpsWDcsK6W1bUBrlkbI1kwmErkifo1tq6qYSJR5NjMIl5N5jOv\nW8sTY2OUDFMgVxSZkumwuyuKR5FZyJYJelXaqn08PpwgWzbxOwa240WWRAul7DhEAx4aq7xMJ4uo\nskxWN1BkoZWzktTt02SKz7gXgO31CgcPHsTn81Wo/hei07QSL3cr5uWs2M8W57PFW7t2LbW1tXzi\nE59AkiR27NhBd3c3XV1dZ33ezxOvqMT+8/TYV0ymV69e/ZIxpOdqxczOzjIxMcHWrVsJBAJwgT35\nztogTdV+JuL5CvJAlkSVNrJUYHgpX6mYgl4NKZ6iqNsENdBNh798cBjHdvB6FEBmNlVEdtExtmuA\nEfBI2LaM6TjYQNCn8NbtzXz9mQkcWcbvVbmyO0Z7LMh7L2/igRNLtNZF+cyv9PD0aJIrVtewuS2C\nX5XJl02aoz4OTWUELBBYzJb5i5+eYnt7Nc0RHzMpIU5WF/bw6rVRJmZmeXTGIWdKPD51hD9/fQ/X\nravj8HSaZ8YS4CJKJMDvUQQjtWzymvX1rIr58bosyu8enqto0gvWo8lcMo+3VKK9oYF/fLNwhDdt\n0G1hEvH5h8dYzglFRd2y6ZvJcF2mxJXdNXzt7VvQTbsiyGa4ipS4rQzdFE5GM8kSD59cRpYk2qM+\nwj6NLa1hVEVCMoXrhoRD0O8lky/y0LhO+tRJ/B6V2zbXs2NVNbs6ozw0FCee17Esm67aAAFV5unF\nHCBE2R4YWObTr12DV5X50FUdBEuLtDTUMZKR+MT9wk5QkuD37x3g0lXVHHZRQrbtICkgyTKXdUYx\nbZt4rszjIymyZVNY5Jng99nopo0iizlOPF9iLl2sfGcZGUlyUFQJ1RHnQkBmz/zNemThKfDr1/QK\nkxfXVGNgYADTNCuY8fMZNv93VeyO47yk974QW7y3vvWtF/y8nydeUYn9XKEoyhkGsqfHwsICIyMj\nZ0WmXIzn4tlaMae3dnbu3HlG7+xCh63rGkLMpEo4toXhSrQu559jpK7Yo1plUzAEDZsqr1rBqTuO\ng5eVPrgioI+IHqvtOLRUeWlsUJkqCGegN2+NkZw8xbsua6WEh6BXwa8p5EqG0Ofwy1zSFGJoXtjz\nffnRMYqGjVeRuLqnljUNASzbqUDjJAnm0mX8msJv7l7FEyMJsiWTO7bU0X9qjCeWPEznykgyZJZK\n/PY9x7m2TcarBakNeURvGFgV83NZZ5RjMxnu65vHcjVt3rt7FdGAh5qghiKDZQvSTpVHxsknae/q\noL46RNmWGJrPMb6cB0noyRd10zWPXknWNmGfykKmxINDyxTKFs0RL69eEyPmhWTpuevSUOXBsGw+\n9r0TzGfKyJLEmvoAYa/CFatj3HlpC986OEu2ZNIS8fMHr+nhLx4YZiwrIcuQLBl889lZVrHEYNbL\nndtqObYoKvob19fx2HBSwE9dA5GiYTGTKrF/IsXocgHJMnn3ZR4OLxrkymJgigPTyRLXrlUJ+VQS\neQNwqAv7eGIkQdlyaI54sW2HVNEQXqUSSLLYPeiWQ7ZkYusWRd2mYFgossz/x957R0l+lne+n/cX\nKldXVXd1mo6Tcw4a5QgSCIQIBmTA2DjhvTa2sX1tr3e9e3y8y7XvLmuvuRgbDF7bRANGSAgBQkia\nUZzRzPTk7unpnLsrp1/94v3jrSqNJkgzo8GA4DlH56inq35VXf3r533e5/0+n29YFyhCLvwRv9qA\nkpkXqdZDuoJfl85dQohGS7O3txfbtslkMszNzTE4OEg4HG5geM83mnZd9zX3mutxpWTHOu30JzV+\nqhL7xZLu2bNnyWazDZPpc6OuM7+SxH5uoq77nUajUbZv337BdS43sft9KkFNuQAXSy2pK+IllYVT\nU8UUqrLy8mr7ZM+T/ZWArnLX+laeH8lgOh4rWoJc399EPpvhunVduNUyX953ChFO8szYIlXboyWi\n89ZN7Tw2mGJwroDtOBxbnGB6vcHAVJZM7dCzguD5sQy/e8cKEiFp5SaEQCiCdR2RRusnW7GI+wXZ\n6RHef+smnvjKEKoq+9kIQc5S6O1fjl2t8C7VZWDaZkNbiEQ8Qrli8vCxebIVGyEgX7H4xJNjfPTO\nlVy3PEGqaLJQNLGtKpubYeOaFcQjfoYWivzpQ6fJli2aIz5+5YYeQn6N5ckQpxeKFA2JOOhtCXDb\n6hY++rWTDEwXMG2XZMSHQPA7O3x8aTLMbLZKa1TnY29bz9/uG2ciXbfH8zg5W+TARI4bVrbw5o1t\n+DSFQsWmvclPIqRhOW5DOa8oAldotPWv5cSpOQ6OpQlisrzZTzGXZXUywGNCjvZTQwA/dWaJw9MF\nych3XT713Dwbl0VxagfBAJ4QTGXKfOC6bibTFVRF4emRNCfnCvhUlcl0hf6WIGp94a391xKRRi3H\nZvJYriL790IqlRxPkhyjfjntbDtSyXOxu7dourxje/KifzeaptHa2kpra2tjhiOVSjXEBOdW8z+q\niv0nHQDG6y2xX0krxrZtjh07RigUYufOnRd97tXwZeqJuk6W7O/vv8DvtB6Xm9jv39rJk0NLF3WA\nr1vmea5HOFCfFqxJSzxobwoQ8St4SE3x+vYIy2JB3r49yHS2QsVyMGyXw3MmL8yOYllV3rpzOV88\nMEOmbOLTFCYzNt8bXGKpYDY45lXH5fBklpLp4NNVPFfabliOR6Fqcf+Wdp44k8ZyXVa3htnbn+CR\nEwvsG05hWLJloK1v5R3xmDRedmTTVngQ0H3SlFuPMrBgQUhj15pW2vQKE7MzOFZdJSSdOuqJL6Cp\n3L2xjfXBAma1ysaNG1EUhUzZ5D9/8zQLBRPP85jKVPja4Tl++cZerl/RwtaeOI+dWiTiV/noHf2M\nLRV5cTJPtdb7mskafOXwLL+5XuWv37WRQxPSvGIsVbnAEMVxPWxHtmj+9xOjmLbH7v44sZDOoYkc\nbRE/ggLy1EAif9MVh387kaVYlbC0OVvlt/pUTk7Ps6kFJosKmqayd3mcF8ZyL2PTVyyHDR0RBhdK\nLBVMFEWwPBnCsD2+fXyB5rDOrt442bL1skSeLlu8c1sHjw+mqJgORdvh2HSBloguGf819k8kpGLZ\nDo7rEfIpGJZLxXap1oFnHhck94hf4X27L5z+Pj+EEEQiESKRCH19fdi2TTqdZmZmhtOnTwM06I2X\nUo5dbvw0GVnzekvsrxTntknqJtP9/f0XxQ/U40r5MvXXqPPZ62TJV3r85ST2nb1xdvXEeOTk4gXf\n0xRBQBP4NRW/rqKrgq64n1KlSmdEY3VXK2XL5l3bl+G48PCxuYaWvGo7bFrWRLZiMZ41sTwQisY3\nj85j2A6iZrihCYFRdaSRgjh3NfFIhnSyFQvX9fA8F0XoDM2XCfhUdvTGCPlU+pqDaKpgKlvBdOQ4\nvq6qHJkpcngyy5s2tFEwHIpVG5+q8Ju39VM2Hf7l+WnOLhYBWen/xf0bcJNRIqGzpA2jIceIag6F\nQoFQKMTU5CQdPVHWr1nL8ZkimbJJzpAMFOClgRzLwbAcuuMBVrdFiPg0KpbN0dkyfhVM++XyyDo3\n/fuDS0xkKiRCOobtsKYtwnOjWbIVKVNLRny8a3sHv/6FowxM5UHAwHSeX7y+h7awzn9+02oGp5bI\n2Ro+TXD98gSffnoCo+ZU5XkwkzdZ0d+DHkuix3K4lkGpVCKdX8LneZK0WCtENFWwozeOripkKya6\nqnJqrsjRmQJl02F4EaazVQK6RCZXbRfHdYkHdT5650o+cvsKPvKlAU7OWESDGo4rUQZ6Te9fMiz8\nuortuFQdCQTz8BB1f93zqg0FWBbVUNUrT4yaptHW1kZbWxue53H69OlGAQY0qvloNHrFbZKfJls8\nfpoSez1Jn4/zfaW4Ut9TIQSLi4tUKpWXkSVf6/WFEPzhPat5YnCR8jndGAXoSwSwPSRvxKfQFQ/h\n0wRHsxVOlCs0NVVZKhp8+AsD2K7XUKQUa4luJlPBtCwsF4SiouCRq9j4NVmdeZ7ccqtNguawj2zZ\nqpkYCzYta+KXbujhzx4ZIlWyCOkq921t5/hMnq8fmSNdNlEVwapkmI+/cwNmtQquTAp2zR82VbLo\njAf47TuWY9ouhuVwy+okz5xNMZYu1fxcBYsFk//52Fl+fk83v3pTP/96aIZcxWJde5itbQFml9Kk\nMmM8v6jw5dMG4rEUO3rjvHlTG57nEgmoFKs2QggURdDfEqK/JcTGzihfPDDNc6MZYkGdvSviVC1B\nX3OI0VQZIQR+TXDnqiZGM3N86pmz5Co2IZ/KraubuXFFM39yzyq+dmSOctXhjeuTPDOa5dhMoWHI\nna1YfPfkIr97x3LiIZ07+zRWrFiBrsg+7qGJnHxftQWkYrl8+/gCj55aZCZXRVMEb9rYyl17+nmH\navN73zhDqmyjqXBXn599g/OMZi00IVG/+85acjfgUzFtl3TZ5JZVCV6ckCqloE+lZNq873OH6W0O\nMF8wMV3IVuwGT33zsijHpvNUHA/VcTFseaBYqFXqsu13odJREbCnJ0pz6LWZVAgh0DSNZDJJIpHA\nsizS6TRTU1MUCnXHLNmbv5zC62etmNdpKIpCPp+/7KTLFU6ruq7LwsICnuexZ6BbBUoAACAASURB\nVM+ey7qJLjexW5bF2OnjRHTwFIHlSH9JFxhJyWEfvaZkOLNYRhUCy7ZxPORiYDkEasoRw5aVqmR4\nQKVq4Qo586kpAsfzUAXcu6mD58fSLBVNOmNB7tvSiU9TePbsEl4pw9Z2nZvWBukMK6xvj7JUNlnb\nFibilxV/sWqjKbJPO5GpcODoSfZ2B5guSL9MTZHGyxG/xsPH5nlhLIPrQU8iwNu2dtAZC1AfQapr\nr21PKllCPpUP7u2hbDq8eVMbRsXg+cNLjBQSTBWzgIPrOew/s8iKiE1fezPv3bmM58dyGJbcpfze\nXStRFcHxmTyfeGqMfEXq64/N5PnQDb188oHN/MV3hskZNstjGkl7iW/Mh0mX8jVSo8P+sxn29Ma4\ne307YZ/GUkm2ro5O5xvDT26NeBnxy93Uh/5lgLEFm9XlBe7b0o4ANndHyZ3NkKvYUNPYf/nQDAsF\nE01VKLsu3z+9xM7eGBs6Ejz0f13Pkak8+waGeGbWYmJoTn4+LoynS5Qs5A6g9pnpqkJvIkRvIshi\n0eKp4RSpokkKk7FUuWHGIgQUDIfmsM5CwUTXVKq2pGr6NUHVFmBLO8SK9XKctKiRHMOa4H07Wq/J\nweO5yVjXddrb22lvb8fzPAqFAqlUiqmpqYZ93rl0xvPDcZzLPoi9liiDH1W8rhL7pW4mx3EYGhrC\nsiyuv/76a26PV+fJBAKBV5VwnRuXM6labxutWrWKttAxCnkpX6uHVxvfdhxZLdWVMKqAkC4wHZdS\n1UFXFdQaL8ZyXCI+gWFaCEXQGfWTKVWxPAkL++07V7J3eYJfuL6Xx08vNMBgE+kyQ4slWsMRjhU1\nysMFHn9kgtGcgws8N6Lx5o3tDTWEWjOqrpg2li/K9RuShJpyDC2U6IoF6G8J4bgujw8tNWzv8obF\nl1+c4c51STpjQSbSFfAgFtJ465Y2LMdFVxUW8gaTWYO1zSqpyWHMaBfjpxfwEI2Ksup6lBzBwvw8\nxYrB7+5IEo03czojW1IBXeXBgTnyZYuaoITRpRJLxSo9iRAfvqWfQ2dnyaUWsWK95M7M1eSU8rO3\nHI+Ny5rIlk2+dmSGoKayuy/Oxs4o3YkgMzkD4Ul7uF29Mf7g306RKVs4DhycyOFTFW5b3cJ7d3ax\nd3kzXzgwTWvExy2rW/jUvnG82qLmuFC2HH4wuMTHvjNMSFeJBjR2tCikKg4uCorw8BTJ2dnSIjhY\ncig7chCpPerju6eWsByXbT1NmOcYfJiuS0hT6W9SGCt42J6HYblYjlWDcCnggVAEAV0l5JMLiHNe\nqe4h77dYQEHXrk21e6kqWwhBU1MTTU1NLF++HNM0G4YaddZ6vdKvJ/OfVeyvs6hUKhw5coTOzk5s\n277m9niFQoGjR4+yZs0abNumUqlc9vVfbeGo9+q3bNlCNBplW4efqYqNYV/CfKMh0fJqVENQPTmI\nVLEcaVHmQSKokilaoCgoqmDvigR2IYM/lmRlMkzVdvn64VlGUiVyZYv1HVGiAY0HB2ap2i6LBVO2\ndFY2M1sRCFXFJzwqVZvnhmZ4x/oo0xnIGy6O49IW1SkSQBSqPDuSxnI8mgIajgejS2WqtvQbpTbs\ncmKmSF9ziA/f3M9TwykKhs2mZVHu2dDO0HyRR47P89jpJYpVm0cGpnnz5g62xQKsbgszslSutZw8\n4kEfPW0tRP0qb+6NMTGf5l/2jROhSiLsIxqNsliooQDq5k0CNnREcD2Pf95/hqV8mVs39tIUCtAe\n9TOVNbAc2UbqbQ7i92n86hePM7Ik3ZkOTxf41Ru6+dDeLpaKFifni2zojOJ5SGSCkFJHISBTNtnW\nE+XAeI6FosnNK5tZFpcDPFG/RqZs1YZ/PIK6yg/OpKmYDmnk0JjuaA3HJtuTqqiAT+fGTT30Lyty\nfCqH4picTBXxkC5I6bIpdf81rb+KnDIN+RQEDhGfhovAtBxUIZ9jux4xn4bpSI9daQRy4f1nOnD3\niuC/u5LF5/PR2dlJZ2enbBcVCiwtLTE+Po6qqrS0tFCpVBrzI68WP6vYf8wjnU5z6tQpNmzYQCwW\nY3Z29oqe/2qJva5/37p1K5FIhIWFhSvqySuKcklt/cTEBLOzsy9rG92zKsSU6fHEcOaiz3FdD11X\nEEJB1BK6pql0B3XyNb/T/rjKyiiEEu0YlkcsqDGZLhN1XVoifkJ+lcWCyVNnUgwvlXBdj+GFInv7\nE1QtB78uNcyegPG0XMQ8z5OKC1VF+PyEYgnu7bf5/miRsF/jjjUx/Ap8ev8483nJSh9NlwnoCu/Z\n2UXTM5NkK7IvrOCRCGmoQqAqcMdaycQuGPJg9foVzfz3R4co1wZryo7CE2cy7Oxv4dbVLVQsh6H5\nEm1Nfj5y+3JWJqWp8af2jfGNI3MUDJtESOfntiXwPIsVYZO5gCBb9RAerOmI0Bnz8yufe46DMwae\nB0O5ST5wXTdv2tTG5u4mDo5nqdou92xo4788NMjoYglVVXBdj+lMhRcm8nzktn7ao34eHJhFrQ1U\nhf06haotK2Ahf/+/9/XTTGUqKMIjEfbzlk1ttEf9PLBrGU+eSTGerqAqgo2dER49tYSoIXEdD5Yq\nDnv6Ejw5nKVq2fh1jbXtEb4xMI/luPzCdT18+cVZPCGH2HTFw6jatAU8LEvUDkMFybDGYklyZJoC\nGroiKBgOEZ9CumziCIFhyfMPx7v4pKkqYGVriDv7Az8yDAC1v6k6a51zfFAzmQzpdJp0Ot1wTrpU\nVf6ziv3HNDzPY3JykpmZGXbu3EkgINklV0pNu1RFXbffy2QyL9O/Xylo7GLXrzMkbNtm165dL7vB\nfJrKf3xjD8+NZjjfbSykQ1DXsVyPrV1RVrXofO9Uio64nxuXN0uGdmGJeFBjsBAgoqjkDQO/rtDd\nHOTx42ken55ECFjdGmIsXW5o5A3bZSRVRlMVzBrF0XU9msM6nucxnq5gOx6qKpk1+VKFQ3MVAqEw\nsbAPTYGTI1Ms5E1ZmQuB8GAuZ7K6LcLdG9p47NQCnhD0twRZngyxsi3EgwNz7D+bxvPgHds6iAY0\nFgsG6aLEFsvDRtkDtl0XTVG4Z0Mbd62Deze1UTYdnjizRLpk829H5qiYDooiyJQtvn8my4dv7uO2\nZJIP3ubj0/tGyRQqbIhX+NtHXmRg1q31yCFbtnj0xAIfu38Db9vayaMnFxrtmPoQFp70BnVcOQCk\nqSr/9VtDnJov0t8c4rbVzdy+ppknz6QRjkUsEmBrV4QvvThb48cL8hWLMwtFlreEWCqa3Lelg5tX\nJvj2yUWmshX8qoLjevg0FdNxieiC5S1Brl/RQiKkkzNs/t/vjVAybfya4DPPTLF1WZTprIGqioaS\n5oFd7cym8/zbCQmems1VsGwPRZe/z0xFMt2tikvVoYbeFZRNB7+q4Km8zGJQ1GSby1tCknB/jQZ7\nroU6pe6DWigUGv35VCrF6Ogouq43UAfnVvNX87qv5p40MjLCP/3TPzW+npqa4g/+4A8YGBhg//79\nDTe2W265hTvuuOM1/cy83hJ73eji5MmTeJ7H7t27L3AFupK4WMXuOA7Hjh0jEAiwY8eOl90AV6qi\nOf/xdVZNc3Mzy5cvv+A9CyEI6So9zWEmM2VM22toiG0HDOEQC2j0t4Q5u1ggqMFctsqjJ+bR3CoV\nV6MprGDZBX4wuIiuKQhF4FMEhYqLT/ewXYej0wWZsDyv8bol02Frd4zjswVs26ajOcje5c2EfSpL\nxSoHxnNs6IzQ5JV44kyBoSwIUWUiY5Aqhbh3cxexuWlKVRvbcTFdj7GFLE8dH2dvv7SRq0exapMp\nWTx0dJ65vGyVfO5Zi+v64zx+aJDOiEbJshutk139caJ+jXzFpmw5TOcMvnDAoi3qk+oKVfbF3drh\nK4rs/auKwt7lcaIBnXu2SPPv8bFxHE3BoSiH02rvKepXWd0W5uFjc3zpwDStUT93rU9y+9okgwtF\nChULz/VIRn3Egzq/+H8OM5uTg0sjiyXyhs2da5q5PpZnbX8/Bxc8Zms/W73c8DyP2bzJZ5+ZYDZv\ngpAWe//rXRt4djTDzKoqR6byBHSFDR0R0pkUXzsyj65p/PpNPZyeL1EyHYQQmI5s9diOS9ivkirK\nIbL1HREypsITkzYVV8WnKRiWjWVDu89iNicPXKMBrfaZeVQseRBeP1y3LtKHURXBr93US2lu7EeG\n2n2lqFfh0WiUREI6OhmGQSqVYnh4GMMwiMfjWJZFKBS6Yt38q7knrVixouGcVCqV+Mu//EtWr17N\nwMAAb37zm7nnnnuuyc9Zj9dVYncchwMHDtDe3k5fX99rrhzOT7z1fn1PTw/d3Rc6r1+pS9O5168f\nkr4Sq0ZRFHyqtEebyRkoitOgPpoumKZL1TZ59ITUqrueR8jnkM1K2WEkIFjIG1L2R60nqypkylIq\nV9eX245DW9TPfNHEr8rEvqM3ztr2CHuXJ8iUTR7Y1YXpuvzgdIonz6QoVW1eKBW4rT9C2tZBuOiq\nwENQNEzuWpukYNg8ODBHwfVob/Lx1s0tHB5P0USZ4bxCc1OYvo4EPkXn0RMLzBeqeIjGUNHHHjzM\nzSsT/OLNy/j+4BJzOYNk1M+f3LOaiF/n1Fyej3zluDwDENAVC/DhW5YTC2q0N/kZWSwBgrBP5Z3b\nO3nDejn9+FePj/Ddk/OY1Sp3rkmwZXUHT8+OMZWp4HkeQV0hoVT4xb97ktNZGlZ9MzmDn9/TzUfv\nXMGJ2SKT6TJ3rW9rjOu7CPSa0UiqaFCan6C1twtDjxHyl+huVulOBJlIlREKNAV9+DXBYEoaoODB\nixM5Pv30JEFd2uStaw8RD/sYWSzz2ClHMmBw+IvvjrC9O9qQh4KEeWUNi3dt7+SR4wtMZiqcmC0y\nlTVojchFr2I6eAg0FRKxCKlqGcVx8Bwb05UFg2mDEA6qAOs8iaNPkX4BO3ub6GsOcXzmR0dkvNJr\nBQIBurq66OrqwnVdstksDz30ECdOnKClpYWbb76Z7du3v8zV7FJxJS5IDz30EPfee+8PtY//ukrs\nqqqyZcuWa+ZHem7FXjex3rBhQ2PFPz+uthVTPyTdvHlzw0nllR7/wJ5uTs0Va36a50H6QR5u1b5w\nbAeEwHI9TNupMcohoCsEfZo8aBQNEi9ejer3d+/byscfG2GpVKU7FmBlMoTnecxkKywUTQYXipyc\nLfKVQzPkymaDhx6LKCg1pLCiKNiOi+XCk8NpehJB/sMtfaRKNm1NfvyaQiUa4ZETCwzO5bGcNB1n\nMnx0px+nEmgMBVE72LRVP1tWd3NqtsQb1iUxHY9YUJdSw2KVP3/kTK2HL5PiZKbCwHSWnb0Jfun6\nHh49vkDQr7KsKUAy7OOR4/OMLJX44oGpGt4Wvn2mSHeryR/fvZojUzmOTObY2t3EytYwf/ODUaq2\nIVtADkwsFdCtIndu7uXt25bx4MAsuqpgOlLOWQ/HcckUypwoJ/iH705RtcfpigV5985OPnR9LwfG\n0kSDPt64vpX/8djZOtyxATM7MJ5hMlvFMB2CPpXb1zQzNF9uTJGCVM0oqkJvIshU1sBxXRJBjVWt\nYfIVm7lCFV1TcW0Hw3SwXY9IQGOxUJXWhz4F0/bwaQIPFV1XwHEk8RNPAuguUifZLrQENG5d1dJ4\nz9eqFeN53r8b3bFuaP3BD36QiYmJBrjsH/7hH3jggQfo7+9/xetfrgtS3dv43e9+d+Pfnn32WQ4c\nOICu63zoQx+6rIXk1eJ1ldipmcVeCwcSaondNE2mpqaYmpp6VRPrq2nF5PN58vn8FQ003bamlTes\nT/GVF6cveIznymlEp7ZdtmtEPjwh++Oeh6pII4SyKQd2euJBcqUSiagPn6rwru3LeGIoxfqOCKYT\nwnRcxtNljk0XGE2VUYTg6HSeW1a1UDRsvNrQUdCnIYTLO7d18vkXp8mXLVRFYU9/gnhQr23rXSI1\nJydqSevUbAEhFBRFMFvxeCIT4+c2RPn+SIGZglwoO6Mat6xrJ+LT2bs8zt88MUq2YnPvpjaEEJyY\nKaIqosE9qd8BzSEfmhC0hHz81bs3cXquwHjGQKtNRj5+WjLLFUWgIMiWTQK6wo0rm7lxZTOPnlio\nDf/X2nlCUhI14aGoKsPzBZ449RwjWQ9baGxY1sRNq9vY3Rfn+dEMhu0S0uAtW5fx4LElKpbE+M7m\nKjxyYpG3belgc3eM5pCPzV1N3Lelnf/9gzJGjYzZ3uRnOmdQNJyaft5m/9kM27qbODkDSi1X6Ypg\ne3cTGzsjHJnMc3gqT9F0eOTEIlu6ojUsM/hVpeELe+OKOI+eWMSnutiuy1RWcmXiIZW8IVUxPl1B\nUxQsozZdfN79JoDNnVHu2yqxGdeyyr6Wi8SVyh1bW1vZvXv3RVskV+ueBPDCCy+wffv2xnvZsWMH\nmzZtYsOGDTz99NN89rOf5Y/+6I+u4Ce7eLzuEvsrxdWYTc/PzxMMBl/Wr79UXEkrxnVdxsfHMQyD\nm2666bJO4c9dOP7kTWt58swSUxnjZX9sde2zAiiKrMzrvqOiJl9blQyzcVmUgak8LWEfm7uiHB4c\nYVlcsK2/hRvXtvCppyf4weAShumgawrX9cVZKlbRawmxaNi8OJ5G9Rxcte7g5FCsysT9vl3dTGcr\nRAMavc3yYOr50QwHxnMIAYmgznt2LiPq12rvW8rq8DwWChYnswp/dFcfX31hjJZ4jK4wTI1PMOkt\n8rlTDodmpIvS4ckcZxZK7OyNc/vaJGOpMrmawmZde5QPXNcDNXTw7/zrcaazBm1RP/dv68Aol8GS\nbQ+BvDcifo22qJ+nz6b4xBNjZCoWybCP9+5axq2rm3lwYK5GPBRs7mqiqTnBs6ck5VJTbOYKKUQ5\nzc29cd65po2R6SWIL0PVdWx3Qd5Xtd9VqlhlMlPm+6eXMG2Xfz08wyffu4Vi1eFbx+bRFMFv3b6c\n//G9YQqG0xjU8qmC//jGFZycXCJdBdeFTV1R3ri+lbmcwdePzKGp0rTccV3OLpZpCfvIGTYBTc4x\nrG8PM5GWaATPc8hXbFzPIxFSmUhXpRRSyGGkfMXCcr0L1DCKgJVNsDGcZ2JslGQy+WMrFbxSuuMP\nwz0J4NChQy9zUVq1alXj/3ft2sXnP//5y3qPrxavu8ReJzJeLOqJ93JuPMuyGBkZQVVVtm7delmV\nw+W2YizL4ujRo4RCIWKx2GXfcEotQVMjA96+tpWvvjgt+R/1VkotcbRFfQjX5KZ1bSwVZY89oKt0\nNvnRFOmHeWK2QK5sslCo4vjjPDlR4lvDE/i+P4bhgIeCoiqYVZtnR9NUrJdex3UcyhWHm1YneWE8\njyKgJezj3s3tCCEI6goBXW5JHdcjb1jsP5vGdj00RWHaNHhqOMXuvjhhv0quYoEHYb/G9t4Y5UKe\ndDbL+25ex0LZRRWCe3Y1oXsWg08dqQ1peVQt+O7JBe7f0s5i0eSXbujh6eEMsaDGf3rTap46kyJv\nWHxm/0TNoUhhMlPBNKtcl3R45+5+fjCc5exiCctx2dOXYCpb4dP7x8lVbBRFMJ83+NZxjXfv7OSt\nW9o5Ol1gPl9lZWuYp84sUTBsKTEVAsuDCTNCW97h8MQM/XGNeDXNfMlPPKhTqsrdghDQFvXz8LF5\n8oY88zg8keO/fmuQ9e0R3l9bkMbTFZYnw/K8oXaY2RoNUMpleM9aP9+Z0TizWGFgusCHv3iMX7uh\nh6rt1iiSUkGjqYK3b+3gwYF55gpVAJ4ZyZEISemq3EVIdc9MrkpTQEVVFMqWTPgBXU4Qm+ccmqpC\nTpqu6kryrltXYBRzTE1Nkc/nGRoaorW1lebm5muG3X2t8cMeUHo196R6nD17lr6+vsbXn/vc59i7\ndy/r16/nxIkT9PT0XNHrXip+PD71f6eo98xf7WYrFoscPXqU9vZ2TNO8amzvxaJcLnPkyBFWrFhB\nU1MTg4ODl/3+6zuOety5tpXvnJjHM2yq5yBUTRfmCiZhDZ4fTVM0HKwaPVER8vAQAemiiePByflC\noxJXVBXLVag6DgIXxa2xQVSXWMBHumzXYF9w16ZO3rJ5GS2RWWbzJq1hH7oiyJRNvnp4lmzZIhbU\nuGFFM8mIZH37VNkosR2PhUKVWEjn7g2tHBzP4QI3r2zGbxVZzBQYFE2c/N4YruextiNSq/6DKKqK\notCQsDq2xcDAUfpam6hEm7jxjStY3RblwHi2xqMXlCybc+yymc4adO9YxXUrWnjf3n6+c2IBw5YT\nupOZCrmKXfu9y/aO5bjs6U8Q9mmsaYuyfzhFzrBpCftRa4YW1LjpIcVmaNHiaErHmHRYFrP44BY/\nt7bbPOcJgn6dHb0JhKZxcrYo31VNLjm8UKJUtTmzUEIRgt19MX71pj6WiibpskXZdMgUy3zp+XG0\neDuT2bnGlO98vsL/t2+c5pDOVMbAqJ2rNAdDWI5LvvrSYJthOZRMBct1KVblnRP2a6hCKpYCwkNX\nBYaQie7cekVT6mgHjT9840qaQj6aQhLeVSqV6OrqIp1OMzExgaIoJJPJhqTwSlor15qHfrnX+2G5\nJ1ETSZzbzr3zzjv5+7//e1RVRVEUfv3Xf/2KXvdS8VOZ2F8p6pCwLVu24Louk5OTl339V0vs9YGp\nOoDMMIzXJI/cu6KZ7T0x9g+nLuh9erUEP5Ux5Ig/Us0RCUj+R7ZiE/YpjcXCsKRTkBD18XFZpQU1\nhaotTZ63J11OLTlUbNjWk2BXbzN//fgIh6fyUo0BbFoWJV22SRVN1Jol28HxLO/d1UXYp1I0bDRN\nAQE9CXmDr+uIsqUrhiLg1Og0acfBCbew7+g8DmDZLotFk86mALM5g919cZ4cSmN5HtGgzh3r27j9\nhj4y2RyfeHKUU/OjRP0KNyxPsLyjmZBPwa+plKovqYhWdya4d0snuqpwarbANwZm0RTBnetbSYR0\nQj6VSg2CZnsuVdvhywdneOTEPGVTTvHetS7J6rYQm5dFGauhD0KqYEMCvnFWUDZtPKTJyP85pvD+\n3ctZ3u+ymMmzLlohXSjhU1wMR+7A1Np8wLMjaVxPJqHvnl7iznVJdvXF+ObReUpVi5Lh8U3Dx51r\nrUZ7BsDxFEBw76Z2Hju9yNBCCdP2SJctZrIGbg0prNWQD57n0Rz2yeEvTRpjWI6HZblUatOlClB2\nL7y3PA/u29R6gVm153nEYjHi8TgrVqxoDAiNjIxQqVSIx+O0tLQQj8d/bIeAriaxX457EsBnPvOZ\nl33d29vLn//5n1/lO710/FQl9ldqlXiex9jYGIuLi+zevRufz0exWLxilcul2kD1A9j6wBTXQPcO\n8Ns3tDEys8SoLaVo50bdssyyPUR9F1rz33RcD9NxCfs0XKHgel6NsS3QVcH6ziie6zGTM0iEdW5a\n0cyzZ2ZImypVx2PfaJaAleX4NDXppNzKz+arJMM+uQMQsnWQNWzyhs19W9r5wdASpu3RnQhw0yo5\nlDGaKvHsSAbdMbipL8rOjf384/NTmI6DqG2fLcdlKlNhbXuEd2xbxq6+BCem86xsDXHL6iQegs8c\nTLF/sorlCGZKDguVLHcUCsT9sLtD4+kJE0UImkIBdvbE+PphORz0macnWCoY2J7EA39wby9v29rB\nMyNp8oZNPKjz9m3L+NLBaYYXSrXdjcd3Ti7y2Q9s5Z6N7eTKFqeHzjCatQjE27CHxl4ysRAyyecq\nNt86Po/peBxNBPif77yOY6VTPH4mg+W4LAurtAU9xjPSsxUBVcthoWBxarZEoSKnQxVFLrZjqTKt\nER/TOUP60qrQ2xxEU+WipNWGkopVm/0jGZoCGiXTxnbB81x6EwHSZYuQLhcED9BUFXAwPQ9/bfjK\ndV46NBVAWFfobQ7xnl1dF71Pz62M6wNCy5Yta0gKU6kUZ8+efUUv1GslgLia+Bm298cwrsb31HVd\nTpw4gaIo7Nq1q/FLvdLEe7HwPI/BwUEMw7jgAPa16N49z2N8fJzU4iJf+vCNvP8fD3NqrnRRMw6h\nvKQUURWB7UiFhDSEcAjqGmu7QszmDDJlm5BP4f4tHXzv9BJWxiBdsth3eoa8pUhaoKagKoJDWRVd\nNbEst/G+HNuiNRLm5Lwc0bdsl+awj5aID00R/NL1vRSrNus6IgzPl0lXqnz98BxG1UJVFSaKRXKk\n6I4HONBoPQkCmsrK1jC24xLUFd69Yxnzq5qJ+DWiAY1nRtKMpcqN4RmhKOSrLl1dvSyLavjGRnjD\nXh/jBRdDaEQUi6Du55+en2KpYKCqKsJ1mcnJKc3ff8MqFCHYN7xErlLj+Newvx6ypbVQqPLVQ7P4\nNcHwxAz9LSHeeeMmjk7naQ77KGcrsp/uebQ3SWJjuiRbewt5gz99aJBdfS1s6WuVC2CxzPhCDs9x\ncNzaXIGm0t8coFWryAErIWqLr1QbtUf9PHJ8npNzRQI+jemswdnFIsUa+C0YUChUHQzL5Q3rWtk3\nnJY2i3jMF+QibFRNKo6HqKmmgrqGIlxcPJzzkrrk0Whs7mqiM3b5xtScIymsT1lezAs1mUzS1NR0\nTRUxVxrX0pLvRxU/2e/+CuNiib1arTYgYb29va/6+CsJ27YZGBggFotd9AD2aip2y7JwXZdTp07h\neR47d+5EURQ2d8WZz1fJ1dQT7rnONi7omiARVNFqjJKueAAPj8WiSTyksywWYLEoHXjKpss3j80x\nNC8PFF3HwbRlX95X47RbNSBUT3NYJlTXQxeCO1ZEqJSyrI1BqiqIBPxs7orhuh4l2+WRYwsUqzY3\nrkzwm7ct568fO0OxIpO6UKQZ9un5Ivdv62CxaHJypoCmCta1R0hGfOiaQrZicc8nnqNUtQn7NH75\nxl76W4JEA9pL5qVIRdDmzhATI8NsWdlDJJ7g5OlFQopDqVRiYWGeqiH16/XlVghBpmQxnzf42uE5\nxlJlOpr8rOuIEg/pTGelisZ2XKIBH00BlU8/dZYlw8M3avH9iWN88oHNHveHmAAAIABJREFUfOz+\n9fz9vjEqlsO6jiidMT9/9fhoo5+uqwrjmQp9LUH2nUnjIhno77thNSeWTrNUNDEdm2a/x8P7DrOj\n3c/BeR+LJUmHbI1qvHVLB6fmiqQrNoqQpihV2+HFiRytEZ35gpyu9QmbSECntzmErmVpCurYrnRB\nKlRtslW3xlZ3ifrlbsSwHOyLVAkBXaEvEeCjdyyXU7yvIUKhEKFQiJ6enoYXat09KRwOY9s2lmVd\nttHNtYqfsWJ+wuL8RJ3L5Th+/Djr1q2jpaXloo+/2or9cqzxXknBc7FQFAXbtjl06BAtLS309/c3\nFos71iZ57PQCqpCtEfec67q1dkw4ojKXN9E1wWTWwPE8orrCUrHKQ8fKEvXrl3S/4zMFLFu2bBRF\nolsjPpWy6dQGmjxawn6uX97Mrt4Y+8+m6W328869q3hqOMWsm2ZytkAxX0F1KvQGYnzhZJl0SfZz\nHzmxwHyuTLmQQ1GldZ9pyzI1FpS35a2rW7h9TZL7tnSQLVvYrktTQOftf/cCqaIJAipWlS8enOLP\n3rKOO9cmmckaLNZkmXevbebJw4O0trbxz0dzvDgxgW27hAIa796+jFWrOvEiWb51bJ7FkoMH9MR0\nQprLr/zzAPMFA0UohH1S4fP+Pd1869g884Uqpu1y9/okjw2MkjJkAlUEDC+W+E8PnuaGlc3s6ovT\nFNS4d1MHZdPmH5+dJFO2Gp9n1K/xr4dmG4YmszmDm1e3cN/WDp4+m+bETIG5ks33bA2vqYl7Vlk8\nfsZkpuQxk6nwwX88xBs2tFGuOjiepC56SLbP3Rta+faJBebyVVzPQ9dcDo5lmckasscub0BmswZB\nXZpaVC2HStXFp18I+qrDxzqb/Ny5rpWAfm0T3/leqJlMhsHBQY4ePdrgrSeTScLh8FW5J13Jc37W\nivkJi3MT9ezsLKOjo2zfvv2SOM8rnSStR31K9XJcmq4kTNNkcnKSDRs2XIAduH5FM6vbIgzNFygY\nF8f6Ziu21Io7sqNqOtIJSVUkXMoGFEvapmVKUn4Y8ms4rqQ3/um9a/jCC9MSSKWr3L2+lUzJZP/Z\nNIsFk8mMwanZo2xaFuXIZF7iAFCYNRT0YATLzOG4kvetAMcmM/zyTf2UT2UYWSrhuNDfEmJnb4yq\n5TC8WGZoociXD07T2xxkZ2+czpifsuk2xOBCyAWharvcv62TPcvjFMo2Mc1m3+FT0NmJLxDk+MwC\nlu2iKgLDdPj+0CJrOyI8sKeP9+7p5TP7xzEshzUJlaHJeaYzFYQCiupRNB2eG82wszfO/3P/eiIB\nnZNTKR585hT+YARF5Bu9dMeR7+XsYpknzkh9+tcOz/KJ92zhrvWtPHx0Htvz6E0E2bs8wcmZgvxR\namyep4dTdCeCDM0XsWwbVVWwPcGLU2XetqWTvFvBp8vWV7Zk8viJaQK6huu68qzE9WiK6IT9Groq\nF5uQT6NiORybyaEqsm9vu7WWgwq6pskWnSKwAdt0peroHHxAXd64ojXMe3a+up/pawkhBKFQiHA4\nzJYtWxq89bGxMcrlMrFY7FUJjefGlSbqn1XsP4bxaj1227Y5c+YMhUKBPXv2vGIv7ZUOQy8Vpmky\nODj4skPSaxGZTIaxsTFaW1svypLx6yr/7W0b+M0vDVA2ixccpCoKmI78R0W81GsHuYUP+1UsR0rc\nFM8ioAm29SY4uyR9Spc3h9jS1cQnjVHm81VURfDNo/M0hzRSJclm0YQkJ55dLDWMkz1PYNoe4wUP\nT9HRVAfXlWYgjgczs7Pc0hPlphWdGLbgF2/owbQ9Ts8V+NxzU2TLJpbjMbJUJurXqNoO8ZBGtmw2\nfDdjQZ0VyRAjiyX2D6fYf2YRn1PmvTeuIVuViezcClRRBJqiEAtqBH0qc/kqecPBsB2iTQm61CDa\n8BieJ3k7pu2RyRc5NjrDXz9eQfE8dLfCh25eyZKhMrhUpWBIY4p4SGdrd5R/PTRHyXTwPI+TswX+\n76+f4ObVSf7Drf0Sf6ypxEI6uiYdsag5LXXEAlzf38Snn5KVvaaq+DWBX1cpmHZjJ6ZrKoqqEAj4\nuGNFhEdPpZgpygW9bMBUutTwUaW+ALqy4h5ZKkvEswqqolIwLCxH7ux8Crji4rZ3rVEf/+WelQjP\nxXXFD7WqPTcZn89bz+VyDUKjz+drHMBeair8SoaTrubxP47xukvsrxbj4+O0trayffv2a3o443ke\nQ0ND2LbNjh07XrOr+rkxMzPD+Pg4q1evplAoXPJx3Ykgn3xgK7/zlaMcmy68zD3ec2kkBU8KLgj5\nJfCrarsEfQp7emMcm0pjuwrhgI9MxaJYtbEcl6GFIr/2LwNM5wxUVZH8k7KJX3spcdQjGdEpVB0K\nNdiYqkDJsNndH+PZs2lMz6M56ued2zuJ+ARTS1meOTmNgodZyrKsJc7h2TIL+WpDmmc6Lqfni6zr\niPDLN/TybwOzzOdNkhEff/pmqRF+fHCRLx2YIm9IRMDCkxP83I5lhHSVtoiPsard4OL0JYLM5avs\nP5Piu6eXyJZNbNfj7GKZB3Z3saY9wtlFuUDGQhpv3NjGd4YWObNkogopGfzMc7P8zl2r+Z3bl7N/\nJE1Ak4e63zm1KKWOtcyoqwrzRZOxmvrHA1YkQ/z5fevoSQQZTZXxXIgEVda06GTGTtGfDDOSlobd\nqhC8dVMbFctBUwQVy8GnqqgC4gGN6TI4qkZbVMOwbDm5enSOJr8gqCkUTAfHlQtgQFfkPkoRctjM\n8wj5dUqGhV07nvCclyd1vwqt0QAfuW058YhEYDuO09jNCnHtk/ylqmxFUUgkEg1eU6VSIZVKMTQ0\nhGmaJBIJWlpaiMVijedfScVen434WSvmJyTK5TJjY2PE4/HGsMC1Ctu2OXr0KNFolEgkck1ZGcPD\nwxQKBXbv3k0+nyeXy73iczpjAT7+zo285x8Oki3bNXY6OLxkZ1Z3wmmP6hRNsEyHsuHy9Nk0iZCG\n4UhS5Om5Eq7rEtQ1Qj6VsVQZhMCnKWiKiiKkvC5dsshWLFQFOmNB7lzXxtBCiafPpgGP9R1RlreG\nGRqfYWubzlTZj64qtEX8vHFjKx/65yWWqgJNUfnqySKbWys0qS7Cc7Ed0Vg04iEdw3bZ1h3jtjUt\nvDieAyGIB3XmcgZPnZ6TjBNVyvcmMwaqEPS1hPjje1bxxFCasVSJpoDODSulMuPgZI50SXqL6sJj\nqVSlOazzj7+wje8PLnF8pkDUr9IZC/LQsQWEQB70Cji7WOTbzx4lEAxRrgh2r+1gbUeUeFjnkRML\nZMtmTRopSAQ0HqlJHanhBL53apE3rGtlYDrPwYks2bLNf/rmED+/q4vb1/nxnU1xarZICZevHJpl\nT3+cD1zXw1cPzTCbN9AUwXi2woq2MG5NgYRQ0DS5K7l5TQvfObUoYXGe3E2OLUhfVssVtYNxl4Cu\n0hTykSmZVM/rPGoCmsOSY3P9iubGvV2vaOXwkkzy9TbntehRX+41gsEg3d3ddHd34zgOmUyGhYUF\nzpw5QygUalTyVzJ1Wod4/STH6y6xX+wXUh8M6unpec3yxfOjjvLt6+tj2bJlZLPZa/IajuNw/Phx\nfD5fY3fxaq2heiWVCOv0NIew3ZIcyrnog6FkWBRN8GvyD9hwoOJIz1BFyGnKgK6ha0rDmFmvKXmE\nUFBVQcyvcf/Wdh4+LtUurRGd+7Z28IPBRWkIYrmcniuiGjkS0RBPz5SQwEmPzx+cZiJbZjxVxnE9\nHMXFRZC2fdyzrYuUO8PQYgnFc2kKKKyNQV/ch67Cuz99kKLpENAU7lrXyo64ge3ISr0u7hRAzrAZ\nXizjuA626xIP6TT5z73tX7pfXE8ufsem8yzmq5yoETSTIR+eWcZ1LVQh0FQ5vOXXVTq6uvj8C5Nk\nKjb7R/I8fGiUj97Ww5s2tPDYYBpFCHb2xljZEmJg5qXdlibg0ESWla1hjs8WsBwPz3WxFIVvnU7z\n/j095Co2qiJ3GEvFKvuG0zywq4uqLZMxnkfV9nhxIkdz0MdYWdrzCSGIBXV8uk7VkYnZ8zws06Lq\ngOm5sseOVAMZlkPFdF92n9TlsYoiaA7r/O4dy0mEL9yFKorSUHcNDAzQ2dkph7pq9o31719pXM3i\noKoqyWSSZDKJ53mUSiWWlpaYnJzENE1GRyXP5lKG11f7uj+O8bpL7OdH3WJu586dFItFUqnUNbt2\n/ZB048aNxONxuEqJ5Pma3UtJMF9JHum6L2nJA7rGfZvb+dunxilxIdpXvk+BjcDFpWqDV2spGqZV\nM4SWygnXc1EVlZxhEfFrdER9TGarCOGxojlEJKjxwniOUtVGEQqD8yX+27fPcGq2wFzekKNLnstx\nT2d7NIDnlVGE12C2LBbC+FSFKm4D0yslmYK3bF2Grgp29ycYncuylMliLY7xW4+WmM3JyrlcdfjW\nkSmW703yO29cz58+PES2LGWba9oi6KqcqHzw6AKn54ooQjpR5Qybbd0xblnZTN6wWCyaOK5Hf0uQ\nvpYQn31mkmzZxKepqLjc3a/xJ29ez6f2TZKt2AR8Cjt7YjxxJkWhKt2bFCEYzHh86dACTUqVbQnw\nBYLcuiJKNBQi4leo1A4/VEWwsjXC2vYwVcvGsWVf169J+qLneVQtt4EglkNJLobt4tSnTWv3jON6\n3LkuyRcPyJkDUZM9pspm41qWaaFpqpSleqC5Lq4neetl073o/IMqIBZQ+aXr++hOXNov1HEcjh49\nSjKZbLBOXFcqfeoV/bntjctJnK81wQohiEQiRCIR4vE4c3NzBINBJiYmKBaLFzW8fq2ve/LkST7+\n8Y/zG7/xG+zcufOC7+/bt49HHnkEIQR33XUXd9xxx6s6L11tvG4T+8Us5iqVylWpXC42LDE9Pc3E\nxMQFKN8r1abXJY/16xeLRQYGBli7di3JZPKCx17s2ucm9fp13rWji5GlMg8dmydbuVAlowgPrZa8\nFSFPV8OKh+MJaYvmeIQ1webOMEuGx3zepSseZG1bmLmC9N6czhsMp8q1dUM0vE8PjmfxAJ+qYNmy\nNRIJ+EiXTSzHQRGyR+950BYNsLW7icNTOSquR1eTjzduaMO0Xcqmw1PDKT755BhNQY37t3aSd8M4\n6gxCVGTywKOKINoU4br+BH/2lrV85+QC3YkAt69NcmAsR9l0GE9VGp+N53mMpcq8Y1snb9nSztu2\ndfCVF2eYyRnsXZ5gPF0mXZLgNMdxqDouh9MB+vI277uum95EQLJoxjKcmC00fn+aIpOsFozy/IzH\ndNYAr8ihqbP89jaVjqBg0vKwXA9V01nXEWZVxKEz4DLuiAbSYXdfnHRZOh6ZtkPEr8tdlCI4NZuv\nLU5KrdJ2aAnrpIomYb+K44Jpu5QMmxPTBVpCCtM56asrLIe2qPS/dTw5mRzyq5i2c0ELRtQ067et\nbeVNGy/NB3cchyNHjtDR0UFX10uTqJdq2VxuNX8tK2fHcdB1nY6ODjo6OvA8j3w+/zLD62QySSwW\nQ9f1q3rdubk5Hn74YdatW3fR7xuGwVe/+lU+9rGPoWkaf/zHf8yePXs4ePDgKzovXW28LhN7HWaf\nTCZfpvW+Gl16PVHXb1DP8zhz5gylUondu3dfoKq5WkyAoigsLS0xNDTUMMe+1GPPjXpSP3/hURXB\nH929mtaoj395foqF4stNs21b6p2VOurXdVF1jZAqMF0V23HRFZjPVcgYDlVbcHahwOiS3O4HdZWy\n6VIxbaTYRuDXJEHSA0IaZGqMGQ9oifjY3hNjJltlqWiiKwrdiQCxoMYtq5M4rsfZVJmuRJCWsI+A\nrvCFF6ZYLFaxPchUbL59fJ63b+skGtDk4Z8jE2o05KNTq/A333yGYynBbBkOTah0NAUkwrjGUa8v\nPLbrkavYnJwrMrxQZDxtcGKuQKZs0Z0IEPZJ+Z/nStNuF0FQ18hULD733ASm7dIe9fN7d63gA3u6\n+V/fH8GwbBCC1a1hFotVJjNGzcsU5g04XG3nrnUO3zu9xNm0SaFi8odfPcaeDpVbN/bwzGiGwfkS\nPlXh6FSOdZ0R3rA+yeODSzV7QEHUr9IW9fOOtghfPjSDIeU0LBVNZnKGHErzPDwh1UhVy8J1bKRl\n6UswM1URGLYcYivWtO/nh67C9maP+7oMZmZmSCaTF/gF2LbNkSNH6OrquuSsxrn37rmHmfW2oW3L\nad7zD2B/mO5JQoiXGV7XLfIefvhhjhw5Qnd3N9FolPXr11/2cFQikeD3f//3L+mcNDw8zMqV/z97\nbxoc136ed/7O1ju2BtAgQWwkAe4LCN5LXV1dXSWWLCmxrSiOHduSJdty7CSjscsapyqKVfZoSpET\nly3PjEaOyzXxlGNHydiJY0mOPE4kK1rvIl5u4AIQG7ERQG/ofTn7fDh9DhtgY2kQ0MJ7nyp+6Gaj\nz+nuc97/+3/f532e4x61+uTJk0xOTjblvNQMvv+LSZtQrVZ57bXXGBoaesw31KU7NoP60op7IQOM\njo42pEruVSZgcXGR2dlZnnnmmYZBHR6XFNgqqLsQBIF/9JYh/sW7RugOK0R8Dq8ZwP0W7FpT1TCd\nDC1R0lkv6aimjYHIw6JN1ZawcHw0C1UTTTe9mrUiS5zrbSXsd9476JM42iZxJKDTFw3hlyVCPon/\n6a2D+GWRv3O2m2hYwS8705unD0W4t5pnfCWPqpuMLxf49FcfMJ+usF7WPb0bUXDq5TbwD0djnGqH\n3jY/w7EI/+YnL3JkaJi4EGVi3SJZMljNVfmtv56kzS4gWgZHO0OOq5HgGFA/d8yRI3h5Pst/ueVM\nmK4Xq/zX23F6IgqXukVCihOMomEf7zzTzV/fjZOvOEqa8YLGb39plnzV5AdPd3O0O8y7znTz+z91\ngWhQwa7RF0UER/GyouMPhohXnGEcQXCa2NcSJoX0GoVSlZpkC/GixmsLObojTpPZJ4kEZMdI/Bsz\n65R0E91w3JRaAoojLVxQUXWHsqnqFpphoekGgqzQFvTREpCRJYGSbiNLYk1l8/EinQgcavVx5WiU\n3/3gWzh1YgRd17l9+zbf/va3mZ2dJZ/Po2kaN27coL+/f8eg3ug6liQJn8+H3+/37iO3CWsYBoZh\nfMfck1yLvPe97338s3/2zxgeHua1117j137t1/ja1762q2P4/f5tz7feYQmgtbWVbDa7pfPSk+Kp\ny9j9fj+jo6MNh46eJGN3m6QDAwMbtpyNXt9MuUcQBKampjBN0ysZ7XQublDfrZ7G3zrZxR98c8Hh\nL2+6k92Hogiq6VDrzFrj0bRqZtmWTcgnYVg2vhqbJl3U0HSLdr/A2U6I+MJMJsqk8hXSeZvjPa3k\n1SqqaRKSZP755yY5cyjCtxechqpPFrFKNp/+6gPUmkSBbQu1CUqDdEkj6JOoGiYSzuBNQJHIFcsc\nFxJcOnqIqw+LdEf8vLqQ4cXjUeZTFUeRsNZkVk1Ilm0kLcGzbSpn2sNYSgBZ9jEccxbPlVzVU7F3\n5QReuvuAd57q5ucOdzvyAoUqIZ9cO8dHteJU0WECTSVKpIs6V6s5ZlMlfuLZPr4xt+5M6YoOa+cD\nV47w6oPso1KEAEG/QkCROHKkF+3hkuNQZDkZbFV3xvpVw3L6FE5R3WE0NTCTBuiK+MlWTKeHgY2B\nREAUSZUcLfeacjOG6dTXRXisYSrVnKTeNtJJJKAACuFwmKGhIXRd9/jjqVSK9vZ273p/Et735mze\nNE2y2Szt7e1egH+SIN9M9q8oCsPDw1y+fNnbVWxGIwelH//xH2d0dHTL992K9LD5+f0SP3vqArso\nivs6SSpJEplMhrm5uW39TuuPsdvFwzAM8vk84XCYs2fP7hik3feu5w/vBn5Z4r3nu/n0V+Yxazfz\nYzK/No7hAo5AmCw5Y/Rhv0ixalDWHDPjQ60BfvUdx/nf/2aWhfUKWQ2+MldyDLJrdVtFlsiUdXTD\n0UTBtslXDBYyFXyyhGFRqyeLxPMqAx1BbMCwnIEgnyTSEfLx7jMx/vu9BIGaPds7hyP02knuGjH+\n061VLOBByqmHH2rxc7g9wEyq5PFcwj6RshCku7ONRKbCl+/Gsa0iftFCqISJRdsI1ura1GSNRSyO\ndHfzl9Ml5l5OocgCfe0B/u65HjpCzkSuIjl9iM6wj69Np7m35kyP2rbNv/yrKd5/5QjvONXFS3MZ\n0kVHUXI5q/L3LvbwxZuLzFUhoEhIosDzxzrIqxZtIT/rFZOQT8EwdATL5N7MA2zDCUiKJJOtaNiK\nTLqscbInzK2HBXTTRACOd4oEfA633bRsZMUpp5VrUsWWO7ugQMV8XDLARcQv8Q/GDvNTDZQbFUUh\nGo2ysLDAhQsXkGWZVCrF7Owsfr+frq4uuru7n2gwTxAE5ubmUBSF3l5nwvVJOfPNmmy4rxUEoeGu\nvJGD0k6IRqNcu3bNe7y+vs7IyAjRaHRXzkvN4qkrxWwHWZabDuzVapXZ2VnGxsZ2DOo0sSuoVCpc\nvXrVE0HaTZAWBIFqtcrExATpdHrXC0ihUGBEWOPtp6OE/RJyg1/dL1PLnB02REk1KKkGZdXx2hRw\nZH2TRZXf/tIMiaJGyCchiyLpsqNG6FdEEAUMy6RYrGAYhjdl6n6+kCIh4NR3DcsiqEi8ONLJoVY/\nPskZqDnVEyagiEQjCj98/hBVw2YtX+HPb8aZt2N8bTbj7SoAHuaqVHWLf/33T3P6UISAIhENK/zI\nhcO0BBRs4L/dS5JXTUqGQMFUuL0ukM0XeXuszPE2Ab9ooWDxlqMdWLKfibUSVcNEN52hpW/OrPPe\ni4e42N/KyZ4Ibxvp5IPP9REvqF5Ql0SBVFFlJlkmGvLXdHWcMsnvfnmGT/zFdZ49EuT04VaqtSbq\na4s55lNlBjpCxFp8qIaJagmIso+qP8r5I+10BATSRQ3DBAmLgGjTFvQhCo5Ub0ARmUmWyBWrWKaF\nAZQ1E90WaA8rdIYVwj6n/KJZAn7p8WtNqC2En/6Jc/zTF482vB6r1SrXr19neHiY7u5uOjo6GBkZ\n4bnnnuPkyZPOlO29e7z66qvMzMyQzWabykBdJVRqNWhJkrySjc/n21Cyccs1u7kH9tMWb68YGRlh\ndnaWUqlEtVrl/v37nD592nNeArZ1XmoW0sc//vHt/n/b//xehKPXsXXwXlpa2pX9lDsclM1mOXv2\n7Ib62HbIZrNIkkRLS8uWr8nlcty6dYvTp0+jqiqtra07Glm7pZcjR46gKAqpVIqZmRkymQyWZREI\nBBpekKlUivv373Px4kX+zoU+uiM+1ks6qZKGYD/K3HVrYxZn2+CXBRRZoqoZaAaEfBKRgEymrKEZ\nljPUI4vYlolPkbAE0anNW9Ae8RP2y+imU5NXTYuekMRzR9tZzWv4FMc+bzAaxC9LjPa1Mpuq4Jcl\nqoaFLAp0hn187lac9ZKKZYNqi5g2ZCs6Fe1RKUoSBD70ln6W16tUNJOSZtISUHj/lSMkixpV3fIc\nmoQaN9uyBcaOHUIItTPQKpPNFfDLAiOtJmt5jbmMI5sgSyKaYeGTRPqjQW49zFOoGsRaAnzwuT5e\nmk2zmlWRJIfV0l4zpb4fL3rG3wBVVccWJJ4Z6eUbM46aoygI5CsGmmXzAye7mKjx5sWaPr5mWrz5\neBc3HhZrOygJ07LJFis8zJRBEPErEoosopsmCjpFU3wkACfYdIZ9xPMaqmmjW04/ZbPchE+E9qDC\nj1w4xE9c7mt4/VWrVW7evMnJkyc92d16KIpCW1sbhw8f5tChQ5imSTweZ3Z2llwuh23bBAKBLTNn\n27aZnJxEkiROnDjRcGERBMEL9vX8+UassHpkMhn8fj/hcLjhsetRLBaxLItYbGsmUCNcv36dP/iD\nP2B6epqpqSmuXr3Kiy++yOc+9zlEUSQWixGNRvm3//bf8vWvf533vOc9DA8P09fXx9WrV/nCF77A\ngwcP+NCHPrRlxaEB/ret/uOpK8WwjWribksXhmFw+/ZtQqFQ0z/wTqWYtbU15ubmPPGx1dXVHbOO\n+iapJEmeprVt2xSLRRKJBDdu3ECSJGKxmLcdXlpaIh6Pb5A4eO9oLz94OsZP/j/XWEhXGu7Jvfqr\n5SgGmrUFQKgNLgmAURPzsixHjuBDzw/y5zdWqWgWgujUgv/R8/3cfpjnK1NpQhIkijq3F5KcboPx\nNBQ0m1zVJFs1yJYd+QJJFKiWLYrVLH5ZIJGvONoutUWrWDW5MhTl5bl11ks6CAJvHYlyvDvC//E3\ns3zxboKK5jA9/sXn7/GJHznF+MMCPllAVW2CikRFN4mGQ4T9Mq/NJfjqdIZgQMEwLb6ZEHm+30dQ\nLqGbJkZNu/ZkT4TP3VojWfMMffnBOr/xlwbPDnawmtNIFR3Fx+OdIV4c7mAhVQLb0TKXbBNEgVh7\n2DM5cSHUJIABqh5v3VmwKrpFVTcf8dZrO0LZr3C4RWI6WaJcayjLgCT7CMgWYZ/T8C9pljP8ZTcc\nZXDer0ad7Gn185EfONbwNZVKhVu3bnHq1ClvXmM7yLJMT08PPT09HrUwmUx61MLu7m66urq8AGbb\nNhMTE159e7f+wmzaIdeXbNxeSLM9gL32C8bGxhgbG3vs+XoHpeeee47nnnvusc/RyHnpSfFUBvYn\ngZuZuGPKU1NTTTVctxpQsm2bBw8esL6+zrPPPuvRqHZydXIbpVtlMC0tLbS0tHD8+HEqlQrJZJK7\nd+9SLBZRFIWzZ88+RtkK+2VO9URYzlQaij15n6UmL1tj1TnZZM2BZ6DNz0pOxbQd151XHmQoawaK\n9CjL/eKdBOmShiI506CqZWP5gjwom1RNFREbVdVJ5Zyb0CeJVA0LQYCqYVLKZgj5nPF3142oM6zw\nU88c4dzhFj791QcA3F0p8q3ZNNcWc1Q00/MpXS/pLGUqdAQV3naik1cfZAn5JGwb3nUmRj6fZ3w5\niy1KzqIpCqSLOnIgxHvHwtxbKWBZBiFBx1dOkik6ps9CzezifrwB745+AAAgAElEQVTIm49Gef5Y\nlL+6G0c3LG4s5/mdv5njbw1HuR8vsJAuYwgC0aCPgY4As4kisuTQDSXR0bYPKiLJgopfFr3AX1YN\nFFFBN216Ij7mUmXUWtO0JSDxT956jF/6s7sea8ingGoY5CsWZu27kmu9EsO02CpUBhSRY91h/tV7\nTxP0PR4OSqUS4+PjTe1aN1+jm6mF7i5SVVWi0SilUolwOLzroL4ZmwefNnPmXUrlbvA0KDvyequx\n74RcLse1a9c4efIkfX3OlrTZSdKtuOZ37tyhUqkwNja2IdBuleG7HflmtKSDwaBXqjl06BBDQ0PM\nz8/zyiuvcP/+fTKZjLeT+bV3jdAVUag52D2G1oCIYVmUNEcZUZGcppymm1i2xcOc6ui01PxB78eL\npIoOTbJc+xvNtCipBqphoZvO58iW9JoDkYgoSSiK7DS8ZZuKqmIaBoZhItkmRzpbeMfpHk4diiAJ\njonycHeIoc4Q/+7VZVTdRDMs1nJVPvXlOdqCsvf5bJya9+RaiaphEVIcE45i1aA9KJNeXyeTzRAI\nhryeg2rYiCK0BWTuPMwznSiRKBpIwRaO9PfjUyRM00K0TVRVRTANVE3lxlKuZhbuCJ7deVhgab3M\nsVAVnyyhiCKGafJXd5NYtsCVwXZCPoli1cSwbNbyGpNrRZ4ZaMUvixSqRm1HpLOSq3DmcATLdmia\nflmgrJn88beX8Us2EcWZDhUEAUXx41Mc71SvxGY4JhqNrmBFhB8+F+Pf/cwljnY+XqZwTd3PnTu3\np6DeCIFAgL6+Pi5dusQzzzxDoVDwfFHv3LnD6uoquq7v4p22hiiKKIqCz+ejVCpRKBQIBoMYhrFB\n06YRngb3JN7I2B9hdXWV+fn5x/TZm6VISpKEqqreY3dYqru7m8HBwV25KNXTrJrJYNxj9fb2epTM\n3t5eTNNkfX2d1dVVJicnaW1tpbu7m3/3gVE+8dczTMWLrNdYLO6ZZKuPzsnG4bnbgCA76n9CbcRd\n0k3agwplzcRXM6kWahlzNKSwlneyetO00EyLs4fCyLIjlavXagRDnUF+4vIRXn6Q4etTKcqqiWTD\nTDzL20a6GH+oO1RAQeDz43FsBIrVR1mYIAgUqgb/6/su8FN/eM0xsxBszve309sewLAs/ts9R8vG\nBopVlUJBZPRoD88fFfnW3DrpkhNMTsQipEo6k/GSo41jCNxZzoENbznWybdm1ynrFrIsMtLl5+HK\nGqWShmnaXrkI2yadSrJuhbFwdN11CwzTJFvVOdXTgqrbRPwSmukwgQqqM8xV1kxagzKiIGDbsJKt\nUjUc024XVcMikSnUDMudQSrTtNFrgl4CJmXdRt9iKybisJJ+6HyM//WHTzd8TaFQ4M6dO5w/f37L\nuYongVtTd02vqS0kyWSSGzduIIqip/uyF3MNav2uqakpRkdHPaZOvWgZm0o2vKEV872N7ZyJNo/w\nu03SfD6/5SRpsxm7+/pSqcStW7cYHh7esla/ObDv1AjaCqVSidu3bzMyMvKYG5Rb13TdaXK5HMlk\nknR6jn98OkD3i0P8+t/Eub6UQzcbl2bc7b1h2siyiGHZSIITIAzLplA1aAvI2EBBNbBsgQfpCse6\nQsynyuSqhhNQfDJnesKkSxoziRIgsJav8sxAO1+fSmKZJmG/M606W5B5uySwmC4jCiAIIpoNr8xn\naA3KFDXD4d3bNh0hhfGHeX700mE+f2uNfNVgPl0h5MtxIhamXKsn2ZaFKUJV8HG0O4xmWsQiPnyS\niInNm452MJ0oYVrOhKYgCFRMk0xZ47mjPUwny8yny/hlkfsZA70zzLHDYTILOQzDJK2ZhGXo7WhD\nL8lYdsUZjMJZNIOKhGpYGLaFjFTjzzsToYbp6MBQJ2OhWzbdEYXF9TI1gylkwUYW5dpi4byvCGTL\nOqVNYl71cOUjIopAh9/mHd0lFhYWvODpIpfLce/ePS5cuLCrhmOzsG2bu3fvEgwGOX78uPe8W1Y8\nduyYl8XPzs5SLpfp6OjwmDi7CbzZbJbJyckNQZ0GnHn3nzsUpOv6G4H9+xFu4HWpj7dv3yYQCDA2\nNtYwkEqS1NTW0A3UrqLk+fPnt93G1gf2vQb1TCbD5OQk586d25aN475ve3s77e3tjIyMUCqVSCaT\nnAqXubbDxqRVgaolOE1T2ymNaKZFvGa/VqiZPcuCwKG2APmKxnRcR5FFwj4JBIHZZImH2Sol1cCv\niN4wzr/84j3mEgVEWfY+e75q4I90IMsJR5DMcvoNlVKJX3ymnf/zqkq24lAK33ysg9VclYm1IgXV\nUXksaSaT8SJdEdkZpzdMgoqAYTvsFYCX5zKMrxSIBJwyzn8djzMSC6OIArJUozEKAqcPtaCblkNv\nrBlaa4bFfLrM+6/0IUsC35hexy/Z2KLI5yYLxPwWAQGKmoBu2ggirJc02gIynWEfpapBUTUAm/72\nAO0hhb62APfWig7vXICTsTAD0SBXF3Je01WUIBwKIeWL2DWbo7aAhGrYSKIj09wINtAWVBjpDvOJ\n95ykOySRTCaZnp6mWq0SjUYJBoMsLy8zOjq6pXHFk8A1jg+Hw16m3gh+v5/e3l56e3uxLItMJkMy\nmWRqaopQKOQ1YBv5HmwV1Ddjc5CvVqvkcrl9Kzt9N/G6C+xuzdyVB3CbpFuhWe0XSZLI5/NkMpld\nuShtpmw1u+VcXV1laWmJS5cu7WkwJBwOEw6H+dWBQV5NfZvpZHnLhmpryEc+p9VNqzpWcIokEVCc\nyUzVMAn7HK123XIkYbVaVtkWcDRYkgWVcs3VyC85dMV4poDk81PNq06NtEYfPNvbwuHWgGOdZzs7\nhA88fxRbMIn6ixTKTl38z6495Fxva41Z4pyfUJOkzZZ0LkRt7q5LVAzHJKMjJHs+o67Qr1WjUp48\n1EJHWOHLE0mKVYOgz2Gg9HcEHFZQjR1UNS0ificwzKwVEbDx+31opoUkCLztfD/XFzJMxYuINYmB\n+2sFOgIi/3D0EJ/5+kItixZYWC/zngsxdMtGrrlPyaLAYrbqZNk+Ccs0EEQRzcJTibS98zZrImRb\n/9atAYm3n+riV37gGB21ha1ey9yVtVAUhZmZGbq7u+ns7Nw3M2m319TS0sLRo0d3/XeiKHouSfVy\nvOPj41iW5Q1GRSIR8vk8k5OTXLx4san7QdM0JicnOXbsGIODg3v8hN87eF0G9mw2y8zMDKdPn27I\nyd38+t2WYmzbZnl5mXK5zAsvvLCr7rooimia1nRQd1k2uVyOsbGxJ274SKLAZz/0DJ/8/6a4upAl\nU9YpbJL8W8ppGx5rhk1YqdXaNznWF1WDimYgSyJ+ySnXKJJIpuQMNomiUxdXDZOgBJIvzJv72/jr\newmKqolm2Ax0tPDKgwzvPhvjz2+ski46iov/+Wact410ktVFFJ/i9CQsi5V0js6AgKo7DkERv9Mw\nDeg5jvZ1slApoJVUQj6Jq/NZEgWNqmaieC5NTp/ALzuiLYYFkYCCIolMJYrohkVHSMYsWqwXnQVu\nsCNAPl9A0zQkUcLyJHVBEgRyVRNFkbEFZ8ExTAtBr/CX1zNOKcsvIYgO9/zqgqNE2RJ0PpOAgKqb\n5CoGedVxZBIEG8uyiecrWLbtZec2j/PTa6eBALQGZX7vJ89xqb/xkF02myWRSPDmN78Zn89HoVAg\nmUyyuLjoqR92d3c3w7HeADeot7a2MjQ0tKf3YJMcrytzkEqlmJ+fJ5fLYRgGIyMjTTmYqarKxMQE\nfX19T0VQ52kN7NsFSE3TmJ6eZmxsbFcX6W6bp64mtSzLtLe37yqo27ZNS0sL9+/fJx6Pe3XwnZpF\nlmUxMTGBKIpcvHhx32qCAUXiE+9xmmmTS0k++Cd3KBtsWbMFZ9rUNiyquoVp13jRkkCmrKHXDDUq\ntkVIEcmUdTTTeV1fRwAfJvEiqILIWkmjbb3Ci8Od/I8phz2SV3X++JVlnj/eQVE1CPicwFmoGrw8\nt45qWF4tXJJEWiJBxgZbEeQ09xJVMiWNgAhpI0RMDpCrrD/qrSBQVE3edqKLL08mKKsGogCXB9pQ\nJJG1fNVThnSchhytmref6uZPXl0k6BORRIGJtQKr60X6u1ow8irrJQ3DtIn4ZUzbJuyTyVZ0NMNp\nkvplkcHeGJavzMMH6zUGkYkigmhq2DZkSppH7/TLIppcxLZrIwe2U24xLGdh3W6uUxQceqhflvjQ\n8wNbBvVkMukZu7sBsbW1ldbWVo4fP96Qotjd3b3Bfm47WJbF7du3aWtre6Kg3giKonD48GHC4TB3\n795leHiYfD7P1atX8fv9Xslmq+xdVVXu3btHb2/vvp/bdxNPZWBvBNu2mZubo1KpcP78+V1nHrtp\nnqqqyo0bN+jr6yMajTI1NbWr8zFNk3A4zOXLl73MY3Z2lkqlQmdnp3fz1Ad5V2mvs7OTgYGBA7Hw\nSqfTZB/O0tcZYjpR3jChuuEzAEMRgzvpR7Z7sojnKxr01UwjLGd8vrfNT6KgUtVNpuJFIopAS1Ch\nK6KQyKvcXM4R8dWoe6JTokkXVV6dW6dqWPglEVEUMCyLsm4Sa/HxIFWmotv4ZUcbpS3kp7Mtgi9j\nIBoGflnk5kqZcnkRw3A497ppIeAIm5U105FREEUCikCuYjC+nKOqm/hlh9uu6RayJNAfDZKvGmim\ns/soqwY+EcKhAJcHOyhOJylURbAtKrrBf7q2wkfffZzP/I954rpV08Mxubmc59fePcLXZ9IbdNAN\n00Q0q9h1A2GWYdEWCdOqqZimIwwW8stY9s7JRtgnEfHL/P2Lh/mJy70NX5NIJJifn2d0dHTLLNel\nKLolm3qGVUtLC11dXVuWbNyg3t7efmDZcD6f5+7du15f4NChQ1Czw0ylUty9exfDMLx7qrW11dmh\naRoTExMcOnSoqdLQ9wNeF4G93maup6enqWC4UymmUCgwPj7OqVOn6OzspFqt7rgQNGqSupnH4cOH\nMU2TdDrNw4cPmZiYoK2tjVgsRjAY5M6dOwwNDe2Ly0ojrKys8PDhQ8bGxvjdEYOf/5MbpEu6x77Y\njGuJjY81E3yiiGFRa+Q5EV+o0fQkUUCoMT90W6TN57gKubVi3XQmWrsjCtXa871tAbIVk4Kqo4gC\nVQ2OtAd520gnX5pIMJUs0xqQSBY0vng7jiTamIbhOBL5ZSqGiuVrobdNYyGjYqkmER+M9Sh8YzGH\nZdsEa+Wh6USRd5+JcbjNz3pZJ1HQsCybnlYfAdmRJpZEEUPXPcGmoE8m4pfIV01kUcRXq7sHfRKF\nqoVuQXuNY28DD7MVvjyZJOST8CvOwieKsFSESKSFqOUYwqiajWbBwnqJfOVRPV1rYJyyGUFZ5E1D\nHfz8Wwa42NfW8DVra2tef2a3dfTNDCvXsMIt2dRPlVqWxfj4ONFodIMT2H6iUChw9+5dLl68+Fiz\nNxQKMTAwwMDAAIZhkE6nWVpa4pVXXiGTyTAwMMCVK1c2MHOeFjyVgb0+cLuTpEeOHKG/v5/p6ekn\nHjhy4TIKRkdHPVrYTs3W3TBfXGmAWCyGZVlks1kePnxIIpGgvb3dm6jbz0EK27aZn58nm80yNjaG\nJEkMdfr43D+5wr/52gPGHxZYXC+TLRuO+cQWNQAbqGoakuCIirlKkn4ZUgUVy3I0S0TB0aKxEaho\nJhXdCfoD0SBreZVC1aKkGbWyiMqPjR3iz15bQbcsArLAVKIItk224mTliiSiGiYL62XafDYWAn5R\npKqZBHwKF/va+MbsOoosEZBFTMtmfLVIuuDYx6EIqKZTke6M+JlLlVgv6QQVp/wTz2vcWs4R8kmc\naIObCVANAIuzvRE00+GlF6uG8+FsG7+sONLHtlXnxYpXO7drqbkgOME9V9GRRIFM2QDbKYEFZVAt\nCctubIhRD3e31OpX+M33nuKtw11bvnZlZYWVlRUuXbq05+uofqrULdkkk0mvZGMYxga7vP2Gy7W/\nePHijjvwepmD4eFhvvzlLxOPx/n3//7fE4lEeM973sP58+cP5Dy/G3gqA7uLfD7P7du3vWyaPfDS\nt8rYFxYWiMfjPPPMMxu2sLvxJW1mx+Ceb6lU4rnnnsOyLBKJBAsLC/h8Pi972klEbDu4NoLAYzX7\nloDCP3/XCQBuLOX4x5+9SblRl64GARg51Mb9eIH1iuU9F5ZMsrrT4BMEJ5uv6hZ97Qr342pNARJm\nkmWGu0JkKjo2NpphsZit8t/uJRFEgc6Qn2xZQ9UtppMlJFFEFhy5A8M0CUjwpmPd/I+Zdcq14DnS\nHaaqm6RLGrIo4JNFSqpBRpM4FmtlKl4kWzEQsYkGBFYSKebShiN/KzrnIAoCh1r9tFhFXk5ZhP0y\nouiM/1+dz/JD52P8rZFO/vClJSzbaUa/uTvM6UMR2vwy93PlGpsGTh+KsJJTHS0Yw67poMOl/jC3\nVwrYtQK7KDgBSRKd/zfrGqWbIQnQGpCJ+GX+57cd3TaoLy8vE4/HuXTp0r6OzwcCAfr7++nt7eXW\nrVu0trZimiavvPIKLS0tHstmPxISN6hfuHChqYauYRieS5krNpZKpfbd5P67jac2sLvKcvXZNHuQ\nCNjcPHWDoGuMsbl51Oj9mzXGqMfi4iLJZJLLly9722VXG6ZcLpNMJrl9+za2bdPd3U0sFmvqQneb\nvu3t7RtsBBvhUn8bl/rbeXU+g2HZDbN2G3hlPrch+DhDSw7/WsbN9gWU2nCTXxYRRYfhYVo2RU3H\nthz+uCw52XW2rBPyOzVx23ZKDSG/TF97gLsreaplA0GANx1tZ62oIwoCnWEFzbSYTZXRTCdABxUn\nkAk1+mWLX0IUwbIEREnCkiTuJHXSxSq6bqMgYlogiyJGOYcaCFCxnCkuf02LIOSTwBb44p0EHSHF\nMcOwLGaSJfJVg4ph4ZcFr7mcyKscbg3gkyUEwfF+DcgCS5kqsu0YZbuLScmzHtweIRl6QvDLb+vj\nxTNbl+mWlpZIpVKMjo4eiCaKaZrcunWLWCzm0YjrhcDm5+dRFMVj2eyFK18sFr2g3swAlWEYTExM\n0N7evkFBcrO38NOApzKwx+NxlpaWNohtudiL9ov7el3XuXXrFtFo9DHbPRebn9urPIBt20xNTaHr\nOpcuXWrIPgiFQgwODjI4OIimad42WNM0Ojs7icVitLS0bHlcVVUZHx+nr69v1/Zm/9dPnuc3vjDJ\nt+bWqWimM6y0+dwb/J0oCSCKmLaFbtgYpo1RNmiTilR1pzZPzWuzpyXIfLpEQTWcBUASOH0oQrqk\nM5ssYdigiAJvHWnn3mqesCI4gmIW3F0tEqw1YKlppciiQGdEIVVSKVQNippjtH3+SAtfuZ/CJ4n4\n/BKq4XDrLw12UtZ0vnI/TU5zNNkDkslaQaLP53DK18s6dm1Iy684Tk+q4fQEfLIIiFjAcqaCbti0\nBJzr0LJtMhWd2VTJY90YtkVFt1nLVTBsoaY74yxy27Jeas5XZw618Atv6eN4i00xm+aVV5Zpa2uj\nu7ubaDTqBfCFhQUymcy+Mqnq0Sios6lkMzw8TKVSIZVKMTExga7rG1g2O90jxWKR27dvNx3UTdP0\nmr0nT548ENLB9xKeysC+3ejxZi2XneAuBOVymVu3bnH06FGv674T9jpJ6jZ7I5HIltrUm+Hz+Thy\n5AhHjhzxGkULCwsUi0U6OjqIxWKelRk7SBBsexxJ5F///TOohsOv/vpUkn/132fQDJstHNsAONYV\nYmG9QtV49CJFAkHxY9iqp5WumzDUJjGdcHcENrppk1cNSppBS0CipJmIAry2kEHVdAKKgIyCaNmY\nlk1AEiipTgA1DIv2kMJQNMRMskzE75RiKprBN2fWyVUc15qALNZ44k6mP7lWQJFEIn4Bw3C01Ntb\nI7QoNtVqlZJKbYgIWv0Sbxps509fe0hJc35vRRQY6Q7y2kKWnOtAVZMWaA3I5CuaIy/sMmAAn19A\nU51gvhUTCUCq0Ux9ssCVoQ4+9Q/OPZoj6DuMZVmebMTs7KxH9bNt+8CDek9Pz7bWkdTE6vr7++nv\n78cwDNbX1z2iQGtrq8ey2VyycYP6+fPnmw7qExMThMNhTp8+/dQHdZ7WwL4d97xZUS/XXPbGjRuc\nO3fOkx/dCXsN6m4WfeTIEc8arFnUN4rccex4PM79+/dpaWkhHA6zurrK+fPnd5Qg2Ap+WSLWIvHe\nS7385xtr3FsrINYMOhoFpJsrpceeaw/5qBg2fqnmvlkz97i5lKWiGYRkAdMWQLBJFTR8kmOQEVBE\nTEvA0DXCPpGsKqAaBrIg0NXi41RPhG8+yIBtY9qO2uQrDzIUqgY9rX5k0Sl1hP0yfkVkLlUmXtDA\ndqzhvjW7zkK6jCKLqJrmyE9YNofbQ+RVE1Os0hGy0XRHwng1tc4rEwYBWaRcC+xONi7S2xZwPEgF\n9zlnISiolqN5LzwaItL0Rxn6lkFdgKDiWAf+yIUe/umLRx8bDhNFkY6ODjo6Ojyt83w+jyRJXLt2\nzSuD7FVcazNM0+TmzZscPny46WtWlmWPKNCoZOOybFzaZLOiZG6mHgqFOHPmzOsiqPO0BvbtIElS\nUy7gq6urVKtV3vrWt+66HuiaX/v9/qYuJLd2eOLEiR0nYneLzePY8/PzLC4u4vP5mJ2d9Yw59jo2\nLosi//cHLvJL/+9t7q0V0QxHadAVDduulKBbFhGf5HG8ASzdZqing9lsCt2qmUcL0BMwmS/Y5KuP\nGrJHuxVUFOxqFdN2yjuaYXF1MUtn2EdAEVnLVdHNWh1fgERBRRYdc+y2oMxcqkzYJzsTo4IjqhX2\nS8RaFKbiZWwBTM0goIhMrBVpDTrTrLphYSIgShAMhskbMpph4pMc1osii6SKKh1hBbPGAhIFpx6f\nrjj+sHrNh1SosYyMLb4s93tURBjsDPOu0138+OVeYi3bj8zbts309DQAb3rTmzzudv28hCuuVb+b\nawaGYXiKorst522FrUo2d+7cIZ/Pe1Tg3faqLMvi/v37BAKBXXkKP014XQb23WTstm17tl7hcLip\noD44OMidO3eaamiur68zNTXFuXPnDkQmlVrjbH19neeffx5FUSiVSiQSCW7evIkoih7DptmGVotf\n4Y9+Zoxkvsq3btwFUeF3r+bJlo1t68TZskG+bGz4f0mEomY4NMkaFRBAExQiskqxZsYtCpBSBSTR\nYiAaYiVXxagNQgUViWxJwxYENMMmpIgMdYVYylTRDAtbtLCwSeSr5KsGlu0wSizbxq9I9IRE5lbK\nyJKAhYBtW0gCHG4LEPGL3FgyPTaLKEDQLzPS28Hn7mVqjU6bqmHS7S9z40F1Qx/CqJj4ZMErSdWG\nSRtCqAVzWRKJ+CV+4YVB3n9ld9TBev/Q+vKDz+fzxLVM09ywm4tEIk3pw7h6S0eOHHnioN4IwWCQ\naDTK8vIyly9fRlVVlpeXyefznvR0NBptyLJxg7prNvN6Cuo8rYF9ux9xN3RHV9dCURTGxsZ4+eWX\ndzxmPfPFvXE2NzS7urqIxWJEIpEN57iyssLy8jKXLl16Itriduc2PT2NqqobGrHhcJijR49y9OhR\nj4N87949TNP0znW323XDMFiauceloS4GBwdZtR/wh99aQrWdhmRDKWD7cQMISRDIlDQUUcAwHeEs\nSYSKIYCoAJrTNBQgiEa6DOtFwaFRYhP2SYT9MvGChig8Gru/sZTHtGyiIZnOiJ+1vOrxynXDYr2s\nYVuOrO+3H1TIGRI+GRRJxLRFDNOmpJms5auOEmTVxLRsT6ysqDqyxGYtUEsidLa3sZytYPNIY8eu\nGXrsxuLZL0PEr3CkPcAvvGWQHzjVvYu/emQ1t51/KLUkx9U8t237MX2Y7Rb6ehG93facmkW5XPaM\nPtySoWu35/YQHjx44JVsXEtIy7KYmppCkiTOnz//VMjwNounMrBvh51YMZqmcfPmTQ4dOrTrabmt\nmC+bG5qpVIoHDx5QKpWIRqPEYjHS6TTFYpHLly8fGP3M1b4+d+7clje5y0Hu7+9/TN7APdetWAvu\nd9bf3+9lbv/0xaN0hn38yavLpIsqogglzXImWLdpDFZNm7lUmXKdS4Sji2KQLjruSzaONK0q+LHR\nAduTtFU1jYeqow0fUCRyFd1xgBIFNNNivWxR0i1sy0aOKGBbiKJTPpEkG8s0aY+2kDcq5CoG4Hi+\nBhWRkqoTL6ioulnbidiYFtyPl4i1+DBtZyESaoyVVEkjs2lHspNWOrWGbKzFzw+fP8SbjnZw4Ugr\nAWV314ardR4IBDh+/PiuM1VBEB7Th0kmkx5zpX4c3zRNbty4wcDAwIFNQLtkhUZS1PXS09Q8WZPJ\nJN/4xjf40pe+xODgIGfOnOFd73rX6zKoAwhbGVLUsJvE4nsOtm2jaVrD/6tUKkxMTDQ0nnWtwEZG\nRujufpQdvfTSS7z5zW9ueJPspUnqSgZMTU1hGIbXPIpGo/t6Ibr0zJ6enj1P/7naIIlEgnw+78kb\nuOfqZlW7Ydf8h1eX+NRX5hxaYO3K2u0FFpEh4JNIlWsLKNDilxAE53svqQ7fO6g4RipVo2bnZztZ\nd0fQyeKp0REty6YropAsao6BBeAXoSWk0BXxs7BeoaKZThZug0+Cw+1BVMMgVTTQTdtjs4zEgoR9\nEjeXixs+T09YJl7aXT9HESGkiCiyxA+c7OLX/+7Jx5qiO8HdaUYikW21zpuFy7JKJpPk83l0Xefw\n4cMcP378QJKRSqXCzZs3m/ZZtW2b8fFxZmZmyOVyzM/PMzY2xvve9759P8fvEWx5gTyVGft2AXar\njD2dTjM5OcmFCxceyxDcv9lcy9sr88WyLJaWlhgYGKCvr49sNuvJE0QiEWKxGF1dXU9001QqFcbH\nxzl27NiGRapZbNYGceVdp6enPU/Jc+fO7arZ+1NX+ljMVPj8+JozvVprWLocdrdJ2KjpWjSgaGz8\n3Szb0ZWRRUdi15l7EnCr16btZPa6ZVFE895cEQUEuVaGqUeoPoEAACAASURBVHtL1QJFt7AsHG9X\n986pLR4BWWQtbyLwqJQiAmXNYjmjPnbOWwV1pTZFatey9I6QTGdQpsMPbz1kMtpbIb62uqWRRCMc\npIKiy7KKRqPcuHGDw4cPYxjGBgXFJ51+dlGpVLh169aegvrMzAw+n4/3ve99Xi8tkUjs4q+fPjyV\nGTs12mAjmKbJ1atXee6557znlpaWWFlZYXR0tOHFefXqVS5evLjhJttrUHcD7tGjRx+zy3PrnIlE\nglQqRSAQ2BNrxVW7O3PmzK7pmc3ClXHt7Owkl8uhKIp3rjvd4PF8la9Np9EMi+HuMJ/4q/us5NQa\nC+YRS2S3qF8IZMHJsIVaScN9H6Fm/CHgZN+mBS0+gaz6KEgHZKE2RWqTqZgbFhlRcNQSizU5xr3e\nGDKgKCKiINARVvjHLwzw7rM9hH2Pkga3qZ1KpaA2l+HSExvBnR52FT8PArquc+PGDYaGhjZct67p\nRTKZfMz0otmGpRvUT58+3dR16xIdNE3bd5mE73Fs+QU/tYFd07SGvqe2bfPyyy/z/PPPe8yBarXK\n+fPnt7wgrl+/zunTp70m0l7djlwvyd0GXPcGTyaTXuYci8W2dYZJpVLMzMw0raHRDFZXV1leXt6w\n2FUqFe9cXTbQdsGoHhOref6XP79HIq9i2hYCQs3o2pmsNPYo41H/64jCI2lhUXCyZsuEetND2RMm\nsynrj7/XXhYcSXi0CwnIAu0hH35FZLSvjV986yD9Hdv/RqqqeoGzWq0+Jue81bTnfsIN6kePHt12\n96dpmleyKZVKTfmUPklQn5ubo1qtPpGg2fcp3gjs9XjppZe4cuUK4+PjtLS0MDw8vG2QvnXrFseP\nHyccDu9Z8yWRSPDgwQMuXLiwJ32MarXqBU7TNL0gXx84Hz58yMrKymO7i/3E/Pw8mUyGCxcubLkQ\numygRCKBqqpeFufqYDf8G8Pka9Np7q4WqBay9IZs/viuSqqkYVrUhLX2HuTrIdaGghpNyvpE0PZ4\njJqoozORWvuYfsVhtvzdsz38wgsD6BZEQ76m6+fU9WbcWndLSwuFQoH+/v4DC+puY3ynoL4Z9T6l\nmUyGcDjsDRtt3n26CqynTp3yGqK7gesiVi6X98VF7PsQbwT2enzzm99EkiQGBwd3NSl3+/ZtBgYG\nvCDarObL4uIiqVSKCxcu7It/pDtkkkgkqFardHV1oWkaqqpuG3CfBK52jWEYnD59etdN3vrGW6FQ\naChv4MJ1hpJlmRMnTjAZL/Av/2qGB2lHV8UniYQUkWRRRatzdnIDaqN4vNWQVECCagNylCQ0Dvib\n36u+H+Bm8yGfY87d2+anUqnQHQlw7HA7P32lj+Hu/Z1N0DSNa9euEQgEUFWVQCDg7ZL2a1F3g/qx\nY8eeSCjLtm2KxSLJZJJUKrXBak8UxT0H9fn5eY9R9joM6rwR2OuQy+V49dVXefbZZ+noaGwVthl3\n796lvb2dWCzWFGvFLfWYptlUMGwGmqYxPj6Oqjom0C41sb29fd+GMlxn+WAw2BSFrtH7ZDIZEokE\n2WyWlpYWYrGYx6apb/55Fna2wx8vayYRv4wsCXz0v9zhm7NZVMNElkR8kkhLQCJZUDGsR4FZEcEv\nQVl/POgPdQZZSFceu8AjPkeLZsPQVF0UdyV1I34RvyQhiQIV3aQ1IDPYGeLDLw6ix2e9WYaDgK7r\n3Lx5k8HBQa/eXSqVSCaTJJNJ2EVdfidomsaNGzcYHh5uSktoN3Ct9uLxONlsllgsRn9//65EwKhL\nlly/34PanX4f4PUX2HVdf2zC1JXytSyLF154YVfv4xpdPHjwwKtxxmKxbcsK1DJVN1BtpQT5pDAM\nw3OoGRwcxLZtj5qYy+VobW31AudeFxV3ZNy9+fYLri6I2yRUVZXu7u5dGRFbts18usz4cg5ZFBkb\nbCcWUfjIf77H1YUsqu6IhB3pCPITY738/jfmyVcfyd92hGQ++s5hfvtLMyTrmCvdYYW/faKTv7yT\nqHmUOgvDTz5zhMm1PDPJEmXNojcMf+9cFz/27BAVFGRRoDWggGV4Afeg+N27KY24pTC3Lr/THMJm\nqKrKzZs3DySo1x/DXTgsy/LKS+5EaWdn55Y7z8XFRTKZDJcvX973oL64uMhv//Zv80M/9EO8+93v\n3vB/4+Pj/Mf/+B8RRZFLly7xYz/2YwD80R/9EdPT0wiCwM/+7M8yPDy8r+e0DV7fgd3dtrk61Fev\nXt2Sl16PzcwXt8aZSCQoFApbZseqqnLr1q0NAzv7DfcYAwMDDSf/6qmJ6+vrhMNhj0a5222re4yD\nDFTuMQ4dOoRpmqRSqT3LG9i2zcNslWRRpTPso7c9gCyKTD5c56N/Po6KTF9HmF/+gWOcP9LGaq7C\nP/kP46yXNWIRP7/3kxfoafXzhy8t8vLsOmG/xC//7WMc73ay3mxFxyeJKIK1oYfQ2dlJe3s7s7Oz\nDA8PH5i+914C7uY5hJ0Cp3uMkZGRfdMranSMGzducPLkyQ275vqJ0nQ63dCMemlpiXQ6zeXLl/d9\nSrtarfJbv/VbHDp0iMHBwccC+0c+8hE+9rGPEY1G+fjHP84v/uIvks/n+cIXvsBHP/pRlpeX+f3f\n/30++clP7ut5bYPXb2C3LIt79+4BcObMGURR5NVXX92xLrcT88WyrA3ZcVtbGz09PSiKwr179/ZV\nyGszmhULc2ucbnbs8/k8auJWGY8r63uQn8Mdbtp8DHfqMZlMevZqT0qhO6jPYZomKysrzMzMIMuy\nt6Pb72Ezt8H4JJ+jUeB0F3u/3+8F3IP8zZtZOFwjmZWVFT7/+c9z7Ngxjh49yjvf+c49ERB2gmma\nmKbJ5z73OVpbWzcE9ng8zmc+8xk+8YlPAPAXf/EXBAIB8vk8XV1dvP3tbwfgV37lV/jN3/zNA2Ok\nbcLra0DJhVuL7Orq2lC33U4IbLduR6IobtDZyGQyLC4ukk6n6ezsxDAMTNPc90ZmJpNhcnKyKflS\nQRBoaWnZ4LyUSCS4desWgiB4Qd69WVxaZqNx7v2Cy7VvdIxG8gYu+6GZsoKr393ssEszqFarnvl3\nS0vLhmGz7ZggzcBdnJptMG5G/Sj+yMiIV5cfHx/Hsiyq1SojIyO77j01C7eMtNvdQL2RTDQa5bXX\nXmN2dpbf+I3f4PTp0/zsz/7svi6ekiRteb9ms9kN11BbWxtra2sUCoUNU76tra1ks9nvVGDfEk9t\nYC+Xy1y/fp3jx48/VkbYavp0r25HgiBQqVTQdZ0XXnjBoybOzc0RDAa9wPmknfu1tTUWFxe5dOnS\ntlz2nRAKhRgaGmJoaOgx8a9QKEQ+n+fSpUsHkhVRp2S5GxNiRVE4fPiwJ9lab8rQyCXIhbs4Neu0\n0wzchaN+cYpGo0Sj0Q27pBs3bngG5a5Q1W7haqYcxLBZOBwmHA5z6NAhrl+/zpEjR0gkEiwuLnqu\nRvvVhK9vxja7G1hZWaFcLvPTP/3TBINBDMNgbm7uO6oDs7my4SZ+Wz3/3cZTG9iTySRnz55teDM0\nCux7nSR1p95KpRJjY2NIkoTf7/c0pUulEvF4nGvXru2qBLLVMdzdwH7zdeuz48XFRZaWlgiFQty6\ndWvXjeJmkEgkmJ+f35OS5VbyBjMzMxuy40KhwNTUFKOjowe2OO20cGzeJblCVXfv3vXUM3cqL5VK\npcfUDfcbbonnzJkz3m7AXUBXV1eZnJzcVUNzOzwJw2Z1dZW1tTXGxsa839Klw34nEY1GyWaz3uP1\n9XU6OjqQJGnD85lM5ol2VfuFpzawDw0NbaniuFm690k0X+7evYvf7+fChQuP/a0gCEQiESKRyGMl\nEFEUd5XB1VMmR0dHDyRLcZvLuVyO5557zlv40uk0S0tLO/LPd4vl5WXW1ta4dOnSE/P5BUHY4BLk\nZsff/va30TSNoaGhA8voMpkM9+/fb2rhCAaDDAwMMDAwsKG85Cp9bja7qLeBOyh9/q1KPJsXULcu\nPzc317Q2jBvUjx8/3nRQj8fjrKyscPny5e96aSMWi3nT1Z2dnVy/fp1f+qVfolAo8Gd/9mf84A/+\nIA8ePKCjo+PAkolm8NQ2T03T3NIpaWJiwhM12mtQd/nje1VOrJ8ktSyroSFHvffpsWPHDmSL5y4c\nlmVx6tSphsFwM//cpVE2KoFsdQx34dhOuuFJsbKywsrKCidOnPCy+WblDXZCOp1mZmaGixcvPlE5\nzMXmJnxrayvhcNibID6oMtJeR/jdhqYrHbGdzZ4rRbCXAadEIsHS0hJjY2MH9h1sxtzcHH/8x3/s\nSXhEo1GeeeYZYrEYV65c4d69e3z2s5+FmiPVe97zHgA++9nPMjExgSAI/PzP//y+i7Btg9cfK2a7\nwD41NUVHRwednZ170nxx2RzHjx9/IuVEF/Uj+K4hRzQaZXp62tNzPwjsZeFwMziXRhkKhbzA2ahE\ntNeJ1Wbhlqo2T942mtLdSd5gK7hlpNHR0QMZirFt22PYKIqy4bvdz+PtNahvhvvdJpNJz2bPbWy7\nmu3NShFQK6O6vaSD2q08JXgjsNdjdnbWa2o2e3Nns1kmJiYOjGmh6zorKyvMzc2hKAo9PT37Xud2\nj+PuOPaqM7KZRukqPMZiMXw+n0c19fv9O+rx7BWuCJQrH7zdwuHy5OvlDXYrUrW6usrDhw+5ePHi\nvshCNIJb4rl48SLBYHDDNKkgCJ6r1ZOUJdyk5MyZM/t6/bp1+WQySTabRdM0jhw5wtGjR5vqCaVS\nKa8Hc1B9hacIbwR2F7ZteyYXLo93t7K48Xic+fn5fduGN4LblDt79izhcHhXA1HNolqtcuvWrYbS\nwU8Cd5vuamDruk4sFjuwSbz6MlK9r+dusFmkqqWlxWu+bi4VLS8vk0gkuHjx4oGVkVym0OjoaMNr\nS1VVL8jvVlhtM1yGzUHSP93yS3d3t7eQ7rYun06nefDgAaOjo/t+fltNh66vr/PpT3/ae108Huf9\n738/hmHwp3/6px6j7sKFC/zoj/7ovp7TPuD1F9gty0LX9ceeq6+n18viumYCjba9tm2zsLDA+vo6\nFy5cODDBoWQyyezsrJexbT73zQNRexmEcYebnpQTvR10Xef69euEw2E0TfOGjJrxUN0J+7kbcOUN\nXJGq+gV/dXWVTCZzoL0B14ZwKz+AzdgsrObqGG238/hOMGwaadiwqS7v9pM21+XX19eZm5s7kKB+\n7969XU2HmqbJxz/+cT72sY/xyiuvsLi4yAc/+MF9PZd9xutzQKkejZqk9WbOjRgrsVgMRVG4f/8+\ntm0fGCuFOsbI5cuXG+4eNg9E1TsZ1YtpbRd8stksk5OTnDt37sBql+5uoN65abOH6mZN8WZhmuYG\nHZ4nhSAItLW1baCoJhIJXn31VUzTZGhoCE3TDoTt4BoyX7p0add1dDcJ6enp8bSMEokEU1NTnnRE\nZ2endx19J4K6a249MDDw2C6wftDIrcvPzs6SzWa9ITW/38/Y2NiB7CRu377Ns88+C0BfXx+lUoly\nufxYSeurX/0qb3rTmw5sN/6dxOsisO+G+bJ5aCeRSDA+Pk6xWKS9vX1LxsiTwuXBl8vlXbu/bKb6\nuWJa2w1EuXrwW2319wOuDMHm3cDmIaN0Os3y8jITExO7yjbr4YqSPUlvYCeEQiF0XScajXL8+HFS\nqZRn6uzuPPYib7AZ8XjcaxLutW7vKnpuHopaWFhAURRaW1uJx+NcvHjxwBZzwzB2bW7t8/k85UtV\nVdE0jZdeeolCocDdu3d55plnuHLlyr7ea9lsdlfToV/5ylf42Mc+5j2emJjgk5/8JKZp8oEPfGBf\nkojvFJ76wL4XtyPXkm5tbc3b5ruTmd3d3fT09OwLr9YtJyiKwvnz5/cUKBplm5sHonRd94abDqrx\n5/YGduJduxOYsVjssWxzp52HpmmeuFoj4bP9gG3bTE5OIooiZ86cQRAE+vr66Ovra8g/32vPw23G\n7qfrz+ahqFQqxd27dwkEAty7d2/fy2HUZer9/f1NC8VVKhXa29v5yEc+QltbG3Nzc9y5c2ffm+y7\nmQ6dmpqit7fXu69HRkZobW1lbGyM+/fv83u/93v8zu/8zr6e10HiqQ3s5XIZwzBQFKXpC6VQKHh1\naFc3o6+vz6Ml3r9/H03TPO75XjIhXde5ffs2nZ2dDA4ONv33jbB5IKpUKjE5OUmhUCASibC6urqj\ntd5ekE6nmZ6ebnrSc3O22Wjn4eqsuCWe48ePH5h6orvQBgKBhrrz9TsPy7JIp9MbpjN3y+1/+PAh\na2trjI6OHli/plgsMj09zTPPPEM4HEbXda+HU6lU9kUywA3qfX19TS+0uVyO6elpzp8/791jw8PD\nB9Jo3zw12mg69Nq1a5w/f957XE8zPnnyJLlcDsuyvqMyBk+Cpzawu7SpUCjkBY/dBLR6z9DNgxE+\nn8/7wTfXjbu6uujp6dnVFt0NUkNDQwcmh2tZFgsLC4TDYcbGxlBVlUQiwd27d7cciNoLXP2aJzU8\n2KrOfePGDU+L59SpUwca1OuNPnZCvbRwPbe/nkrbSPxraWmJZDLJ6OjogTVj3cSk/hpWFMUrgeyH\nZIDrtXrkyJGmg3o+n2dqaopz584dmIpkPS5evLjjdOjs7CxvectbvMef//zn6ezs5IUXXmBxcZHW\n1tbvm6DO08yKoXazptNp4vE46XSaQCDgBflGmaXbwLxw4UJTQcqldcXjccrl8rYaK+6oeP1uYL9R\n31ysV7V00Wggqqenp+ktuhukDpIpVCgUGB8fp7u7m3w+702S7sei5MINUt3d3U9sJmLbtrcopVIp\nZFn2FoB4PH7gDJtGQX2n860fOHPLkF1dXVveA6ZpcvPmTXp7e5v2GygUCkxOTnL27NkDW6QbYfN0\nqJv0XblyBYBf/dVf5dd//de9TD6dTvOZz3zGK+X+zM/8zHfSQGO3eP3RHTfDpQvG43GP0uYGeb/f\nzxe/+EUGBwc5d+7cE91025lxZDIZpqamOH/+/IGNSbt16CNHjuzKms3deSQSCY+xstNAVDNDQU8C\nl8VT/31pmuZRVN1F6UmamW454aCs7Fzxr8XFRQzD8BqMB/H7u1LIu1HNbAR3UXJpn4IgeIuS+35u\nUD98+HDT31exWGRycpLTp0/vy8T2G3gjsG9AvfbJ6uoqX/rSl2hra+Pnfu7n9pUOVs89T6VS2LbN\nyZMnm/ZO3S0qlYondbCXbGjzotTR0UFPT8+GOqzbXAQ4derUgUmU7kaTxTAMb1FqVqudOt71btgc\ne4W7CJbLZU6cOOF9v83YLO4G+XzeU5vcr52M602aSCQ8llAmk9mTzIUb1E+dOrWvQ3Gvc7wR2Bsh\nn8/zqU99irGxMU6ePLlB/Ccaje4Le8AVwMpkMvT395NKpTwhLVeIbD+CvEsXe1L9DxeNBqK6u7tZ\nWVk5UFEyajTAhYWFpjRZNlvAuY5WW9EoXSefer79fsO2bWZmZtA0zWPY1J9v/SLaLO2zHrlcjomJ\niYaDbfsFVVW5fv06oihiWVZTcgylUomJiQlOnDix72ym7fxGP/zhD2/w+/3lX/5lotHod9OjdL/x\nRmBvhC9/+ct0dXUxOjoKdfXGeDzu6XNEo1E6Ozv3FOTd7Na27Q08+PrjrK+v73rAaCu44+gHVeJx\nZRgmJiawbdvLjPd6vtvBZYxcvHhxz3X7ehplJpMhEol4dWNJkg7cLo868TNXNXO7a2er8+3s7Nzx\nO/hOBHW3BxGLxejr63tMjmG78y2Xy9y7d4/h4eF9L3XtNFH64Q9/mE996lMbdny7nUL9PsEbk6eN\n8I53vGPD43rrsBMnTpDP54nH40xPT3sBLRqN0tLSsmOQdxuYra2tHD16dMPr64+zmeb3/7d35lFN\nnfn/fyckgAECCSjQoiCIKMoScEFl1FE741Gnp6dVOtW206qnVWfq2MVuWqWjtFode2zt1J+nU2fs\nYst0zqht7TKnHVppix1B2RL2JWxJ2PdAQvL7Y3ju9yZmX9jyvM7pqSFcuAnwuc/9PO/P+y0QCOwK\nnSarW0eCK2xFo9GgpqYGsbGxCA0NtShLdIa6ujp0dXU5rRgxllH29vYyA1p8Ph8DAwOIj493a1En\nWnhb2lWWzpdtb2B890L2INxZ1HU6HYqKipiiTs43ODgYwcHBBudbV1fHDEUJhUL4+/tDJpMhJibG\nLfsXtk6UOnvMZMSjC7sl2PK72NhY9Pb2QqlUoqamBiMjI8wfoqn+qD0bmMYyv76+PsZsjCgUzJmU\nyeVytLW1uTxViQ1Z3cbGxjJBCeZkicTd0ZGEKCIbTUxMdOn+A4fDYQpNWFgYo36prq5GXV2dQ3F1\nltDr9ZBKpfD29nbIw4Z9vuT9bW1tZfJpiSJoaGgIZWVlbp0k1ul0KCwsREhIiNkpX+PzHRgYQHFx\nMd59912MjIxg0aJFmD17tlsi42yZKD137hxaW1sxb948bN261eYp1MkOLew2YPzLyy6+ZFNJLBYj\nMDAQdXV1KC8vx+LFi+1OjGFPDrKnSG/evGlgUsbn81FVVQW1Wu1W/xoizTSXt8keiIqOjjYZkm1t\nIIqsbjkcDhYuXOi2vj1RjCQnJzPtKmIdQbT97MlMRyCJWgKBwGV7ECSXNCoqinF4JFYXZBrWx8fH\n5e8bWamHhITYJQEVCARMGy04OBgqlQoXL14En8/Hvn37XHqO1iZKMzIykJycDH9/f5w4cQLXr1+f\nsBmlroYWdjsxLr7Em0Mul6Ourg45OTnYunWrSzTqfn5+iI6ONiiat27dwuDgIPz9/bFgwQK3Sw3t\nCYM2FZJtaSCKFMJp06aZnPR0Feai7Hx9fZm4OqLtr6iowPDwMKNYsaXtRl5LSUkJAgIC3OYp4uPj\nAz8/P+j1eixduhR9fX0usTcwhhR1sVhst65frVZDKpVi1qxZiIyMRHx8PFavXn1bQXUF1iZKV61a\nxfxbIpEwId0TMaPU1dDC7iRkxdre3o6bN2/iscceg0ajQX5+PkQiEcRisVM5oQSBQICZM2eis7MT\nIpEIPj4+KCkpAUbzGF1pFUDyLZ25zWeHZBtbMRCXyurqapdaKpiCyCatvRb2VDGxxa2vr0dfX5/V\nokkKoUgkcutr6ejoQGVlJbOf4u/vj7CwMEbB5Ii9ganXUlxcDLFYjFmzZtl17NDQEGQyGSIiIm57\nH9xx0bY0UTowMIDXX38dzz33HHg8HqRSKdLS0iAWiydkRqmr8WhVjKsYGhrC22+/jZ07dzK+MWSF\nTTTWpMg7ImcDq28fERFhMO1HrAJUKhVGRkaYIu9oz7C5uRlNTU1ITk52i2GYVquFQqFAVVUVvLy8\nEBYW5paEKLgoys6aD74rp1Ytwb5AWdokN54ktWdzmxT1oKAguy9QQ0NDkEqlCA8PN+hhuxtLE6VX\nr17Fd999B29vb0RFReHRRx8Fl8sdz4xSV0PljuOJWq2GUqmESqVCf38/goKCmCJvy4qKxJmxNzBN\nYWwVYK9JGTtMxF0j78PDw0wYQ0hIyG0DUUTL7WyRb2lpQWNjo0svUGwffJL3OjAwgIiIiDEp6vZ4\ntsOEvQFx1jS1WUxaSUKh0O5CNzw8DKlUitDQUMTExNh1LMUpaGGfKLBX2L29vQgMDGQ2X00VU7Lp\nZ2+cGbEKUCqVTIizOZMyMkijVqvd2rdXq9W4deuWyQsU0UYrlUqnEqLAirJzp4cNabf5+vpiaGiI\nsUh2dfB0W1sb0xZz9usSe4PW1lbGgprYBThT1GUyGaZPnz6ZB30mK7SwT0SI7wmZlhQKhUyR5/F4\nKC4uRl9fn8PeHwTSMzZlUqbX6yGTycDj8TB37ly3bWCaC+EwhfHK2HjAyBL19fVuN9oyZUXADp4m\nzo/O7nu4sqgbQ5KM2ENRsbGxdqVaaTQaSKVSBAcHIzY21qW/O5amQ0tKSnDx4kVwuVyEh4dj165d\nkMlkOHXqFHPnNGvWLGzfvt1l5zNBoYV9okP8ssmKtaamBjdv3sT+/ftd6oJnPMpONPnuSogC667D\nkWg29gBXe3u72Z6xXq9HbW0t+vr63GpMRlpJUVFRZj1PiCKI7HuQIm+PjJJE5rmjqBP0ej1KSkog\nEAgQEBBgl72BVquFVCqFSCRy+YLA2nTo3r17cfjwYQQHB+PUqVNYvXo1fHx88OWXX+Lpp5922XlM\nAujk6USH7Zd9+fJlyOVybNu2DTU1NVCpVIy1gbP9YtJnFYlEKCwshEgkwsjICK5fv+6UX4k5iNTQ\n0bsOcz7tBQUFBgNR9fX10Gg0DidR2QLxl7FmssZWBJELdmVlJdMSmz59usXNYnYOqrsSr/R6PUpL\nSxlJLUbVVcapVqbsArRaLRNr6I67PGvToceOHWP+LRQK0dfX57ap68kKLewTjJKSEjQ2NuLgwYPg\n8XhMG4UEWvj5+TFF3tGV3NDQEBP0QVad5A9aqVSioqLCJSZlrpBNsjE3EJWXlwcOh4PIyEgMDQ25\nZRKT7A/Y6y9jHHDR1taGhoYGg81ithyW5JWORVGfNm3abQoWc/YGdXV1kMlkCAwMRHh4OMLCwhAX\nF+eWi6i16VDy/87OThQVFeH++++HXC5HY2Mjjh8/jr6+PmzZsgWJiYkuP7fJAi3sE4wFCxZgwYIF\nzB8MO5GetFEUCgUaGhrsTocCS2FjXKCM/6DJqq2ystIhkzJyjvYqOezB19cXfX19uPPOOxEREcEM\nRLlC9smG2CrExcU5NXjm5eXF/CzZm8Xl5eUQCoXw9vZGZ2en24u6VCplhsIsYTxxPWPGDHz99de4\nefMm/Pz8sHjxYixbtszuCWtbztH4sfEFpLu7G8ePH8eOHTsQEBCA8PBwbNmyBcuWLYNSqcTLL7+M\nN998022b5xMdz3zVExhLKyDjIGiyIVpcXGw1HQqsdB1rChsOhwORSASRSOSQSVljYyOUSqVLg5qN\nIZprYrIGwOJAlKNhHORC6Co7ZIKxkVZtbS0aGxvBIt0GoQAAG/xJREFU4/Egk8nsMoKzFVLUfXx8\n7Naaj4yMYHBwEHfddRcWLFiA7u5u5Ofno6WlxeWF3dp06MDAAF555RX89re/RVJSEnPM8uXLAQBh\nYWEICgpCR0eHx3q/08I+SWFnbrLToUpKSgzSociKtaGhAU1NTXb3uq2ZlIWGhhpsZNbW1qKnp8et\nmZ4jIyMWfUyMp0jb2tpQW1trNbbQmP7+fhQVFdktNbUXYt+8fPlyeHl5MTYV9fX1zD7CjBkznLrz\nIeonb29vu+0bdDodysvL4ePjw9xNBgUFYe3atQ6fjyWsZZReuHABGzduhEQiYT527do1dHZ24u67\n70ZXVxe6u7vHJE91okJVMVMMdjpUa2sr+Hw+6uvr8eOPP+Lw4cMuHZ8mBYhke2K0p+xOLbxWq0Vh\nYaFD0WymEqKMe9wEYoDmiJLHHlpaWphJX1Orc7KPQPIBiMLGnp8jKep8Pt9ux0lS1Hk8HhISEsYs\n0NncRGlSUhIeffRRzJ07l/nc9PR0rFixAqdPn8bAwAC0Wi02b96MlJSUMTnXcYTKHT0RvV6Pzz//\nHN9//z3WrVsHf39/l6ZDsb9PcXExhoaGoNfrDVpGrlQruDLKztJAVH9/P0pKSpCQkGDz1K4jtLS0\noLm52eZQEeLuqFKpoNVqDdwoLeXTlpWVwcvLy26tuU6nQ0VFBbhcrsvtlCkugRZ2T+THH39Ebm4u\n9u3bBz6f79J0KAIZRff392cCRYgdrkqlAlxkUubOKDv2ZnFrays0Gg2T+OOudlJzczNaWlocblnZ\nEkKu1+tRXl4ODodjtyyRJEBhtDVCi/qExHMKu1QqxalTp7B7926kpqbe9vy1a9dw9epVcDgcrFu3\nDmvWrIFWq8Vf/vIXZmpwz549bgs3HkvUajX4fP5thYNsiJIib286FIEYYIWEhJh1AnSFSZmjUkN7\n6erqgkwmw5w5c9Dd3Y22tjaXJkQRnC3qxphqMU2fPh0qlQpcLtehol5ZWQmdToekpCS3XdwoTuMZ\nhV2hUODChQvgcrn45S9/eVthV6vVeO655/Dqq6+Cx+PhhRdewMsvv4wbN26gqqoKO3fuRGFhIb79\n9ls8+eST4/Y6xhKiVSZF3lo6FEGj0aCwsJDRaNsCUasolUpoNBqbTMqIKsUWKwJnILmxxpp7430E\nZzcym5qaoFQq3VYwSYupoqICQ0NDTLvGVqkq8Q3SarVu2QC3ZBVQVFTEWAVIJBJs3rzZ6jEejmdM\nnopEIjzzzDN4++23TT5fVVWFmJgYZrUYFxeHsrIylJSUYOXKlQCAhIQEs8dPRexJhyJFXq1Wo6io\nyOJYvSnYahXSSiDmY6ZMysZqA5Ptnmi8J8AeiBocHIRSqbQrIYoNMSdz5yqYw+Ggra2NGfUnA0a2\n5NOSiEKNRgOJROLyc5RKpVAoFMjKyjJpFXD+/HkcOHAAYrEYmZmZSEtLQ09Pj8VjKKaZUoXd2kZd\nV1eXgWyNTLSxP87lcsHhcKDVaj1uuMFSOtTQ0BDEYjGGhobw4YcfYu/evU5phPl8PsLDwxEeHm5S\nkujn54e6ujokJSU5HFVnC+zxfWur8GnTpplMiLLFD6ahoQFtbW1uLersFgoJ0TaXT0vuPqZPnw4f\nHx/o9XrU1NRgaGjILUUdVqwClEol/P39GasGiUSC4uJi9PT0eET4tKuZtJXrm2++wbfffmvwsS1b\ntiA5OdnsMebaTqYm3Si4bXy/qKgIFy5cwMqVK9HT0wMej+eSdCgej4ewsDCEhYVhZGQEcrkc5eXl\n8Pb2RmNjo8si34who/KOTHoaJ0S1tbUxsXrGA1Hsou6uTUh2C2X+/Pm3vVfGdgyDg4NQqVTIyclB\nTk4OYmNjMXfuXKxZs8ZtCxpLVgHGi67AwEAoFAr09vZ6RPi0q5m0hX3t2rV2D0iIxWLk5+czjzs6\nOhAbG2sw6abVaqHX6z1utW4NhUKBf/7zn3jxxRchFouhUqnQ0tKCqqoqp9Oh2BB1yrJly+Dt7Y2O\njg40NzejrKwMQUFBCA0NdcnFhG154OymqLe3N7PXYHz3wePxoNfrkZKS4vairtFoTBZ1U0ybNg2R\nkZGMdLSoqAj//e9/8Z///Aepqam47777XH4htWQVYO45TwmfdjUeVb1iY2Nx9uxZ9Pf3w8vLC+Xl\n5XjkkUcwODiIvLw8JCcnIz8/H/Pnz8cbb7xhViVTU1ODCxcuMI8bGxuxf/9+FBYWIjc3l1FurFy5\nEmvWrBmX1+pqAgICsH//fqb9wm5JKJVKKBQKVFdX250OxYa9giZtEZKPaspbxVGTMqJKcYflAfvu\no66uDkqlEn5+fvj5558tDkQ5CumLDw8PIz4+3m71i1wuB5fLxfbt2+Ht7Y2BgQFUVFS4pXhasgow\nfq6jo4P5HfKE8GlXM6UKe0FBAa5cuYKmpibU1NTgiy++wMGDB3Hp0iXEx8dj7ty52LZtG7KyssDh\ncLB582YIBAIsX74cRUVFeOmll8Dn85GSkgKFQoEjR46gsLAQH374oYFKJjo6GpmZmcDo2Plrr72G\n2NhYFBYWYsOGDVi/fv04vgvuwZx23NfXF5GRkYyzIpE21tTUWE2HYkOi7MytoI29VRw1KSMbmO60\nPMBo4Ed3dzcWL14MLpdr8sJEztmZIk/64vYWdYz2/bu6upCamspcSAUCgcV2pjNYsgqYMWMG0x4K\nDg5GQUEBnnjiCfT29npE+LSrmVJyR1dx5swZrFy5EomJidDpdNizZw/Onj1r8nM/+ugjREdHY8mS\nJcjOzoZQKJyShd1erKVDsSGmYbZOYLIxDuIQCAQIDQ018A8nyOVytLe3uzXTFQDq6urQ3d1tdgSf\nBE4Tjxh7EqLYVFdXY3Bw0MAN1FYaGhrQ3t6O1NTUMfUytxQ+LZVK8cEHHwAAli5dirvvvtvkMZM4\nfNrVeIaO3VUcPXoUDz74IPMLtHv3bpMWoMPDwzh8+DCysrLA5XKRnZ2N0tJS8Hg88Pl8bN++3WPd\n5dgYp0MFBAQwRf7y5cuYPn060tPTnS62er2ekWu2tbUZmJQ1NTVZLLauora2Fr29vTanOLE9z+0Z\niKqpqcHAwIBDRb2xsRFtbW1ISUlxi3c9ZczwDB27I5hS11RWVho8Nnfx+/nnnyGRSJg/4JSUFCxc\nuBDx8fH44Ycf8O677+L5559349lPDthhE1qtFq2trVAoFPjkk0/Q3t6O7du3Q6fTOV3Yzck1f/rp\nJ+j1esTExECr1brNH76mpgb9/f12RfOZmiMwliQaD0TV1tYy38feot7c3IzW1lakpqZOyqJ+9epV\nfP3118zjlpYW7N+/H4sWLRrX85poeHxhN6Wueeutt2xSyRQUFOBXv/oV85g9Ebdo0SLmtpLyf5DN\nxW+++QZ+fn548MEHmULminQoNn5+ftDpdBCLxZg9ezZaW1tx69Ytt5iUVVdXMytoZ+4ITEkS2QNR\narUaarXaoaLe0tIChUIxaYs6AGzYsAEbNmwAAOTm5uKzzz5z257AZMbjC7spkpKSDFQyCxYsMPl5\n1dXViIyMZB6fP38eaWlpmD9/PkpLSzFz5kybfGgeeOABxMXFMY8PHToEnU43Jf1rMJp+4+3tjV27\ndjFJ865Ih2JDhnW0Wi3TrvDz80NUVBRTMIuLiwEXmJSRXrcjxdYSRJJINqZlMhm6u7sxbdo01NfX\n2xWQrVAo0NLSgpSUFLdtPtryu/7jjz/i008/BZfLxcKFC/HAAw8gJycHH3/8MfO5iYmJuPfeey1+\nL6VSiffeew+ZmZlUmmwC2mM3gU6nw9mzZ9HS0gI+n489e/YgJCTEQF0DADt37sQ777zDHCeXy3Hu\n3Dl4eXmBy+Xi8ccfR1lZmVUfmh07duCvf/2rwcdycnI81r+GnQ7V3t5uUzoUG+JqiFHbCEvFlq3k\n0el0zASpLQMwRGroqCrFHurq6tDT04OFCxcyWnmlUmlTQpRSqURjYyNSUlLcOsVr7Xd2aGgITz31\nFE6ePAlfX18cOHAAe/bsQVVVFeRyOR5++GGbvo9Wq8WhQ4fw61//GqtWrXLb65kE0B67PZDVhjH3\n3HOPwWN2UQeAWbNm4ejRowYf++STTxzyofFk/xp706HYkFAJHo9nk/+4j4/PbZF6ZWVljElZaGio\nyWI4lkWdSCfJxq+5gaj+/n7Gvpd4+6hUqjEp6rDhd9bHxwcnT55kLs4BAQHo7e21+/t89NFHCAsL\n8/SibhFa2N2MLT40w8PDzEDU0qVLsWnTJupfMwqXy71tSEmlUkEqlYLP5zM9eYFAAI1Gg7y8PISH\nh9sd/wYTJmWtra2orKy8zaQMo4ZyGo3G7UVdLpejq6vLrJrH2I6ho6MDDQ0NOHbsGEJDQxEVFYVN\nmza5vajDxt91UtTlcjlUKhViY2OhVCohk8mQlZWFkZERPPTQQ0yOrTFkQvbYsWNufz2TGc+qEm7G\nUYXNQw89xKx0Dh8+jPnz51P/GhOwh5TmzZuHrq4upigAwBdffIGZM2ciPT3d6WJrrORhr4q5XC58\nfX2RkJDg9qLe0dFhc3qRl5cXc6ezb98+5Obmoru7G0eOHEFMTAwyMjJcFjztjJqspaUFp0+fxh//\n+EfmzkooFCIlJQXl5eV46623cPLkSZPHXrp0CX19fXjhhReYj61btw6bNm1yxcuaMtDC7kIcVdiw\nlTUJCQmQy+XUv8YKHA4HIpEIIpEI0dHR+POf/4zZs2dj/vz5uHXrlkvSoQhkVRwaGoqysjIMDg6C\ny+Xi+vXrEIvFCA0NNbA1dgUNDQ12FXU27e3taGxsxD333AOhUAidTofKykqXbpo6+rve3t6OEydO\n4A9/+AMzJ0LukjC6J9Ld3Q2dTmfydR86dMhlr2EqQyuFm7GmsGlubsY//vEP7N27FzqdDmVlZUhL\nSwOfz7dJmUMB3nvvPUgkEqxfv94gHaqystLhdChjSFQch8OBRCIBh8NhNnmbmpogk8lcZlLmjBtk\nR0cHamtrkZycbNAWYauu3IUtarKzZ89i586dBo6Nly9fRnBwMNLT0yGXyyEUCmkUn5NQVYybsUVh\n88EHH6CkpAQcDgeLFi3Cvffea/K4oKCgMZOTTSaGh4dN6t4dTYcy9XWsZYey+/9dXV0G4dj2FKnG\nxka0trY6ZHvQ2dmJqqoqJCcnIzAw0K5jXYG133V/f388++yzBvMemzZtwuzZs3HmzBnodDrodDr8\n7ne/oylJtkEtBaYCYyUnm4qw7QZIYLWpdChTx5WVlcHLy8smlQ05hpiUdXR02GxS5kzCUldXFyor\nK5GUlETdDz0HKnecCoyVnGwqYks6FCnyZIVNpJN8Ph9z5syxeYXP7v+zW0PV1dXw8/Nj/GvYxbup\nqcnpop6YmEiLOgWghX1yMRZyMk/BOB2KDPGQ4JDAwEC8//77WLx4MVasWOFwb54dT8e+a6itrWUM\nv4h/jiNFvbu7G5WVlUhISIBIJHLoHK1Bp6cnH7SwT1DGS07miQgEAsyePRuzZ8/GwMAAFAoF/v73\nvzPyQRL64OyGnqm7hqqqKnR0dCAoKAgKhQLTp0+32Senp6cHFRUVWLhwIRPu4g5yc3MhEAjM5hNg\n9D0kGQWE77//3upxFPdAC/sEZbzkZJ6Or68vvvjiC8ybNw+/+c1voFKpXJIOZYre3l6MjIxg1apV\nGBoaglKptNmkrLe3F+Xl5ViwYIHLtOnmcHQK2pOnp8cbWtgnEa6Qk7355psYHBzEoUOH8Mgjjxio\nD4qKinDx4kVwuVxIJBJs3rwZAPC3v/0NlZWV4HA4tx0z1RgZGUFCQgJTkFyRDmWKlpYWNDc3M0lO\n7LsGYlJWVFTEuDqyTcr6+vpQXl6O+Ph4hISEuPw9MIZOT08+6Ds8iTCO8CN+Nmw5mUwmg0ajYY7Z\ntGkT0tPTcebMGVy6dAnt7e3IzMyEr68v3n77bWRlZTGfe/78eRw4cABisRiZmZlIS0tDT08PFAoF\nsrKy0NjYeNsxUw0+n88UdTbGnjKkyNfW1lpMhzKFQqFAU1OT2Xg+Y1dHlUqF0tJSfPnll4iIiMCd\nd96JtLQ0s3GFzkCnp6cGtLBPImwxJ3v//fdNHnv48GF8/PHHCAkJYVbc/f39GBgYgEAggFKphL+/\nP7MClEgkKC4uRk9PDxYvXgwAiIiIMDjGU/H29kZERAQiIiIM0qHq6uoM0qFMJSCRTdrk5GSbLgLs\nC0poaCi++uor5Ofn4/r160hNTcXq1atd2l+n09NTA/ouexBdXV0GLRqhUIiuri4IBAKD22YACAwM\nhEKhQG9vr9ljKKbToZRKJerr6+Hv789YG/D5fFy/fh0AkJqaaneBI5u69913H+644w709/cjPz8f\narXaTa/s/6DT05MPWtg9CFO3xkTGZ+45S8dQDOHxeAgPD0d4eDi0Wi0THCKXyyGXy3Hjxg08++yz\nDhV1mUyGmJgY3HHHHcBoOpSplpE7sNYCnDt3LkJCQvDiiy8y09Nz5sxBdHS0yeMo7ocWdg+CfWuM\n0RF0MtBi/ByR+Hl5eZk9hmIeHo+H0NBQhIaGIi8vD1KpFFu3bkVVVZVd6VCDg4OQyWSIiopilE1j\njS0twG3bttl8HMX90MLuQSQlJSE7Oxt33XUXamtrIRKJmIGmGTNmMGqM4OBgFBQU4IknnkBvb6/Z\nY2BFMVNSUsKobMLDw7Fr1y7IZDKcOnUKM2fOBEbDSbZv3z4O78bY0Nrais8//xwvvfQSk8FK0qGK\ni4stpkOp1WpIpVJERkYy7xeFYgvUK8bD+OCDDyCTycDhcLBjxw7U1dVBIBBgyZIlkEqlTAD30qVL\ncffdd5s8hujjpVIprly5gueff96kYmbv3r04fPgwgoODcerUKaxevRo+Pj748ssv8fTTT4/TOzD2\nmJP4sdOh2traDNKhuFwupFIpZs6caZCrS6GwoF4xlP9hfMtMijQAxMfHm5QymrrNBoDi4mKLiplj\nx44x/xYKhejr6zM7cDOVMddTN5cOVVpaipGREUbySKHYCy3sFIexpLLB6Jg5RvvyRUVFuP/++yGX\ny9HY2Ijjx4+jr68PW7ZsQWJi4ri9homCcTqUUqlEWFiY276fNf+XmpoaXLhwgXnc2NiI/fv3o7Cw\nELm5uYzEcuXKlVizZo3bzpPiGLSwUxzGFsVMd3c3jh8/jh07diAgIADh4eHYsmULli1bBqVSiZdf\nfhlvvvkm1Tez4HA4bi3qsMH/JTo6mvF+6e/vx2uvvYbY2FgUFhZiw4YNWL9+vVvPj+Ic1CyE4jCW\nVDYYlem98soruP/++5GUlMQcs3z5cqZ4BQUFoaOjY1zO35MpKSnBkiVLgNGBovLycrOf++mnn2Lj\nxo3UW2gSQX9SHsann36K1157jXl89OhRfPXVVw59LTK4AsCkYubChQvYuHEjJBIJ87Fr167hypUr\nwGgrp7u7263OhBTTmPNxMWZ4eBiFhYVYtGgR87GffvoJR44cwbFjx6BSqcb0vCm2Qe9/PYyNGzci\nNzcXhYWFGB4exuDgIO666y6HvlZcXByio6Nx8OBBRjGTk5MDgUCApKQkfP/991AoFIz3SHp6Olas\nWIHTp0/jxo0b0Gq12LlzJ9OGsSSd/P3vf4/g4GBm1bh3716IxWKPMihzFGcsoH/++WdIJBLmfU9J\nScHChQsRHx+PH374Ae+++y6ef/55N549xSH0er2l/yhTkOrqav1TTz2l37dvn76+vn68T0ev1+v1\npaWl+ldffVWv1+v1DQ0N+hdffNHg+T179ugHBwftOoZinjNnzuhv3ryp1+v1eo1Go3/sscdMft7p\n06f1MpnM5HNqtVq/e/dut54nxSJmazdtxXgg0dHREAgEEAqFmDVr1nifDmBBOunqYyj/g91Gs+Tj\nUl1dbSC5PH/+PGQyGQCgtLSUDk5NUGgrxgMpKCgAl8uFRqNBQUEBUlJSxvuUrEonAeDcuXNobW3F\nvHnzsHXrVpuOoZjGFv8XjCpi2Psma9euxblz5+Dl5QUul4vHH3983F4DxTy0sHsYarUa58+fx/79\n+zE8PIzXX38d8fHxVj1L3I016WRGRgaSk5Ph7++PEydO4Pr169SgzAls8X8BgHfeecfg8axZs3D0\n6FG3nx/FOWgrxsPIzs5GamoqZs2ahTlz5iAhIQEfffTReJ+WVenkqlWrEBgYCC8vL0gkktv8vk0d\nQ6F4KnTF7mE8/PDDBo937do1bufCxpJB2cDAAF5//XU899xz4PF4kEqlSEtLg1gsdsigrKOjA2+8\n8QbzeUqlEtu2bYNWq8XHH3/MTGAmJibi3nvvHfP3gkJxFmoCRpkwWDIou3r1Kr777jt4e3sjKioK\njz76KLhcrsMGZYSRkRFkZmbiwIEDyMvLg1wuv+3iN5mQSqU4deoUdu/ejdTU1Nuev3btGq5evQoO\nh4N169ZhzZo1Vu0FKBMWagJGmfhYMijbsGEDNmzYYPUYgjWDMkJOTg6WLl067nsMrkChUOCzzz7D\nvHnzTD6vVqvxySef4NVXXwWPx8MLL7yAJUuW4MaNGxbtBSiTD9pjp0xJjKP+iGLGmG+//dbAxEom\nkyErKwt/+tOfUFtbO2bn6wpEIhGeeeaZ23zdCVVVVYiJiYFAIIC3tzfi4uJQVlZml70AZXJAV+yU\nKYktipmKigrccccdzCo+NjYWQqEQKSkpKC8vx1tvvYWTJ0+O5Wk7hTVLZHMXO3P2AtSYbfJCf3KU\nKYktipn8/HwkJCQwj++8804mfi4uLg7d3d3Q6XQT0vzKlE3Ali1bkJycbPYYc/tppi6ClMkNLeyU\nKYkllQ2huroaK1asYB5fvnwZwcHBSE9Ph1wuh1AonJBFHaODQmvXrrXrGLFYjPz8fOZxR0cHYmNj\nDS6CWq0Wer2ertYnOfSnR5mSWDIoI/3kzs5Og9ZEeno6zpw5g3//+9/Q6XTYvXu3wdeUy+U4ceIE\nNm7ceJsfeVFREZPvKpFIsHnzZsCKsdlYExsbi7Nnz6K/vx9eXl4oLy/HI488gsHBQeTl5SE5Odmi\nvQBl8kDljhSKDajVahw/fhxhYWGIjIy8rbA/+eSTOHDgAMRiMTIzM/HYY4+hp6fHJsmlqygoKMCV\nK1fQ1NQEoVAIkUiEgwcPGtgE5OXl4cqVK+BwOFi/fj1+8YtfQKfT4ezZs2hpaWHsBUJCQtx2nhSX\nYVbuSAs7hWIDIyMjGBkZwaVLlyAUCg0Ku1KpxJkzZ3DkyBEAwL/+9S/4+vqip6cHISEhTMtk3759\neOWVV6iXDcVVmC3sE7OBSKFMMLy8vODt7W3yOWO1SWBgIDo7O22WXFIoroYWdgrFScxJK6lJGWW8\nsNaKoVAoLDIyMjIBtGVnZ59hfSwKwMXs7Oxlo48PA2gHEAKgJTs7+/+NfrwGQFJ2dnbveL4GytSH\nrtgpFCfJzs6uAyDMyMiIysjI4AHYBODr0f82439FXQKgmRZ1ylhA5Y4Uig1kZGSkAvgzgCgAmoyM\njM0ArgCozc7O/heA3QAujn76x9nZ2RUAKjIyMvIzMjJ+BKAD8PtxfhkUD4G2YigUCmWKQVsxFAqF\nMsWghZ1CoVCmGLSwUygUyhTj/wN1sgI58itZpQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139741775524752" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139740795828368" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRbkvV2JL2QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139742113507216" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nOM3QhF1DQ0PjNEMTdg0NDY3TjP8feTNbOo59pqcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139741805260752" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n3CbJvIywAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139742099995664" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139742000502992" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ndgKBQJhjkMJOIBAIc4z/Ab5v0n/qZqrbAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139742099995664" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAF2CAYAAAB6XrNlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139741807862096" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# Number of optimization steps\n", + "Niter = 2000\n", + "# Weight for the chamfer loss\n", + "w_chamfer = 1.0 \n", + "# Weight for mesh edge loss\n", + "w_edge = 1.0 \n", + "# Weight for mesh normal consistency\n", + "w_normal = 0.01 \n", + "# Weight for mesh laplacian smoothing\n", + "w_laplacian = 0.1 \n", + "# Plot period for the losses\n", + "plot_period = 250\n", + "loop = tqdm_notebook(range(Niter))\n", + "\n", + "chamfer_losses = []\n", + "laplacian_losses = []\n", + "edge_losses = []\n", + "normal_losses = []\n", + "\n", + "%matplotlib inline\n", + "\n", + "for i in loop:\n", + " # Initialize optimizer\n", + " optimizer.zero_grad()\n", + " \n", + " # Deform the mesh\n", + " new_src_mesh = src_mesh.offset_verts(deform_verts)\n", + " \n", + " # We sample 5k points from the surface of each mesh \n", + " sample_trg = sample_points_from_meshes(trg_mesh, 5000)\n", + " sample_src = sample_points_from_meshes(new_src_mesh, 5000)\n", + " \n", + " # We compare the two sets of pointclouds by computing (a) the chamfer loss\n", + " loss_chamfer, _ = chamfer_distance(sample_trg, sample_src)\n", + " \n", + " # and (b) the edge length of the predicted mesh\n", + " loss_edge = mesh_edge_loss(new_src_mesh)\n", + " \n", + " # mesh normal consistency\n", + " loss_normal = mesh_normal_consistency(new_src_mesh)\n", + " \n", + " # mesh laplacian smoothing\n", + " loss_laplacian = mesh_laplacian_smoothing(new_src_mesh, method=\"uniform\")\n", + " \n", + " # Weighted sum of the losses\n", + " loss = loss_chamfer * w_chamfer + loss_edge * w_edge + loss_normal * w_normal + loss_laplacian * w_laplacian\n", + " \n", + " # Print the losses\n", + " loop.set_description('total_loss = %.6f' % loss)\n", + " \n", + " # Save the losses for plotting\n", + " chamfer_losses.append(loss_chamfer)\n", + " edge_losses.append(loss_edge)\n", + " normal_losses.append(loss_normal)\n", + " laplacian_losses.append(loss_laplacian)\n", + " \n", + " # Plot mesh\n", + " if i % plot_period == 0:\n", + " plot_pointcloud(new_src_mesh, title=\"iter: %d\" % i)\n", + " \n", + " # Optimization step\n", + " loss.backward()\n", + " optimizer.step()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Visualize the loss" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5,1,'Loss vs iterations')" + ] + }, + "execution_count": 17, + "metadata": { + "bento_obj_id": "139740794754384" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwoAAAFTCAYAAACZJvs3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nQogZ/i/yj6IUtWUwmQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139741777095760" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig = plt.figure(figsize=(13, 5))\n", + "ax = fig.gca()\n", + "ax.plot(chamfer_losses, label=\"chamfer loss\")\n", + "ax.plot(edge_losses, label=\"edge loss\")\n", + "ax.plot(normal_losses, label=\"normal loss\")\n", + "ax.plot(laplacian_losses, label=\"laplacian loss\")\n", + "ax.legend(fontsize=\"16\")\n", + "ax.set_xlabel(\"Iteration\", fontsize=\"16\")\n", + "ax.set_ylabel(\"Loss\", fontsize=\"16\")\n", + "ax.set_title(\"Loss vs iterations\", fontsize=\"16\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Save the predicted mesh" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": {}, + "colab_type": "code", + "collapsed": true, + "id": "krikJzrLtuvw" + }, + "outputs": [], + "source": [ + "# Fetch the verts and faces of the final predicted mesh\n", + "final_verts, final_faces = new_src_mesh.get_mesh_verts_faces(0)\n", + "\n", + "# Scale normalize back to the original target size\n", + "final_verts = final_verts * scale + center\n", + "\n", + "# Store the predicted mesh using save_obj\n", + "final_obj = os.path.join('./', 'final_model.obj')\n", + "save_obj(final_obj, final_verts, final_faces)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Conclusion \n", + "\n", + "In this tutorial we learnt how to load a mesh from an obj file, initialize a PyTorch3d datastructure called **Meshes**, set up an optimization loop and use four different PyTorch3d mesh loss functions. " + ] + } + ], + "metadata": { + "bento_stylesheets": { + "bento/extensions/flow/main.css": true, + "bento/extensions/kernel_selector/main.css": true, + "bento/extensions/kernel_ui/main.css": true, + "bento/extensions/new_kernel/main.css": true, + "bento/extensions/system_usage/main.css": true, + "bento/extensions/theme/main.css": true + }, + "colab": { + "name": "FitMesh.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "pytorch3d (local)", + "language": "python", + "name": "pytorch3d_local" + }, + "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.7.5+" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/docs/tutorials/render_textured_meshes.ipynb b/docs/tutorials/render_textured_meshes.ipynb new file mode 100644 index 00000000..34223fd5 --- /dev/null +++ b/docs/tutorials/render_textured_meshes.ipynb @@ -0,0 +1,516 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Render a textured mesh\n", + "\n", + "This tutorial shows how to:\n", + "- load a mesh and textures from an `.obj` file. \n", + "- set up a renderer \n", + "- render the mesh \n", + "- vary the rendering settings such as lighting and camera position\n", + "- use the batching features of the pytorch3d API to render the mesh from different viewpoints" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import modules" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import torch\n", + "import matplotlib.pyplot as plt\n", + "from skimage.io import imread\n", + "\n", + "# Util function for loading meshes\n", + "from pytorch3d.io import load_obj\n", + "\n", + "# Data structures and functions for rendering\n", + "from pytorch3d.structures import Meshes, Textures\n", + "from pytorch3d.renderer import (\n", + " look_at_view_transform,\n", + " OpenGLPerspectiveCameras, \n", + " PointLights, \n", + " DirectionalLights, \n", + " Materials, \n", + " RasterizationSettings, \n", + " MeshRenderer, \n", + " MeshRasterizer, \n", + " TexturedPhongShader\n", + ")\n", + "\n", + "# add path for demo utils\n", + "import sys\n", + "import os\n", + "sys.path.append(os.path.abspath(''))\n", + "from utils import image_grid" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Load a mesh and texture file\n", + "\n", + "Load an `.obj` file and it's associated `.mtl` file and create a **Textures** and **Meshes** object. \n", + "\n", + "**Meshes** is a unique datastructure provided in PyTorch3d for working with batches of meshes of different sizes. \n", + "\n", + "**Textures** is an auxillary datastructure for storing texture information about meshes. \n", + "\n", + "**Meshes** has several class methods which are used throughout the rendering pipeline." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Setup\n", + "device = torch.device(\"cuda:0\")\n", + "torch.cuda.set_device(device)\n", + "\n", + "# Set paths\n", + "DATA_DIR = \"./data\"\n", + "obj_filename = os.path.join(DATA_DIR, \"cow_mesh/cow.obj\")\n", + "\n", + "# Load obj file\n", + "verts, faces, aux = load_obj(obj_filename)\n", + "faces_idx = faces.verts_idx.to(device)\n", + "verts = verts.to(device)\n", + "\n", + "# Get textures from the outputs of the load_obj function\n", + "# the `aux` variable contains the texture maps and vertex uv coordinates. \n", + "# Refer to the `obj_io.load_obj` function for full API reference. \n", + "# Here we only have one texture map for the whole mesh. \n", + "verts_uvs = aux.verts_uvs[None, ...].to(device) # (N, V, 2)\n", + "faces_uvs = faces.textures_idx[None, ...].to(device) # (N, F, 3)\n", + "tex_maps = aux.texture_images\n", + "texture_image = list(tex_maps.values())[0]\n", + "texture_image = texture_image[None, ...].to(device) # (N, H, W, 3)\n", + "\n", + "# Create a textures object\n", + "tex = Textures(verts_uvs=verts_uvs, faces_uvs=faces_uvs, maps=texture_image)\n", + "\n", + "# Create a meshes object with textures\n", + "mesh = Meshes(verts=[verts], faces=[faces_idx], textures=tex)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Let's visualize the texture map" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 1023.5, 1023.5, -0.5)" + ] + }, + "execution_count": 3, + "metadata": { + "bento_obj_id": "139743440981360" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAGeCAYAAAAuU/5OAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n+hv2PNmUyuutLwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139743762731920" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(7,7))\n", + "plt.imshow(texture_image.squeeze().cpu().numpy())\n", + "plt.grid(\"off\")\n", + "plt.axis('off')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create a renderer\n", + "\n", + "A renderer in PyTorch3d is composed of a **rasterizer** and a **shader** which each have a number of subcomponents such as a **camera** (orthgraphic/perspective). Here we initialize some of these components and use default values for the rest.\n", + "\n", + "In this example we will first create a **renderer** which uses a **perspective camera**, a **point light** and applies **phong shading**. Then we learn how to vary different components using the modular API. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Initialize an OpenGL perspective camera.\n", + "R, T = look_at_view_transform(2.7, 10, 20)\n", + "cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T)\n", + "\n", + "# Define the settings for rasterization and shading. Here we set the output image to be of size\n", + "# 512x512. As we are rendering images for visualization purposes only we will set faces_per_pixel=1\n", + "# and blur_radius=0.0. Refer to rasterize_meshes.py for explanations of these parameters. \n", + "raster_settings = RasterizationSettings(\n", + " image_size=512, \n", + " blur_radius=0.0, \n", + " faces_per_pixel=1, \n", + " bin_size=0\n", + ")\n", + "\n", + "# Place a point light in front of the object\n", + "lights = PointLights(device=device, location=[[1.0, 1.0, -2.0]])\n", + "\n", + "# Create a phong renderer by composing a rasterizer and a shader. The textured phong shader will \n", + "# interpolate the texture uv coordinates for each vertex, sample from a texture image and \n", + "# apply the Phong lighting model\n", + "renderer = MeshRenderer(\n", + " rasterizer=MeshRasterizer(\n", + " cameras=cameras, \n", + " raster_settings=raster_settings\n", + " ),\n", + " shader=TexturedPhongShader(\n", + " device=device, \n", + " cameras=cameras,\n", + " lights=lights\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Render the mesh" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The light is in front of the object so it is bright and the image has specular highlights." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 511.5, 511.5, -0.5)" + ] + }, + "execution_count": 5, + "metadata": { + "bento_obj_id": "139743386282224" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAJBCAYAAACnLarpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139743441074064" + }, + "output_type": "display_data" + } + ], + "source": [ + "images = renderer(mesh)\n", + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(images[0, ..., :3].cpu().numpy())\n", + "plt.grid(\"off\")\n", + "plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Move the light behind the object and re-render\n", + "\n", + "We can pass arbirary keyword arguments to the `rasterizer`/`shader` via the call to the `renderer` so the renderer does not need to be reinitialized if any of the settings change/\n", + "\n", + "In this case, we can simply update the location of the lights and pass them into the call to the renderer. \n", + "\n", + "The image is now dark as there is only ambient lighting, and there are no specular highlights." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "lights.location = torch.tensor([0.0, 0.0, +1.0], device=device)[None]\n", + "images = renderer(mesh, lights=lights)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 511.5, 511.5, -0.5)" + ] + }, + "execution_count": 7, + "metadata": { + "bento_obj_id": "139743432353072" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAJBCAYAAACnLarpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngQgASE8gAgDSE4gAgPT+Hy/M7WDcCQoxAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139743401094992" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(images[0, ..., :3].cpu().numpy())\n", + "plt.grid(\"off\")\n", + "plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rotate the object, modify the material properties or light properties\n", + "\n", + "We can also change many other settings in the rendering pipeline. Here we:\n", + "\n", + "- change the **viewing angle** of the camera\n", + "- change the **position** of the point light\n", + "- change the **material reflectance** properties of the mesh" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Rotate the object by increasing the azimuth angle\n", + "R, T = look_at_view_transform(dist=2.7, elev=10, azim=50)\n", + "cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T)\n", + "\n", + "# Move the light location to be in front of the object again\n", + "lights.location = torch.tensor([[5.0, 5.0, -2.0]], device=device)\n", + "\n", + "# Change specular color to green and change material shininess \n", + "materials = Materials(\n", + " device=device,\n", + " specular_color=[[0.0, 1.0, 0.0]],\n", + " shininess=10.0\n", + ")\n", + "\n", + "# Re render the mesh, passing in keyword arguments for the modified components.\n", + "images = renderer(mesh, lights=lights, materials=materials, cameras=cameras)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(-0.5, 511.5, 511.5, -0.5)" + ] + }, + "execution_count": 9, + "metadata": { + "bento_obj_id": "139743401155952" + }, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAJBCAYAAACnLarpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139743432059792" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 10))\n", + "plt.imshow(images[0, ..., :3].cpu().numpy())\n", + "plt.grid(\"off\")\n", + "plt.axis(\"off\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Batched Rendering\n", + "\n", + "One of the core design choices of the PyTorch3d API is to suport **batched inputs for all components**. \n", + "The renderer and associated components can take batched inputs and **render a batch of output images in one forward pass**. We will now use this feature to render the mesh from many different viewpoints.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set batch size - this is the number of different viewpoints from which we want to render the mesh.\n", + "batch_size = 20\n", + "\n", + "# Create a batch of meshes by repeating the cow mesh and associated textures. \n", + "# Meshes has a useful `extend` method which allows us do this very easily. \n", + "# This also extends the textures. \n", + "meshes = mesh.extend(batch_size)\n", + "\n", + "# Get a batch of viewing angles. \n", + "elev = torch.linspace(0, 360, batch_size)\n", + "azim = torch.linspace(0, 360, batch_size)\n", + "\n", + "# All the cameras helper methods support mixed type inputs and broadcasting. So we can \n", + "# view the camera from the same distance and specify dist=2.7 as a float,\n", + "# and then specify elevation and azimuth angles for each viewpoint as tensors. \n", + "R, T = look_at_view_transform(dist=2.7, elev=elev, azim=azim)\n", + "cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T)\n", + "\n", + "# Move the light back in front of the object\n", + "lights.location = torch.tensor([[1.0, 1.0, -5.0]], device=device)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# We can pass arbirary keyword arguments to the rasterizer/shader via the renderer\n", + "# so the renderer does not need to be reinitialized if any of the settings change.\n", + "images = renderer(meshes, cameras=cameras, lights=lights)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABCcAAAKqCAYAAAAJyzSYAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nSUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "bento_obj_id": "139743401261328" + }, + "output_type": "display_data" + } + ], + "source": [ + "image_grid(images.cpu().numpy(), rows=4, cols=5, rgb=True)" + ] + } + ], + "metadata": { + "bento_stylesheets": { + "bento/extensions/flow/main.css": true, + "bento/extensions/kernel_selector/main.css": true, + "bento/extensions/kernel_ui/main.css": true, + "bento/extensions/new_kernel/main.css": true, + "bento/extensions/system_usage/main.css": true, + "bento/extensions/theme/main.css": true + }, + "kernelspec": { + "display_name": "pytorch3d (local)", + "language": "python", + "name": "pytorch3d_local" + }, + "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.7.5+" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorials/utils/__init__.py b/docs/tutorials/utils/__init__.py new file mode 100644 index 00000000..c15c125f --- /dev/null +++ b/docs/tutorials/utils/__init__.py @@ -0,0 +1,8 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .camera_visualisation import ( + get_camera_wireframe, + plot_camera_scene, + plot_cameras, +) +from .plot_image_grid import image_grid diff --git a/docs/tutorials/utils/camera_visualisation.py b/docs/tutorials/utils/camera_visualisation.py new file mode 100644 index 00000000..6d2435e6 --- /dev/null +++ b/docs/tutorials/utils/camera_visualisation.py @@ -0,0 +1,71 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import matplotlib.pyplot as plt +import torch +from mpl_toolkits.mplot3d import Axes3D # noqa: F401 unused import + + +def get_camera_wireframe(scale: float = 0.3): + """ + Returns a wireframe of a 3D line-plot of a camera symbol. + """ + a = 0.5 * torch.tensor([-2, 1.5, 4]) + b = 0.5 * torch.tensor([2, 1.5, 4]) + c = 0.5 * torch.tensor([-2, -1.5, 4]) + d = 0.5 * torch.tensor([2, -1.5, 4]) + C = torch.zeros(3) + F = torch.tensor([0, 0, 3]) + camera_points = [a, b, d, c, a, C, b, d, C, c, C, F] + lines = torch.stack([x.float() for x in camera_points]) * scale + return lines + + +def plot_cameras(ax, cameras, color: str = "blue"): + """ + Plots a set of `cameras` objects into the maplotlib axis `ax` with + color `color`. + """ + cam_wires_canonical = get_camera_wireframe().cuda()[None] + cam_trans = cameras.get_world_to_view_transform().inverse() + cam_wires_trans = cam_trans.transform_points(cam_wires_canonical) + plot_handles = [] + for wire in cam_wires_trans: + # the Z and Y axes are flipped intentionally here! + x_, z_, y_ = wire.detach().cpu().numpy().T.astype(float) + (h,) = ax.plot(x_, y_, z_, color=color, linewidth=0.3) + plot_handles.append(h) + return plot_handles + + +def plot_camera_scene(cameras, cameras_gt, status: str): + """ + Plots a set of predicted cameras `cameras` and their corresponding + ground truth locations `cameras_gt`. The plot is named with + a string passed inside the `status` argument. + """ + fig = plt.figure() + ax = fig.gca(projection="3d") + ax.clear() + ax.set_title(status) + handle_cam = plot_cameras(ax, cameras, color="#FF7D1E") + handle_cam_gt = plot_cameras(ax, cameras_gt, color="#812CE5") + plot_radius = 3 + ax.set_xlim3d([-plot_radius, plot_radius]) + ax.set_ylim3d([3 - plot_radius, 3 + plot_radius]) + ax.set_zlim3d([-plot_radius, plot_radius]) + ax.set_xlabel("x") + ax.set_ylabel("z") + ax.set_zlabel("y") + labels_handles = { + "Estimated cameras": handle_cam[0], + "GT cameras": handle_cam_gt[0], + } + ax.legend( + labels_handles.values(), + labels_handles.keys(), + loc="upper center", + bbox_to_anchor=(0.5, 0), + ) + plt.show() + return fig diff --git a/docs/tutorials/utils/plot_image_grid.py b/docs/tutorials/utils/plot_image_grid.py new file mode 100644 index 00000000..a84661be --- /dev/null +++ b/docs/tutorials/utils/plot_image_grid.py @@ -0,0 +1,54 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import matplotlib.pyplot as plt + + +def image_grid( + images, + rows=None, + cols=None, + fill: bool = True, + show_axes: bool = False, + rgb: bool = True, +): + """ + A util function for plotting a grid of images. + + Args: + images: (N, H, W, 4) array of RGBA images + rows: number of rows in the grid + cols: number of columns in the grid + fill: boolean indicating if the space between images should be filled + show_axes: boolean indicating if the axes of the plots should be visible + rgb: boolean, If True, only RGB channels are plotted. + If False, only the alpha channel is plotted. + + Returns: + None + """ + if (rows is None) != (cols is None): + raise ValueError("Specify either both rows and cols or neither.") + + if rows is None: + rows = len(images) + cols = 1 + + gridspec_kw = {"wspace": 0.0, "hspace": 0.0} if fill else {} + fig, axarr = plt.subplots( + rows, cols, gridspec_kw=gridspec_kw, figsize=(15, 9) + ) + bleed = 0 + fig.subplots_adjust( + left=bleed, bottom=bleed, right=(1 - bleed), top=(1 - bleed) + ) + + for ax, im in zip(axarr.ravel(), images): + if rgb: + # only render RGB channels + ax.imshow(im[..., :3]) + else: + # only render Alpha channel + ax.imshow(im[..., 3]) + if not show_axes: + ax.set_axis_off() diff --git a/packaging/build_conda.sh b/packaging/build_conda.sh new file mode 100755 index 00000000..bf309040 --- /dev/null +++ b/packaging/build_conda.sh @@ -0,0 +1,15 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set -ex + +script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +. "$script_dir/pkg_helpers.bash" + +export BUILD_TYPE=conda +setup_env 0.1.0 +export SOURCE_ROOT_DIR="$PWD" +setup_conda_pytorch_constraint +setup_conda_cudatoolkit_constraint +setup_visual_studio_constraint +# shellcheck disable=SC2086 +conda build $CONDA_CHANNEL_FLAGS ${TEST_FLAG:-} -c defaults -c conda-forge --no-anaconda-upload -c takatosp1 --python "$PYTHON_VERSION" packaging/pytorch3d diff --git a/packaging/build_wheel.sh b/packaging/build_wheel.sh new file mode 100755 index 00000000..d2a9cd80 --- /dev/null +++ b/packaging/build_wheel.sh @@ -0,0 +1,14 @@ +#!/bin/bash +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set -ex + +script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" +. "$script_dir/pkg_helpers.bash" + +export BUILD_TYPE=wheel +setup_env 0.1.0 +setup_wheel_python +pip_install numpy +setup_pip_pytorch_version +python setup.py clean +IS_WHEEL=1 python setup.py bdist_wheel diff --git a/packaging/conda/build_pytorch3d.sh b/packaging/conda/build_pytorch3d.sh new file mode 100755 index 00000000..ba202e37 --- /dev/null +++ b/packaging/conda/build_pytorch3d.sh @@ -0,0 +1,215 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +if [[ -x "/remote/anaconda_token" ]]; then + . /remote/anaconda_token || true +fi + +set -ex + +# Function to retry functions that sometimes timeout or have flaky failures +retry () { + $* || (sleep 1 && $*) || (sleep 2 && $*) || (sleep 4 && $*) || (sleep 8 && $*) +} + +# Parse arguments and determmine version +########################################################### + +if [ "$#" -ne 3 ]; then + echo "Illegal number of parameters. Pass cuda version, pytorch3d version, pytorch3d build number" + echo "CUDA version should be Mm with no dot, e.g. '80'" + echo "DESIRED_PYTHON should be M.m, e.g. '2.7'" + exit 1 +fi + +desired_cuda="$1" +build_version="$2" +build_number="$3" + +if [[ "$desired_cuda" != cpu ]]; then + desired_cuda="$(echo $desired_cuda | tr -d cuda. )" +fi +echo "Building cuda version $desired_cuda and pytorch3d version: $build_version build_number: $build_number" + +if [[ "$desired_cuda" == 'cpu' ]]; then + cpu_only=1 + cuver="cpu" +else + # Switch desired_cuda to be M.m to be consistent with other scripts in + # pytorch/builder + export FORCE_CUDA=1 + cuda_nodot="$desired_cuda" + + if [[ ${#cuda_nodot} -eq 2 ]]; then + desired_cuda="${desired_cuda:0:1}.${desired_cuda:1:1}" + elif [[ ${#cuda_nodot} -eq 3 ]]; then + desired_cuda="${desired_cuda:0:2}.${desired_cuda:2:1}" + else + echo "unknown cuda version $cuda_nodot" + exit 1 + fi + + cuver="cu$cuda_nodot" +fi + +export PYTORCH3D_BUILD_VERSION=$build_version +export PYTORCH3D_BUILD_NUMBER=$build_number + +if [[ -z "$DESIRED_PYTHON" ]]; then + DESIRED_PYTHON=('3.5' '3.6' '3.7') +fi + +SOURCE_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null && pwd )" + +if [[ -z "$WIN_PACKAGE_WORK_DIR" ]]; then + WIN_PACKAGE_WORK_DIR="$(echo $(pwd -W) | tr '/' '\\')\\tmp_conda_$(date +%H%M%S)" +fi + +mkdir -p "$WIN_PACKAGE_WORK_DIR" || true +pytorch3d_rootdir="$(realpath ${WIN_PACKAGE_WORK_DIR})/pytorch3d-src" +git config --system core.longpaths true + +if [[ ! -d "$pytorch3d_rootdir" ]]; then + rm -rf "$pytorch3d_rootdir" + git clone SOURCE_DIR/../.. "$pytorch3d_rootdir" + + # pushd "$vision_rootdir" + # git checkout $PYTORCH_BRANCH + # popd +fi + +cd "$SOURCE_DIR" + +export tmp_conda="${WIN_PACKAGE_WORK_DIR}\\conda" +export miniconda_exe="${WIN_PACKAGE_WORK_DIR}\\miniconda.exe" +rm -rf "$tmp_conda" +rm -f "$miniconda_exe" +curl -sSk https://repo.continuum.io/miniconda/Miniconda3-latest-Windows-x86_64.exe -o "$miniconda_exe" +"$SOURCE_DIR/install_conda.bat" && rm "$miniconda_exe" +pushd $tmp_conda +export PATH="$(pwd):$(pwd)/Library/usr/bin:$(pwd)/Library/bin:$(pwd)/Scripts:$(pwd)/bin:$PATH" +popd +retry conda install -yq conda-build + +ANACONDA_USER=pytorch-nightly +conda config --set anaconda_upload no + + +export TORCHVISION_PACKAGE_SUFFIX="" +if [[ "$desired_cuda" == 'cpu' ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="" + export CONDA_CPUONLY_FEATURE="- cpuonly # [not osx]" + export CUDA_VERSION="None" +else + export CONDA_CPUONLY_FEATURE="" + . ./switch_cuda_version.sh $desired_cuda + if [[ "$desired_cuda" == "10.1" ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=10.1,<10.2 # [not osx]" + elif [[ "$desired_cuda" == "10.0" ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=10.0,<10.1 # [not osx]" + elif [[ "$desired_cuda" == "9.2" ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=9.2,<9.3 # [not osx]" + elif [[ "$desired_cuda" == "9.0" ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=9.0,<9.1 # [not osx]" + elif [[ "$desired_cuda" == "8.0" ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=8.0,<8.1 # [not osx]" + else + echo "unhandled desired_cuda: $desired_cuda" + exit 1 + fi +fi + +if [[ -z "$PYTORCH_VERSION" ]]; then + export CONDA_CHANNEL_FLAGS="-c pytorch-nightly" + export PYTORCH_VERSION="$(conda search --json 'pytorch[channel=pytorch-nightly]' | \ + python -c "import os, sys, json, re; cuver = '$cuver'; \ + cuver = cuver.replace('cu', 'cuda') if cuver != 'cpu' else cuver; \ + print(re.sub(r'\\+.*$', '', \ + [x['version'] for x in json.load(sys.stdin)['pytorch'] \ + if (x['platform'] == 'darwin' or cuver in x['fn']) \ + and 'py' + os.environ['DESIRED_PYTHON'] in x['fn']][-1]))")" + if [[ -z "$PYTORCH_VERSION" ]]; then + echo "PyTorch version auto detection failed" + echo "No package found for desired_cuda=$desired_cuda and DESIRED_PYTHON=$DESIRED_PYTHON" + exit 1 + fi +else + export CONDA_CHANNEL_FLAGS="-c pytorch -c pytorch-nightly" +fi +if [[ "$desired_cuda" == 'cpu' ]]; then + export CONDA_PYTORCH_BUILD_CONSTRAINT="- pytorch==$PYTORCH_VERSION" + export CONDA_PYTORCH_CONSTRAINT="- pytorch==$PYTORCH_VERSION" +else + export CONDA_PYTORCH_BUILD_CONSTRAINT="- pytorch==${PYTORCH_VERSION}" + export CONDA_PYTORCH_CONSTRAINT="- pytorch==${PYTORCH_VERSION}" +fi + +# Loop through all Python versions to build a package for each +for py_ver in "${DESIRED_PYTHON[@]}"; do + build_string="py${py_ver}_${build_string_suffix}" + folder_tag="${build_string}_$(date +'%Y%m%d')" + + # Create the conda package into this temporary folder. This is so we can find + # the package afterwards, as there's no easy way to extract the final filename + # from conda-build + output_folder="out_$folder_tag" + rm -rf "$output_folder" + mkdir "$output_folder" + + export VSTOOLCHAIN_PACKAGE=vs2017 + + # We need to build the compiler activation scripts first on Windows + time VSDEVCMD_ARGS=${VSDEVCMD_ARGS[@]} \ + conda build -c "$ANACONDA_USER" \ + --no-anaconda-upload \ + --output-folder "$output_folder" \ + ../$VSTOOLCHAIN_PACKAGE + + cp ../$VSTOOLCHAIN_PACKAGE/conda_build_config.yaml ../torchvision/conda_build_config.yaml + + conda config --set anaconda_upload no + echo "Calling conda-build at $(date)" + if [[ "$desired_cuda" == "9.2" ]]; then + time CMAKE_ARGS=${CMAKE_ARGS[@]} \ + BUILD_VERSION="$PYTORCH3D_BUILD_VERSION" \ + CU_VERSION="$cuver" \ + SOURCE_ROOT_DIR="$pytorch3d_rootdir" \ + conda build -c "$ANACONDA_USER" \ + -c defaults \ + -c conda-forge \ + -c "numba/label/dev" \ + --no-anaconda-upload \ + --python "$py_ver" \ + --output-folder "$output_folder" \ + --no-verify \ + --no-test \ + ../torchvision + else + time CMAKE_ARGS=${CMAKE_ARGS[@]} \ + BUILD_VERSION="$PYTORCH3D_BUILD_VERSION" \ + CU_VERSION="$cuver" \ + SOURCE_ROOT_DIR="$pytorch3d_rootdir" \ + conda build -c "$ANACONDA_USER" \ + -c defaults \ + -c conda-forge \ + --no-anaconda-upload \ + --python "$py_ver" \ + --output-folder "$output_folder" \ + --no-verify \ + --no-test \ + ../torchvision + fi + echo "Finished conda-build at $(date)" + + # Extract the package for testing + ls -lah "$output_folder" + built_package="$(find $output_folder/ -name '*torchvision*.tar.bz2')" + + # Copy the built package to the host machine for persistence before testing + if [[ -n "$PYTORCH_FINAL_PACKAGE_DIR" ]]; then + mkdir -p "$PYTORCH_FINAL_PACKAGE_DIR" || true + cp "$built_package" "$PYTORCH_FINAL_PACKAGE_DIR/" + fi +done + + +set +e diff --git a/packaging/conda/install_conda.bat b/packaging/conda/install_conda.bat new file mode 100644 index 00000000..c8200b6f --- /dev/null +++ b/packaging/conda/install_conda.bat @@ -0,0 +1,2 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +start /wait "" "%miniconda_exe%" /S /InstallationType=JustMe /RegisterPython=0 /AddToPath=0 /D=%tmp_conda% diff --git a/packaging/conda/switch_cuda_version.sh b/packaging/conda/switch_cuda_version.sh new file mode 100755 index 00000000..05fa5249 --- /dev/null +++ b/packaging/conda/switch_cuda_version.sh @@ -0,0 +1,30 @@ +#!/usr/bin/env bash +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +if [[ "$OSTYPE" == "msys" ]]; then + CUDA_DIR="/c/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v$1" +else + CUDA_DIR="/usr/local/cuda-$1" +fi + +if ! ls "$CUDA_DIR" +then + echo "folder $CUDA_DIR not found to switch" +fi + +echo "Switching symlink to $CUDA_DIR" +mkdir -p /usr/local +rm -fr /usr/local/cuda +ln -s "$CUDA_DIR" /usr/local/cuda + +if [[ "$OSTYPE" == "msys" ]]; then + export CUDA_VERSION=`ls /usr/local/cuda/bin/cudart64*.dll | head -1 | tr '._' ' ' | cut -d ' ' -f2` + export CUDNN_VERSION=`ls /usr/local/cuda/bin/cudnn64*.dll | head -1 | tr '._' ' ' | cut -d ' ' -f2` +else + export CUDA_VERSION=$(ls /usr/local/cuda/lib64/libcudart.so.*|sort|tac | head -1 | rev | cut -d"." -f -3 | rev) + export CUDNN_VERSION=$(ls /usr/local/cuda/lib64/libcudnn.so.*|sort|tac | head -1 | rev | cut -d"." -f -3 | rev) +fi + +ls -alh /usr/local/cuda + +echo "CUDA_VERSION=$CUDA_VERSION" +echo "CUDNN_VERSION=$CUDNN_VERSION" diff --git a/packaging/pkg_helpers.bash b/packaging/pkg_helpers.bash new file mode 100644 index 00000000..7cb289c2 --- /dev/null +++ b/packaging/pkg_helpers.bash @@ -0,0 +1,265 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +# shellcheck shell=bash +# A set of useful bash functions for common functionality we need to do in +# many build scripts + + +# Setup CUDA environment variables, based on CU_VERSION +# +# Inputs: +# CU_VERSION (cu92, cu100, cu101) +# NO_CUDA_PACKAGE (bool) +# BUILD_TYPE (conda, wheel) +# +# Outputs: +# VERSION_SUFFIX (e.g., "") +# PYTORCH_VERSION_SUFFIX (e.g., +cpu) +# WHEEL_DIR (e.g., cu100/) +# CUDA_HOME (e.g., /usr/local/cuda-9.2, respected by torch.utils.cpp_extension) +# FORCE_CUDA (respected by pytorch3d setup.py) +# NVCC_FLAGS (respected by pytorch3d setup.py) +# +# Precondition: CUDA versions are installed in their conventional locations in +# /usr/local/cuda-* +# +# NOTE: Why VERSION_SUFFIX versus PYTORCH_VERSION_SUFFIX? If you're building +# a package with CUDA on a platform we support CUDA on, VERSION_SUFFIX == +# PYTORCH_VERSION_SUFFIX and everyone is happy. However, if you are building a +# package with only CPU bits (e.g., torchaudio), then VERSION_SUFFIX is always +# empty, but PYTORCH_VERSION_SUFFIX is +cpu (because that's how you get a CPU +# version of a Python package. But that doesn't apply if you're on OS X, +# since the default CU_VERSION on OS X is cpu. +setup_cuda() { + + # First, compute version suffixes. By default, assume no version suffixes + export VERSION_SUFFIX="" + export PYTORCH_VERSION_SUFFIX="" + export WHEEL_DIR="" + # Wheel builds need suffixes (but not if they're on OS X, which never has suffix) + if [[ "$BUILD_TYPE" == "wheel" ]] && [[ "$(uname)" != Darwin ]]; then + # The default CUDA has no suffix + if [[ "$CU_VERSION" != "cu101" ]]; then + export PYTORCH_VERSION_SUFFIX="+$CU_VERSION" + fi + # Match the suffix scheme of pytorch, unless this package does not have + # CUDA builds (in which case, use default) + if [[ -z "$NO_CUDA_PACKAGE" ]]; then + export VERSION_SUFFIX="$PYTORCH_VERSION_SUFFIX" + export WHEEL_DIR="$CU_VERSION/" + fi + fi + + # Now work out the CUDA settings + case "$CU_VERSION" in + cu101) + if [[ "$OSTYPE" == "msys" ]]; then + export CUDA_HOME="C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.1" + else + export CUDA_HOME=/usr/local/cuda-10.1/ + fi + export FORCE_CUDA=1 + # Hard-coding gencode flags is temporary situation until + # https://github.com/pytorch/pytorch/pull/23408 lands + export NVCC_FLAGS="-gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_50,code=compute_50" + ;; + cu100) + if [[ "$OSTYPE" == "msys" ]]; then + export CUDA_HOME="C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v10.0" + else + export CUDA_HOME=/usr/local/cuda-10.0/ + fi + export FORCE_CUDA=1 + # Hard-coding gencode flags is temporary situation until + # https://github.com/pytorch/pytorch/pull/23408 lands + export NVCC_FLAGS="-gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_75,code=sm_75 -gencode=arch=compute_50,code=compute_50" + ;; + cu92) + if [[ "$OSTYPE" == "msys" ]]; then + export CUDA_HOME="C:\\Program Files\\NVIDIA GPU Computing Toolkit\\CUDA\\v9.2" + else + export CUDA_HOME=/usr/local/cuda-9.2/ + fi + export FORCE_CUDA=1 + export NVCC_FLAGS="-gencode=arch=compute_35,code=sm_35 -gencode=arch=compute_50,code=sm_50 -gencode=arch=compute_60,code=sm_60 -gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_50,code=compute_50" + ;; + cpu) + ;; + *) + echo "Unrecognized CU_VERSION=$CU_VERSION" + exit 1 + ;; + esac +} + +# Populate build version if necessary, and add version suffix +# +# Inputs: +# BUILD_VERSION (e.g., 0.2.0 or empty) +# VERSION_SUFFIX (e.g., +cpu) +# +# Outputs: +# BUILD_VERSION (e.g., 0.2.0.dev20190807+cpu) +# +# Fill BUILD_VERSION if it doesn't exist already with a nightly string +# Usage: setup_build_version 0.2.0 +setup_build_version() { + if [[ -z "$BUILD_VERSION" ]]; then + export BUILD_VERSION="$1.dev$(date "+%Y%m%d")$VERSION_SUFFIX" + else + export BUILD_VERSION="$BUILD_VERSION$VERSION_SUFFIX" + fi +} + +# Set some useful variables for OS X, if applicable +setup_macos() { + if [[ "$(uname)" == Darwin ]]; then + export MACOSX_DEPLOYMENT_TARGET=10.9 CC=clang CXX=clang++ + fi +} + +# Top-level entry point for things every package will need to do +# +# Usage: setup_env 0.2.0 +setup_env() { + setup_cuda + setup_build_version "$1" + setup_macos +} + +# Function to retry functions that sometimes timeout or have flaky failures +retry () { + $* || (sleep 1 && $*) || (sleep 2 && $*) || (sleep 4 && $*) || (sleep 8 && $*) +} + +# Inputs: +# PYTHON_VERSION (2.7, 3.5, 3.6, 3.7) +# UNICODE_ABI (bool) +# +# Outputs: +# PATH modified to put correct Python version in PATH +# +# Precondition: If Linux, you are in a soumith/manylinux-cuda* Docker image +setup_wheel_python() { + if [[ "$(uname)" == Darwin ]]; then + eval "$(conda shell.bash hook)" + conda env remove -n "env$PYTHON_VERSION" || true + conda create -yn "env$PYTHON_VERSION" python="$PYTHON_VERSION" + conda activate "env$PYTHON_VERSION" + else + case "$PYTHON_VERSION" in + 2.7) + if [[ -n "$UNICODE_ABI" ]]; then + python_abi=cp27-cp27mu + else + python_abi=cp27-cp27m + fi + ;; + 3.5) python_abi=cp35-cp35m ;; + 3.6) python_abi=cp36-cp36m ;; + 3.7) python_abi=cp37-cp37m ;; + 3.8) python_abi=cp38-cp38 ;; + *) + echo "Unrecognized PYTHON_VERSION=$PYTHON_VERSION" + exit 1 + ;; + esac + export PATH="/opt/python/$python_abi/bin:$PATH" + fi +} + +# Install with pip a bit more robustly than the default +pip_install() { + retry pip install --progress-bar off "$@" +} + +# Install torch with pip, respecting PYTORCH_VERSION, and record the installed +# version into PYTORCH_VERSION, if applicable +setup_pip_pytorch_version() { + if [[ -z "$PYTORCH_VERSION" ]]; then + # Install latest prerelease version of torch, per our nightlies, consistent + # with the requested cuda version + pip_install --pre torch -f "https://download.pytorch.org/whl/nightly/${WHEEL_DIR}torch_nightly.html" + if [[ "$CUDA_VERSION" == "cpu" ]]; then + # CUDA and CPU are ABI compatible on the CPU-only parts, so strip + # in this case + export PYTORCH_VERSION="$(pip show torch | grep ^Version: | sed 's/Version: *//' | sed 's/+.\+//')" + else + export PYTORCH_VERSION="$(pip show torch | grep ^Version: | sed 's/Version: *//')" + fi + else + pip_install "torch==$PYTORCH_VERSION$CUDA_SUFFIX" \ + -f https://download.pytorch.org/whl/torch_stable.html \ + -f https://download.pytorch.org/whl/nightly/torch_nightly.html + fi +} + +# Fill PYTORCH_VERSION with the latest conda nightly version, and +# CONDA_CHANNEL_FLAGS with appropriate flags to retrieve these versions +# +# You MUST have populated CUDA_SUFFIX before hand. +setup_conda_pytorch_constraint() { + if [[ -z "$PYTORCH_VERSION" ]]; then + export CONDA_CHANNEL_FLAGS="-c pytorch-nightly" + export PYTORCH_VERSION="$(conda search --json 'pytorch[channel=pytorch-nightly]' | \ + python -c "import os, sys, json, re; cuver = os.environ.get('CU_VERSION'); \ + cuver_1 = cuver.replace('cu', 'cuda') if cuver != 'cpu' else cuver; \ + cuver_2 = (cuver[:-1] + '.' + cuver[-1]).replace('cu', 'cuda') if cuver != 'cpu' else cuver; \ + print(re.sub(r'\\+.*$', '', \ + [x['version'] for x in json.load(sys.stdin)['pytorch'] \ + if (x['platform'] == 'darwin' or cuver_1 in x['fn'] or cuver_2 in x['fn']) \ + and 'py' + os.environ['PYTHON_VERSION'] in x['fn']][-1]))")" + if [[ -z "$PYTORCH_VERSION" ]]; then + echo "PyTorch version auto detection failed" + echo "No package found for CU_VERSION=$CU_VERSION and PYTHON_VERSION=$PYTHON_VERSION" + exit 1 + fi + else + export CONDA_CHANNEL_FLAGS="-c pytorch -c pytorch-nightly" + fi + if [[ "$CU_VERSION" == cpu ]]; then + export CONDA_PYTORCH_BUILD_CONSTRAINT="- pytorch==$PYTORCH_VERSION${PYTORCH_VERSION_SUFFIX}" + export CONDA_PYTORCH_CONSTRAINT="- pytorch==$PYTORCH_VERSION" + else + export CONDA_PYTORCH_BUILD_CONSTRAINT="- pytorch==${PYTORCH_VERSION}${PYTORCH_VERSION_SUFFIX}" + export CONDA_PYTORCH_CONSTRAINT="- pytorch==${PYTORCH_VERSION}${PYTORCH_VERSION_SUFFIX}" + fi +} + +# Translate CUDA_VERSION into CUDA_CUDATOOLKIT_CONSTRAINT +setup_conda_cudatoolkit_constraint() { + export CONDA_CPUONLY_FEATURE="" + if [[ "$(uname)" == Darwin ]]; then + export CONDA_CUDATOOLKIT_CONSTRAINT="" + else + case "$CU_VERSION" in + cu101) + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=10.1,<10.2 # [not osx]" + ;; + cu100) + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=10.0,<10.1 # [not osx]" + ;; + cu92) + export CONDA_CUDATOOLKIT_CONSTRAINT="- cudatoolkit >=9.2,<9.3 # [not osx]" + ;; + cpu) + export CONDA_CUDATOOLKIT_CONSTRAINT="" + export CONDA_CPUONLY_FEATURE="- cpuonly" + ;; + *) + echo "Unrecognized CU_VERSION=$CU_VERSION" + exit 1 + ;; + esac + fi +} + +# Build the proper compiler package before building the final package +setup_visual_studio_constraint() { + if [[ "$OSTYPE" == "msys" ]]; then + export VSTOOLCHAIN_PACKAGE=vs2019 + export VSDEVCMD_ARGS='' + # shellcheck disable=SC2086 + conda build $CONDA_CHANNEL_FLAGS --no-anaconda-upload packaging/$VSTOOLCHAIN_PACKAGE + cp packaging/$VSTOOLCHAIN_PACKAGE/conda_build_config.yaml packaging/torchvision/conda_build_config.yaml + fi +} diff --git a/packaging/pytorch3d/conda_build_config.yaml b/packaging/pytorch3d/conda_build_config.yaml new file mode 100644 index 00000000..5188bb0e --- /dev/null +++ b/packaging/pytorch3d/conda_build_config.yaml @@ -0,0 +1,24 @@ +blas_impl: + - mkl # [x86_64] +c_compiler: + - vs2017 # [win] +cxx_compiler: + - vs2017 # [win] +python: + - 3.5 + - 3.6 +# This differs from target_platform in that it determines what subdir the compiler +# will target, not what subdir the compiler package will be itself. +# For example, we need a win-64 vs2008_win-32 package, so that we compile win-32 +# code on win-64 miniconda. +cross_compiler_target_platform: + - win-64 # [win] +target_platform: + - win-64 # [win] +vc: + - 14 +zip_keys: + - # [win] + - vc # [win] + - c_compiler # [win] + - cxx_compiler # [win] diff --git a/packaging/pytorch3d/meta.yaml b/packaging/pytorch3d/meta.yaml new file mode 100644 index 00000000..f2b83d6e --- /dev/null +++ b/packaging/pytorch3d/meta.yaml @@ -0,0 +1,60 @@ +package: + name: pytorch3d + version: "{{ environ.get('BUILD_VERSION') }}" + +source: + path: "{{ environ.get('SOURCE_ROOT_DIR') }}" + +requirements: + build: + - {{ compiler('c') }} # [win] + + host: + - python + - setuptools + {{ environ.get('CONDA_PYTORCH_BUILD_CONSTRAINT') }} + {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }} + {{ environ.get('CONDA_CPUONLY_FEATURE') }} + + run: + - python + - numpy >=1.11 + - six + - torchvision >=0.5 + - fvcore + {{ environ.get('CONDA_PYTORCH_CONSTRAINT') }} + {{ environ.get('CONDA_CUDATOOLKIT_CONSTRAINT') }} + +build: + string: py{{py}}_{{ environ['CU_VERSION'] }} + script: python setup.py install --single-version-externally-managed --record=record.txt # [not win] + script_env: + - CUDA_HOME + - FORCE_CUDA + - NVCC_FLAGS + features: + {{ environ.get('CONDA_CPUONLY_FEATURE') }} + +test: + imports: + - pytorch3d + source_files: + - tests + - docs + requires: + - pytest + - scipy + - mock + - av + - ca-certificates + - typing + commands: + #pytest . + python -m unittest discover -v -s tests + + +about: + home: https://github.com/facebookresearch/pytorch3d + license: BSD + license_file: LICENSE + summary: '3d Geometry for pytorch' diff --git a/packaging/vs2017/activate.bat b/packaging/vs2017/activate.bat new file mode 100644 index 00000000..b95e10c7 --- /dev/null +++ b/packaging/vs2017/activate.bat @@ -0,0 +1,45 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +:: Set env vars that tell distutils to use the compiler that we put on path +SET DISTUTILS_USE_SDK=1 +SET MSSdk=1 + +SET "VS_VERSION=15.0" +SET "VS_MAJOR=15" +SET "VS_YEAR=2017" + +set "MSYS2_ARG_CONV_EXCL=/AI;/AL;/OUT;/out" +set "MSYS2_ENV_CONV_EXCL=CL" + +:: For Python 3.5+, ensure that we link with the dynamic runtime. See +:: http://stevedower.id.au/blog/building-for-python-3-5-part-two/ for more info +set "PY_VCRUNTIME_REDIST=%PREFIX%\\bin\\vcruntime140.dll" + +for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -legacy -products * -version [15^,16^) -property installationPath`) do ( + if exist "%%i" if exist "%%i\VC\Auxiliary\Build\vcvarsall.bat" ( + set "VSINSTALLDIR=%%i\" + goto :vswhere + ) +) + +:vswhere + +:: Shorten PATH to avoid the `input line too long` error. +SET MyPath=%PATH% + +setlocal EnableDelayedExpansion + +SET TempPath="%MyPath:;=";"%" +SET var= +FOR %%a IN (%TempPath%) DO ( + IF EXIST %%~sa ( + SET "var=!var!;%%~sa" + ) +) + +set "TempPath=!var:~1!" +endlocal & set "PATH=%TempPath%" + +:: Shorten current directory too +FOR %%A IN (.) DO CD "%%~sA" + +:: other things added by install_activate.bat at package build time diff --git a/packaging/vs2017/conda_build_config.yaml b/packaging/vs2017/conda_build_config.yaml new file mode 100644 index 00000000..5188bb0e --- /dev/null +++ b/packaging/vs2017/conda_build_config.yaml @@ -0,0 +1,24 @@ +blas_impl: + - mkl # [x86_64] +c_compiler: + - vs2017 # [win] +cxx_compiler: + - vs2017 # [win] +python: + - 3.5 + - 3.6 +# This differs from target_platform in that it determines what subdir the compiler +# will target, not what subdir the compiler package will be itself. +# For example, we need a win-64 vs2008_win-32 package, so that we compile win-32 +# code on win-64 miniconda. +cross_compiler_target_platform: + - win-64 # [win] +target_platform: + - win-64 # [win] +vc: + - 14 +zip_keys: + - # [win] + - vc # [win] + - c_compiler # [win] + - cxx_compiler # [win] diff --git a/packaging/vs2017/install_activate.bat b/packaging/vs2017/install_activate.bat new file mode 100644 index 00000000..fdbb7212 --- /dev/null +++ b/packaging/vs2017/install_activate.bat @@ -0,0 +1,30 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set YEAR=2017 +set VER=15 + +mkdir "%PREFIX%\etc\conda\activate.d" +COPY "%RECIPE_DIR%\activate.bat" "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + +IF "%cross_compiler_target_platform%" == "win-64" ( + set "target_platform=amd64" + echo SET "CMAKE_GENERATOR=Visual Studio %VER% %YEAR% Win64" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + IF "%VSDEVCMD_ARGS%" == "" ( + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x64 >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x86_amd64 >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) ELSE ( + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x64 %VSDEVCMD_ARGS% >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x86_amd64 %VSDEVCMD_ARGS% >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) else ( + set "target_platform=x86" + echo SET "CMAKE_GENERATOR=Visual Studio %VER% %YEAR%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvars32.bat" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd + ) diff --git a/packaging/vs2017/install_runtime.bat b/packaging/vs2017/install_runtime.bat new file mode 100644 index 00000000..f0749d44 --- /dev/null +++ b/packaging/vs2017/install_runtime.bat @@ -0,0 +1,50 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set VC_PATH=x86 +if "%ARCH%"=="64" ( + set VC_PATH=x64 +) + +set MSC_VER=2017 + +rem :: This should always be present for VC installed with VS. Not sure about VC installed with Visual C++ Build Tools 2015 +rem FOR /F "usebackq tokens=3*" %%A IN (`REG QUERY "HKEY_LOCAL_MACHINE\Software\Microsoft\DevDiv\VC\Servicing\14.0\IDE.x64" /v UpdateVersion`) DO ( +rem set SP=%%A +rem ) + +rem if not "%SP%" == "%PKG_VERSION%" ( +rem echo "Version detected from registry: %SP%" +rem echo "does not match version of package being built (%PKG_VERSION%)" +rem echo "Do you have current updates for VS 2015 installed?" +rem exit 1 +rem ) + + +REM ========== REQUIRES Win 10 SDK be installed, or files otherwise copied to location below! +robocopy "C:\Program Files (x86)\Windows Kits\10\Redist\ucrt\DLLs\%VC_PATH%" "%LIBRARY_BIN%" *.dll /E +robocopy "C:\Program Files (x86)\Windows Kits\10\Redist\ucrt\DLLs\%VC_PATH%" "%PREFIX%" *.dll /E +if %ERRORLEVEL% GEQ 8 exit 1 + +REM ========== This one comes from visual studio 2017 +set "VC_VER=141" + +for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -legacy -products * -version [15^,16^) -property installationPath`) do ( + if exist "%%i" if exist "%%i\VC\Auxiliary\Build\vcvarsall.bat" ( + set "VS15VCVARSALL=%%i\VC\Auxiliary\Build\vcvarsall.bat" + goto :eof + ) +) + +@setlocal +call "%VS15VARSALL%" x64 + +set "REDIST_ROOT=%VCToolsRedistDir%%VC_PATH%" + +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.CRT" "%LIBRARY_BIN%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.CRT" "%PREFIX%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.OpenMP" "%LIBRARY_BIN%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.OpenMP" "%PREFIX%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +@endlocal diff --git a/packaging/vs2017/meta.yaml b/packaging/vs2017/meta.yaml new file mode 100644 index 00000000..34f4860b --- /dev/null +++ b/packaging/vs2017/meta.yaml @@ -0,0 +1,45 @@ +{% set vcver="14.1" %} +{% set vcfeature="14" %} +{% set vsyear="2017" %} +{% set fullver="15.4.27004.2010" %} + +package: + name: vs{{ vsyear }} + version: {{ fullver }} + +build: + skip: True [not win] + script_env: + - VSDEVCMD_ARGS # [win] + +outputs: + - name: vs{{ vsyear }}_{{ cross_compiler_target_platform }} + script: install_activate.bat + track_features: + # VS 2017 is binary-compatible with VS 2015/vc14. Tools are "v141". + strong: + - vc{{ vcfeature }} + run_exports: + - vc {{ vcver }} + about: + summary: Activation and version verification of MSVC {{ vcver }} (VS {{ vsyear }}) compiler + license: BSD 3-clause + - name: vs{{ vsyear }}_runtime + script: install_runtime.bat + - name: vc + version: {{ vcver }} + track_features: + - vc{{ vcfeature }} + requirements: + run: + - {{ pin_subpackage('vs' ~ vsyear ~ '_runtime') }} + about: + home: https://github.com/conda/conda/wiki/VC-features + license: Modified BSD License (3-clause) + license_family: BSD + summary: A meta-package to track VC features. + description: | + This metapackage is used to activate vc features without + depending on Python. + doc_url: https://github.com/conda/conda/wiki/VC-features + dev_url: https://github.com/conda/conda/wiki/VC-features diff --git a/packaging/vs2019/activate.bat b/packaging/vs2019/activate.bat new file mode 100644 index 00000000..660551a8 --- /dev/null +++ b/packaging/vs2019/activate.bat @@ -0,0 +1,45 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +:: Set env vars that tell distutils to use the compiler that we put on path +SET DISTUTILS_USE_SDK=1 +SET MSSdk=1 + +SET "VS_VERSION=16.0" +SET "VS_MAJOR=16" +SET "VS_YEAR=2019" + +set "MSYS2_ARG_CONV_EXCL=/AI;/AL;/OUT;/out" +set "MSYS2_ENV_CONV_EXCL=CL" + +:: For Python 3.5+, ensure that we link with the dynamic runtime. See +:: http://stevedower.id.au/blog/building-for-python-3-5-part-two/ for more info +set "PY_VCRUNTIME_REDIST=%PREFIX%\\bin\\vcruntime140.dll" + +for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -legacy -products * -version [16^,17^) -property installationPath`) do ( + if exist "%%i" if exist "%%i\VC\Auxiliary\Build\vcvarsall.bat" ( + set "VSINSTALLDIR=%%i\" + goto :vswhere + ) +) + +:vswhere + +:: Shorten PATH to avoid the `input line too long` error. +SET MyPath=%PATH% + +setlocal EnableDelayedExpansion + +SET TempPath="%MyPath:;=";"%" +SET var= +FOR %%a IN (%TempPath%) DO ( + IF EXIST %%~sa ( + SET "var=!var!;%%~sa" + ) +) + +set "TempPath=!var:~1!" +endlocal & set "PATH=%TempPath%" + +:: Shorten current directory too +FOR %%A IN (.) DO CD "%%~sA" + +:: other things added by install_activate.bat at package build time diff --git a/packaging/vs2019/conda_build_config.yaml b/packaging/vs2019/conda_build_config.yaml new file mode 100644 index 00000000..358052ec --- /dev/null +++ b/packaging/vs2019/conda_build_config.yaml @@ -0,0 +1,24 @@ +blas_impl: + - mkl # [x86_64] +c_compiler: + - vs2019 # [win] +cxx_compiler: + - vs2019 # [win] +python: + - 3.5 + - 3.6 +# This differs from target_platform in that it determines what subdir the compiler +# will target, not what subdir the compiler package will be itself. +# For example, we need a win-64 vs2008_win-32 package, so that we compile win-32 +# code on win-64 miniconda. +cross_compiler_target_platform: + - win-64 # [win] +target_platform: + - win-64 # [win] +vc: + - 14 +zip_keys: + - # [win] + - vc # [win] + - c_compiler # [win] + - cxx_compiler # [win] diff --git a/packaging/vs2019/install_activate.bat b/packaging/vs2019/install_activate.bat new file mode 100644 index 00000000..70ef1831 --- /dev/null +++ b/packaging/vs2019/install_activate.bat @@ -0,0 +1,30 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set YEAR=2019 +set VER=16 + +mkdir "%PREFIX%\etc\conda\activate.d" +COPY "%RECIPE_DIR%\activate.bat" "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + +IF "%cross_compiler_target_platform%" == "win-64" ( + set "target_platform=amd64" + echo SET "CMAKE_GENERATOR=Visual Studio %VER% %YEAR% Win64" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + IF "%VSDEVCMD_ARGS%" == "" ( + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x64 >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x86_amd64 >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) ELSE ( + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x64 %VSDEVCMD_ARGS% >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvarsall.bat" x86_amd64 %VSDEVCMD_ARGS% >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) + echo popd >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + ) else ( + set "target_platform=x86" + echo SET "CMAKE_GENERATOR=Visual Studio %VER% %YEAR%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo pushd "%%VSINSTALLDIR%%" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo CALL "VC\Auxiliary\Build\vcvars32.bat" >> "%PREFIX%\etc\conda\activate.d\vs%YEAR%_compiler_vars.bat" + echo popd + ) diff --git a/packaging/vs2019/install_runtime.bat b/packaging/vs2019/install_runtime.bat new file mode 100644 index 00000000..21c939dd --- /dev/null +++ b/packaging/vs2019/install_runtime.bat @@ -0,0 +1,50 @@ +:: Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +set VC_PATH=x86 +if "%ARCH%"=="64" ( + set VC_PATH=x64 +) + +set MSC_VER=2019 + +rem :: This should always be present for VC installed with VS. Not sure about VC installed with Visual C++ Build Tools 2015 +rem FOR /F "usebackq tokens=3*" %%A IN (`REG QUERY "HKEY_LOCAL_MACHINE\Software\Microsoft\DevDiv\VC\Servicing\14.0\IDE.x64" /v UpdateVersion`) DO ( +rem set SP=%%A +rem ) + +rem if not "%SP%" == "%PKG_VERSION%" ( +rem echo "Version detected from registry: %SP%" +rem echo "does not match version of package being built (%PKG_VERSION%)" +rem echo "Do you have current updates for VS 2015 installed?" +rem exit 1 +rem ) + + +REM ========== REQUIRES Win 10 SDK be installed, or files otherwise copied to location below! +robocopy "C:\Program Files (x86)\Windows Kits\10\Redist\ucrt\DLLs\%VC_PATH%" "%LIBRARY_BIN%" *.dll /E +robocopy "C:\Program Files (x86)\Windows Kits\10\Redist\ucrt\DLLs\%VC_PATH%" "%PREFIX%" *.dll /E +if %ERRORLEVEL% GEQ 8 exit 1 + +REM ========== This one comes from visual studio 2019 +set "VC_VER=142" + +for /f "usebackq tokens=*" %%i in (`"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -legacy -products * -version [16^,17^) -property installationPath`) do ( + if exist "%%i" if exist "%%i\VC\Auxiliary\Build\vcvarsall.bat" ( + set "VS15VCVARSALL=%%i\VC\Auxiliary\Build\vcvarsall.bat" + goto :eof + ) +) + +@setlocal +call "%VS15VARSALL%" x64 + +set "REDIST_ROOT=%VCToolsRedistDir%%VC_PATH%" + +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.CRT" "%LIBRARY_BIN%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.CRT" "%PREFIX%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.OpenMP" "%LIBRARY_BIN%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +robocopy "%REDIST_ROOT%\Microsoft.VC%VC_VER%.OpenMP" "%PREFIX%" *.dll /E +if %ERRORLEVEL% LSS 8 exit 0 +@endlocal diff --git a/packaging/vs2019/meta.yaml b/packaging/vs2019/meta.yaml new file mode 100644 index 00000000..e3f8b471 --- /dev/null +++ b/packaging/vs2019/meta.yaml @@ -0,0 +1,45 @@ +{% set vcver="14.2" %} +{% set vcfeature="14" %} +{% set vsyear="2019" %} +{% set fullver="15.4.27004.2010" %} + +package: + name: vs{{ vsyear }} + version: {{ fullver }} + +build: + skip: True [not win] + script_env: + - VSDEVCMD_ARGS # [win] + +outputs: + - name: vs{{ vsyear }}_{{ cross_compiler_target_platform }} + script: install_activate.bat + track_features: + # VS 2019 is binary-compatible with VS 2017/vc 14.1 and 2015/vc14. Tools are "v142". + strong: + - vc{{ vcfeature }} + run_exports: + - vc {{ vcver }} + about: + summary: Activation and version verification of MSVC {{ vcver }} (VS {{ vsyear }}) compiler + license: BSD 3-clause + - name: vs{{ vsyear }}_runtime + script: install_runtime.bat + - name: vc + version: {{ vcver }} + track_features: + - vc{{ vcfeature }} + requirements: + run: + - {{ pin_subpackage('vs' ~ vsyear ~ '_runtime') }} + about: + home: https://github.com/conda/conda/wiki/VC-features + license: Modified BSD License (3-clause) + license_family: BSD + summary: A meta-package to track VC features. + description: | + This metapackage is used to activate vc features without + depending on Python. + doc_url: https://github.com/conda/conda/wiki/VC-features + dev_url: https://github.com/conda/conda/wiki/VC-features diff --git a/pytorch3d/__init__.py b/pytorch3d/__init__.py new file mode 100644 index 00000000..be0366e3 --- /dev/null +++ b/pytorch3d/__init__.py @@ -0,0 +1,3 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + +__version__ = "0.1" diff --git a/pytorch3d/csrc/ext.cpp b/pytorch3d/csrc/ext.cpp new file mode 100644 index 00000000..ad71c2cf --- /dev/null +++ b/pytorch3d/csrc/ext.cpp @@ -0,0 +1,27 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include "face_areas_normals/face_areas_normals.h" +#include "gather_scatter/gather_scatter.h" +#include "nearest_neighbor_points/nearest_neighbor_points.h" +#include "packed_to_padded_tensor/packed_to_padded_tensor.h" +#include "rasterize_meshes/rasterize_meshes.h" +#include "rasterize_points/rasterize_points.h" + +PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) { + m.def("face_areas_normals", &face_areas_normals); + m.def("packed_to_padded_tensor", &packed_to_padded_tensor); + m.def("nn_points_idx", &nn_points_idx); + m.def("gather_scatter", &gather_scatter); + m.def("rasterize_points", &RasterizePoints); + m.def("rasterize_points_backward", &RasterizePointsBackward); + m.def("rasterize_meshes_backward", &RasterizeMeshesBackward); + m.def("rasterize_meshes", &RasterizeMeshes); + + // These are only visible for testing; users should not call them directly + m.def("_rasterize_points_coarse", &RasterizePointsCoarse); + m.def("_rasterize_points_naive", &RasterizePointsNaive); + m.def("_rasterize_meshes_naive", &RasterizeMeshesNaive); + m.def("_rasterize_meshes_coarse", &RasterizeMeshesCoarse); + m.def("_rasterize_meshes_fine", &RasterizeMeshesFine); +} diff --git a/pytorch3d/csrc/face_areas_normals/face_areas_normals.cu b/pytorch3d/csrc/face_areas_normals/face_areas_normals.cu new file mode 100644 index 00000000..3b3e4f22 --- /dev/null +++ b/pytorch3d/csrc/face_areas_normals/face_areas_normals.cu @@ -0,0 +1,80 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include + +template +__global__ void face_areas_kernel( + const scalar_t* __restrict__ verts, + const long* __restrict__ faces, + scalar_t* __restrict__ face_areas, + scalar_t* __restrict__ face_normals, + const size_t V, + const size_t F) { + const size_t tid = blockIdx.x * blockDim.x + threadIdx.x; + const size_t stride = gridDim.x * blockDim.x; + + // Faces split evenly over the number of threads in the grid. + // Each thread computes the area & normal of its respective faces and adds it + // to the global face_areas tensor. + for (size_t f = tid; f < F; f += stride) { + const long i0 = faces[3 * f + 0]; + const long i1 = faces[3 * f + 1]; + const long i2 = faces[3 * f + 2]; + + const scalar_t v0_x = verts[3 * i0 + 0]; + const scalar_t v0_y = verts[3 * i0 + 1]; + const scalar_t v0_z = verts[3 * i0 + 2]; + + const scalar_t v1_x = verts[3 * i1 + 0]; + const scalar_t v1_y = verts[3 * i1 + 1]; + const scalar_t v1_z = verts[3 * i1 + 2]; + + const scalar_t v2_x = verts[3 * i2 + 0]; + const scalar_t v2_y = verts[3 * i2 + 1]; + const scalar_t v2_z = verts[3 * i2 + 2]; + + const scalar_t ax = v1_x - v0_x; + const scalar_t ay = v1_y - v0_y; + const scalar_t az = v1_z - v0_z; + + const scalar_t bx = v2_x - v0_x; + const scalar_t by = v2_y - v0_y; + const scalar_t bz = v2_z - v0_z; + + const scalar_t cx = ay * bz - az * by; + const scalar_t cy = az * bx - ax * bz; + const scalar_t cz = ax * by - ay * bx; + + scalar_t norm = sqrt(cx * cx + cy * cy + cz * cz); + face_areas[f] = norm / 2.0; + norm = (norm < 1e-6) ? 1e-6 : norm; // max(norm, 1e-6) + face_normals[3 * f + 0] = cx / norm; + face_normals[3 * f + 1] = cy / norm; + face_normals[3 * f + 2] = cz / norm; + } +} + +std::tuple face_areas_cuda( + at::Tensor verts, + at::Tensor faces) { + const auto V = verts.size(0); + const auto F = faces.size(0); + + at::Tensor areas = at::empty({F}, verts.options()); + at::Tensor normals = at::empty({F, 3}, verts.options()); + + const int blocks = 64; + const int threads = 512; + AT_DISPATCH_FLOATING_TYPES(verts.type(), "face_areas_kernel", ([&] { + face_areas_kernel<<>>( + verts.data_ptr(), + faces.data_ptr(), + areas.data_ptr(), + normals.data_ptr(), + V, + F); + })); + + return std::make_tuple(areas, normals); +} diff --git a/pytorch3d/csrc/face_areas_normals/face_areas_normals.h b/pytorch3d/csrc/face_areas_normals/face_areas_normals.h new file mode 100644 index 00000000..601fc934 --- /dev/null +++ b/pytorch3d/csrc/face_areas_normals/face_areas_normals.h @@ -0,0 +1,36 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include +#include + +// Compute areas of mesh faces using packed representation. +// +// Inputs: +// verts: FloatTensor of shape (V, 3) giving vertex positions. +// faces: LongTensor of shape (F, 3) giving faces. +// +// Returns: +// areas: FloatTensor of shape (F,) where areas[f] is the area of faces[f]. +// normals: FloatTensor of shape (F, 3) where normals[f] is the normal of +// faces[f] +// + +// Cuda implementation. +std::tuple face_areas_cuda( + at::Tensor verts, + at::Tensor faces); + +// Implementation which is exposed. +std::tuple face_areas_normals( + at::Tensor verts, + at::Tensor faces) { + if (verts.type().is_cuda() && faces.type().is_cuda()) { +#ifdef WITH_CUDA + return face_areas_cuda(verts, faces); +#else + AT_ERROR("Not compiled with GPU support."); +#endif + } + AT_ERROR("Not implemented on the CPU."); +} diff --git a/pytorch3d/csrc/gather_scatter/gather_scatter.cu b/pytorch3d/csrc/gather_scatter/gather_scatter.cu new file mode 100644 index 00000000..0b34b86a --- /dev/null +++ b/pytorch3d/csrc/gather_scatter/gather_scatter.cu @@ -0,0 +1,69 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include + +// TODO(T47953967) to make this cuda kernel support all datatypes. +__global__ void gather_scatter_kernel( + const float* __restrict__ input, + const long* __restrict__ edges, + float* __restrict__ output, + bool directed, + bool backward, + const size_t V, + const size_t D, + const size_t E) { + const int tid = threadIdx.x; + + // Reverse the vertex order if backward. + const int v0_idx = backward ? 1 : 0; + const int v1_idx = backward ? 0 : 1; + + // Edges are split evenly across the blocks. + for (int e = blockIdx.x; e < E; e += gridDim.x) { + // Get indices of vertices which form the edge. + const long v0 = edges[2 * e + v0_idx]; + const long v1 = edges[2 * e + v1_idx]; + + // Split vertex features evenly across threads. + // This implementation will be quite wasteful when D<128 since there will be + // a lot of threads doing nothing. + for (int d = tid; d < D; d += blockDim.x) { + const float val = input[v1 * D + d]; + float* address = output + v0 * D + d; + atomicAdd(address, val); + if (!directed) { + const float val = input[v0 * D + d]; + float* address = output + v1 * D + d; + atomicAdd(address, val); + } + } + __syncthreads(); + } +} + +at::Tensor gather_scatter_cuda( + const at::Tensor input, + const at::Tensor edges, + bool directed, + bool backward) { + const auto num_vertices = input.size(0); + const auto input_feature_dim = input.size(1); + const auto num_edges = edges.size(0); + + auto output = at::zeros({num_vertices, input_feature_dim}, input.options()); + const size_t threads = 128; + const size_t max_blocks = 1920; + const size_t blocks = num_edges < max_blocks ? num_edges : max_blocks; + + gather_scatter_kernel<<>>( + input.data_ptr(), + edges.data_ptr(), + output.data_ptr(), + directed, + backward, + num_vertices, + input_feature_dim, + num_edges); + + return output; +} diff --git a/pytorch3d/csrc/gather_scatter/gather_scatter.h b/pytorch3d/csrc/gather_scatter/gather_scatter.h new file mode 100644 index 00000000..6b88e38a --- /dev/null +++ b/pytorch3d/csrc/gather_scatter/gather_scatter.h @@ -0,0 +1,43 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include + +// Fused gather scatter operation for aggregating features of neighbor nodes +// in a graph. This gather scatter operation is specific to graphs as edge +// indices are used as input. +// +// Args: +// input: float32 Tensor of shape (V, D) where V is the number of vertices +// and D is the feature dimension. +// edges: int64 Tensor of shape (E, 2) giving the indices of the vertices that +// make up the edge. E is the number of edges. +// directed: Bool indicating if edges in the graph are directed. For a +// directed graph v0 -> v1 the updated feature for v0 depends on v1. +// backward: Bool indicating if the operation is the backward pass. +// +// Returns: +// output: float32 Tensor of same shape as input. + +// Cuda implementation. +at::Tensor gather_scatter_cuda( + const at::Tensor input, + const at::Tensor edges, + bool directed, + bool backward); + +// Exposed implementation. +at::Tensor gather_scatter( + const at::Tensor input, + const at::Tensor edges, + bool directed, + bool backward) { + if (input.type().is_cuda() && edges.type().is_cuda()) { +#ifdef WITH_CUDA + return gather_scatter_cuda(input, edges, directed, backward); +#else + AT_ERROR("Not compiled with GPU support."); +#endif + } + AT_ERROR("Not implemented on the CPU"); +} diff --git a/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.cu b/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.cu new file mode 100644 index 00000000..07d2bbb3 --- /dev/null +++ b/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.cu @@ -0,0 +1,265 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include + +template +__device__ void warp_reduce( + volatile scalar_t* min_dists, + volatile long* min_idxs, + const size_t tid) { + // s = 32 + if (min_dists[tid] > min_dists[tid + 32]) { + min_idxs[tid] = min_idxs[tid + 32]; + min_dists[tid] = min_dists[tid + 32]; + } + // s = 16 + if (min_dists[tid] > min_dists[tid + 16]) { + min_idxs[tid] = min_idxs[tid + 16]; + min_dists[tid] = min_dists[tid + 16]; + } + // s = 8 + if (min_dists[tid] > min_dists[tid + 8]) { + min_idxs[tid] = min_idxs[tid + 8]; + min_dists[tid] = min_dists[tid + 8]; + } + // s = 4 + if (min_dists[tid] > min_dists[tid + 4]) { + min_idxs[tid] = min_idxs[tid + 4]; + min_dists[tid] = min_dists[tid + 4]; + } + // s = 2 + if (min_dists[tid] > min_dists[tid + 2]) { + min_idxs[tid] = min_idxs[tid + 2]; + min_dists[tid] = min_dists[tid + 2]; + } + // s = 1 + if (min_dists[tid] > min_dists[tid + 1]) { + min_idxs[tid] = min_idxs[tid + 1]; + min_dists[tid] = min_dists[tid + 1]; + } +} + +// CUDA kernel to compute nearest neighbors between two batches of pointclouds +// where each point is of dimension D. +// +// Args: +// points1: First set of points, of shape (N, P1, D). +// points2: Second set of points, of shape (N, P2, D). +// idx: Output memory buffer of shape (N, P1). +// N: Batch size. +// P1: Number of points in points1. +// P2: Number of points in points2. +// D_2: Size of the shared buffer; this is D rounded up so that memory access +// is aligned. +// +template +__global__ void nearest_neighbor_kernel( + const scalar_t* __restrict__ points1, + const scalar_t* __restrict__ points2, + long* __restrict__ idx, + const size_t N, + const size_t P1, + const size_t P2, + const size_t D, + const size_t D_2) { + // Each block will compute one element of the output idx[n, i]. Within the + // block we will use threads to compute the distances between points1[n, i] + // and points2[n, j] for all 0 <= j < P2, then use a block reduction to + // take an argmin of the distances. + + // Shared buffers for the threads in the block. CUDA only allows declaration + // of a single shared buffer, so it needs to be manually sliced and cast to + // build several logical shared buffers of different types. + extern __shared__ char shared_buf[]; + scalar_t* x = (scalar_t*)shared_buf; // scalar_t[DD] + scalar_t* min_dists = &x[D_2]; // scalar_t[NUM_THREADS] + long* min_idxs = (long*)&min_dists[blockDim.x]; // long[NUM_THREADS] + + const size_t n = blockIdx.y; // index of batch element. + const size_t i = blockIdx.x; // index of point within batch element. + const size_t tid = threadIdx.x; + + // Thread 0 copies points1[n, i, :] into x. + if (tid == 0) { + for (size_t d = 0; d < D; d++) { + x[d] = points1[n * (P1 * D) + i * D + d]; + } + } + __syncthreads(); + + // Compute the distances between points1[n, i] and points2[n, j] for + // all 0 <= j < P2. Here each thread will reduce over P2 / blockDim.x + // in serial, and store its result to shared memory + scalar_t min_dist = FLT_MAX; + size_t min_idx = 0; + for (size_t j = tid; j < P2; j += blockDim.x) { + scalar_t dist = 0; + for (size_t d = 0; d < D; d++) { + scalar_t x_d = x[d]; + scalar_t y_d = points2[n * (P2 * D) + j * D + d]; + scalar_t diff = x_d - y_d; + dist += diff * diff; + } + min_dist = (j == tid) ? dist : min_dist; + min_idx = (dist <= min_dist) ? j : min_idx; + min_dist = (dist <= min_dist) ? dist : min_dist; + } + min_dists[tid] = min_dist; + min_idxs[tid] = min_idx; + __syncthreads(); + + // Perform reduction in shared memory. + for (int s = blockDim.x / 2; s > 32; s >>= 1) { + if (tid < s) { + if (min_dists[tid] > min_dists[tid + s]) { + min_dists[tid] = min_dists[tid + s]; + min_idxs[tid] = min_idxs[tid + s]; + } + } + __syncthreads(); + } + + // Unroll the last 6 iterations of the loop since they will happen + // synchronized within a single warp. + if (tid < 32) + warp_reduce(min_dists, min_idxs, tid); + + // Finally thread 0 writes the result to the output buffer. + if (tid == 0) { + idx[n * P1 + i] = min_idxs[0]; + } +} + +// CUDA kernel to compute nearest neighbors between two sets of 3-dimensional +// pointclouds. This is a specialization of the nearest_neighbor_kernel +// to the case D=3. +// +// Args: +// points1: First set of pointclouds, of shape (N, P1, 3). +// points2: Second set of pointclouds, of shape (N, P2, 3). +// idx: Output memory buffer of shape (N, P1). +// N: Batch size. +// P1: Number of points in points1. +// P2: Number of points in points2. +// +template +__global__ void nearest_neighbor_kernel_D3( + const scalar_t* __restrict__ points1, + const scalar_t* __restrict__ points2, + long* __restrict__ idx, + const size_t N, + const size_t P1, + const size_t P2) { + // Single shared memory buffer which is split and cast to different types. + extern __shared__ char shared_buf[]; + scalar_t* min_dists = (scalar_t*)shared_buf; // scalar_t[NUM_THREADS] + long* min_idxs = (long*)&min_dists[blockDim.x]; // long[NUM_THREADS] + + const size_t D = 3; + const size_t n = blockIdx.y; // index of batch element. + const size_t i = blockIdx.x; // index of point within batch element. + const size_t tid = threadIdx.x; + + // Retrieve the coordinates of points1[n, i] from global memory; these + // will be stored in registers for fast access. + const scalar_t x = points1[n * (P1 * D) + i * D + 0]; + const scalar_t y = points1[n * (P1 * D) + i * D + 1]; + const scalar_t z = points1[n * (P1 * D) + i * D + 2]; + + // Compute distances between points1[n, i] and all points2[n, j] + // for 0 <= j < P2 + scalar_t min_dist = FLT_MAX; + size_t min_idx = 0; + + // Distance computation for points in p2 spread across threads in the block. + for (size_t j = tid; j < P2; j += blockDim.x) { + scalar_t dx = x - points2[n * (P2 * D) + j * D + 0]; + scalar_t dy = y - points2[n * (P2 * D) + j * D + 1]; + scalar_t dz = z - points2[n * (P2 * D) + j * D + 2]; + scalar_t dist = dx * dx + dy * dy + dz * dz; + min_dist = (j == tid) ? dist : min_dist; + min_idx = (dist <= min_dist) ? j : min_idx; + min_dist = (dist <= min_dist) ? dist : min_dist; + } + min_dists[tid] = min_dist; + min_idxs[tid] = min_idx; + + // Synchronize local threads writing to the shared memory buffer. + __syncthreads(); + + // Perform reduction in shared memory. + for (int s = blockDim.x / 2; s > 32; s >>= 1) { + if (tid < s) { + if (min_dists[tid] > min_dists[tid + s]) { + min_dists[tid] = min_dists[tid + s]; + min_idxs[tid] = min_idxs[tid + s]; + } + } + + // Synchronize local threads so that min_dists is correct. + __syncthreads(); + } + + // Unroll the last 6 iterations of the loop since they will happen + // synchronized within a single warp. + if (tid < 32) + warp_reduce(min_dists, min_idxs, tid); + + // Finally thread 0 writes the result to the output buffer. + if (tid == 0) { + idx[n * P1 + i] = min_idxs[0]; + } +} + +at::Tensor nn_points_idx_cuda(at::Tensor p1, at::Tensor p2) { + const auto N = p1.size(0); + const auto P1 = p1.size(1); + const auto P2 = p2.size(1); + const auto D = p1.size(2); + + AT_ASSERTM(p2.size(2) == D, "Point sets must have same last dimension."); + auto idx = at::empty({N, P1}, p1.options().dtype(at::kLong)); + + // On P100 with pointclouds of size (16, 5000, 3), 128 threads per block + // gives best results. + const int threads = 128; + const dim3 blocks(P1, N); + + if (D == 3) { + // Use the specialized kernel for D=3. + AT_DISPATCH_FLOATING_TYPES(p1.type(), "nearest_neighbor_v3_cuda", ([&] { + size_t shared_size = threads * sizeof(size_t) + + threads * sizeof(long); + nearest_neighbor_kernel_D3 + <<>>( + p1.data_ptr(), + p2.data_ptr(), + idx.data_ptr(), + N, + P1, + P2); + })); + } else { + // Use the general kernel for all other D. + AT_DISPATCH_FLOATING_TYPES( + p1.type(), "nearest_neighbor_v3_cuda", ([&] { + // To avoid misaligned memory access, the size of shared buffers + // need to be rounded to the next even size. + size_t D_2 = D + (D % 2); + size_t shared_size = (D_2 + threads) * sizeof(size_t); + shared_size += threads * sizeof(long); + nearest_neighbor_kernel<<>>( + p1.data_ptr(), + p2.data_ptr(), + idx.data_ptr(), + N, + P1, + P2, + D, + D_2); + })); + } + + return idx; +} diff --git a/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.h b/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.h new file mode 100644 index 00000000..7d87f1b4 --- /dev/null +++ b/pytorch3d/csrc/nearest_neighbor_points/nearest_neighbor_points.h @@ -0,0 +1,37 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include +#include "pytorch3d_cutils.h" + +// Compute indices of nearest neighbors in pointcloud p2 to points +// in pointcloud p1. +// +// Args: +// p1: FloatTensor of shape (N, P1, D) giving a batch of pointclouds each +// containing P1 points of dimension D. +// p2: FloatTensor of shape (N, P2, D) giving a batch of pointclouds each +// containing P2 points of dimension D. +// +// Returns: +// p1_neighbor_idx: LongTensor of shape (N, P1), where +// p1_neighbor_idx[n, i] = j means that the nearest neighbor +// to p1[n, i] in the cloud p2[n] is p2[n, j]. +// + +// Cuda implementation. +at::Tensor nn_points_idx_cuda(at::Tensor p1, at::Tensor p2); + +// Implementation which is exposed. +at::Tensor nn_points_idx(at::Tensor p1, at::Tensor p2) { + if (p1.type().is_cuda() && p2.type().is_cuda()) { +#ifdef WITH_CUDA + CHECK_CONTIGUOUS_CUDA(p1); + CHECK_CONTIGUOUS_CUDA(p2); + return nn_points_idx_cuda(p1, p2); +#else + AT_ERROR("Not compiled with GPU support."); +#endif + } + AT_ERROR("Not implemented on the CPU."); +}; diff --git a/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.cu b/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.cu new file mode 100644 index 00000000..b3fb5f70 --- /dev/null +++ b/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.cu @@ -0,0 +1,52 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include + +template +__global__ void packed_to_padded_tensor_kernel( + const scalar_t* __restrict__ inputs, + const long* __restrict__ first_idxs, + scalar_t* __restrict__ inputs_padded, + const size_t batch_size, + const size_t max_size, + const size_t num_inputs) { + // Batch elements split evenly across blocks (num blocks = batch_size) and + // values for each element split across threads in the block. Each thread adds + // the values of its respective input elements to the global inputs_padded + // tensor. + const size_t tid = threadIdx.x; + const size_t batch_idx = blockIdx.x; + + const long start = first_idxs[batch_idx]; + const long end = + batch_idx + 1 < batch_size ? first_idxs[batch_idx + 1] : num_inputs; + const int num_faces = end - start; + for (size_t f = tid; f < num_faces; f += blockDim.x) { + inputs_padded[batch_idx * max_size + f] = inputs[start + f]; + } +} + +at::Tensor packed_to_padded_tensor_cuda( + at::Tensor inputs, + at::Tensor first_idxs, + const long max_size) { + const auto num_inputs = inputs.size(0); + const auto batch_size = first_idxs.size(0); + at::Tensor inputs_padded = + at::zeros({batch_size, max_size}, inputs.options()); + + const int threads = 512; + const int blocks = batch_size; + AT_DISPATCH_FLOATING_TYPES( + inputs.type(), "packed_to_padded_tensor_kernel", ([&] { + packed_to_padded_tensor_kernel<<>>( + inputs.data_ptr(), + first_idxs.data_ptr(), + inputs_padded.data_ptr(), + batch_size, + max_size, + num_inputs); + })); + + return inputs_padded; +} diff --git a/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.h b/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.h new file mode 100644 index 00000000..1edbfe30 --- /dev/null +++ b/pytorch3d/csrc/packed_to_padded_tensor/packed_to_padded_tensor.h @@ -0,0 +1,44 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include + +// Converts a packed tensor into a padded tensor, restoring the batch dimension. +// Refer to pytorch3d/structures/meshes.py for details on packed/padded tensors. +// +// Inputs: +// inputs: FloatTensor of shape (F,), representing the packed batch tensor. +// e.g. areas for faces in a batch of meshes. +// first_idxs: LongTensor of shape (N,) where N is the number of +// elements in the batch and `packed_first_idxs[i] = f` +// means that the inputs for batch element i begin at +// `inputs[f]`. +// max_size: Max length of an element in the batch. +// Returns: +// inputs_padded: FloatTensor of shape (N, max_size) where max_size is max +// of `sizes`. The values for batch element i which start at +// `inputs[packed_first_idxs[i]]` will be copied to +// `inputs_padded[i, :]``, with zeros padding out the extra +// inputs. +// + +// Cuda implementation. +at::Tensor packed_to_padded_tensor_cuda( + at::Tensor inputs, + at::Tensor first_idxs, + const long max_size); + +// Implementation which is exposed. +at::Tensor packed_to_padded_tensor( + at::Tensor inputs, + at::Tensor first_idxs, + const long max_size) { + if (inputs.type().is_cuda()) { +#ifdef WITH_CUDA + return packed_to_padded_tensor_cuda(inputs, first_idxs, max_size); +#else + AT_ERROR("Not compiled with GPU support."); +#endif + } + AT_ERROR("Not implemented on the CPU."); +} diff --git a/pytorch3d/csrc/pytorch3d_cutils.h b/pytorch3d/csrc/pytorch3d_cutils.h new file mode 100644 index 00000000..585de032 --- /dev/null +++ b/pytorch3d/csrc/pytorch3d_cutils.h @@ -0,0 +1,12 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include + +#define CHECK_CUDA(x) \ + AT_ASSERTM(x.type().is_cuda(), #x "must be a CUDA tensor.") +#define CHECK_CONTIGUOUS(x) \ + AT_ASSERTM(x.is_contiguous(), #x "must be contiguous.") +#define CHECK_CONTIGUOUS_CUDA(x) \ + CHECK_CUDA(x); \ + CHECK_CONTIGUOUS(x) diff --git a/pytorch3d/csrc/rasterize_meshes/float_math.cuh b/pytorch3d/csrc/rasterize_meshes/float_math.cuh new file mode 100644 index 00000000..4380da0e --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/float_math.cuh @@ -0,0 +1,86 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include + +// Common functions and operators for float2. + +__device__ inline float2 operator-(const float2& a, const float2& b) { + return make_float2(a.x - b.x, a.y - b.y); +} + +__device__ inline float2 operator+(const float2& a, const float2& b) { + return make_float2(a.x + b.x, a.y + b.y); +} + +__device__ inline float2 operator/(const float2& a, const float2& b) { + return make_float2(a.x / b.x, a.y / b.y); +} + +__device__ inline float2 operator/(const float2& a, const float b) { + return make_float2(a.x / b, a.y / b); +} + +__device__ inline float2 operator*(const float2& a, const float2& b) { + return make_float2(a.x * b.x, a.y * b.y); +} + +__device__ inline float2 operator*(const float a, const float2& b) { + return make_float2(a * b.x, a * b.y); +} + +__device__ inline float dot(const float2& a, const float2& b) { + return a.x * b.x + a.y * b.y; +} + +// Backward pass for the dot product. +// Args: +// a, b: Coordinates of two points. +// grad_dot: Upstream gradient for the output. +// +// Returns: +// tuple of gradients for each of the input points: +// (float2 grad_a, float2 grad_b) +// +__device__ inline thrust::tuple +DotBackward(const float2& a, const float2& b, const float& grad_dot) { + return thrust::make_tuple(grad_dot * b, grad_dot * a); +} + +__device__ inline float sum(const float2& a) { + return a.x + a.y; +} + +// Common functions and operators for float3. + +__device__ inline float3 operator-(const float3& a, const float3& b) { + return make_float3(a.x - b.x, a.y - b.y, a.z - b.z); +} + +__device__ inline float3 operator+(const float3& a, const float3& b) { + return make_float3(a.x + b.x, a.y + b.y, a.z + b.z); +} + +__device__ inline float3 operator/(const float3& a, const float3& b) { + return make_float3(a.x / b.x, a.y / b.y, a.z / b.z); +} + +__device__ inline float3 operator/(const float3& a, const float b) { + return make_float3(a.x / b, a.y / b, a.z / b); +} + +__device__ inline float3 operator*(const float3& a, const float3& b) { + return make_float3(a.x * b.x, a.y * b.y, a.z * b.z); +} + +__device__ inline float3 operator*(const float a, const float3& b) { + return make_float3(a * b.x, a * b.y, a * b.z); +} + +__device__ inline float dot(const float3& a, const float3& b) { + return a.x * b.x + a.y * b.y + a.z * b.z; +} + +__device__ inline float sum(const float3& a) { + return a.x + a.y + a.z; +} diff --git a/pytorch3d/csrc/rasterize_meshes/geometry_utils.cuh b/pytorch3d/csrc/rasterize_meshes/geometry_utils.cuh new file mode 100644 index 00000000..ddb33349 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/geometry_utils.cuh @@ -0,0 +1,350 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include +#include +#include "float_math.cuh" + +// Set epsilon for preventing floating point errors and division by 0. +const auto kEpsilon = 1e-30; + +// Determines whether a point p is on the right side of a 2D line segment +// given by the end points v0, v1. +// +// Args: +// p: vec2 Coordinates of a point. +// v0, v1: vec2 Coordinates of the end points of the edge. +// +// Returns: +// area: The signed area of the parallelogram given by the vectors +// A = p - v0 +// B = v1 - v0 +// +__device__ inline float +EdgeFunctionForward(const float2& p, const float2& v0, const float2& v1) { + return (p.x - v0.x) * (v1.y - v0.y) - (p.y - v0.y) * (v1.x - v0.x); +} + +// Backward pass for the edge function returning partial dervivatives for each +// of the input points. +// +// Args: +// p: vec2 Coordinates of a point. +// v0, v1: vec2 Coordinates of the end points of the edge. +// grad_edge: Upstream gradient for output from edge function. +// +// Returns: +// tuple of gradients for each of the input points: +// (float2 d_edge_dp, float2 d_edge_dv0, float2 d_edge_dv1) +// +__device__ inline thrust::tuple EdgeFunctionBackward( + const float2& p, + const float2& v0, + const float2& v1, + const float& grad_edge) { + const float2 dedge_dp = make_float2(v1.y - v0.y, v0.x - v1.x); + const float2 dedge_dv0 = make_float2(p.y - v1.y, v1.x - p.x); + const float2 dedge_dv1 = make_float2(v0.y - p.y, p.x - v0.x); + return thrust::make_tuple( + grad_edge * dedge_dp, grad_edge * dedge_dv0, grad_edge * dedge_dv1); +} + +// The forward pass for computing the barycentric coordinates of a point +// relative to a triangle. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the triangle vertices. +// +// Returns +// bary: (w0, w1, w2) barycentric coordinates in the range [0, 1]. +// +__device__ inline float3 BarycentricCoordsForward( + const float2& p, + const float2& v0, + const float2& v1, + const float2& v2) { + const float area = EdgeFunctionForward(v2, v0, v1) + kEpsilon; + const float w0 = EdgeFunctionForward(p, v1, v2) / area; + const float w1 = EdgeFunctionForward(p, v2, v0) / area; + const float w2 = EdgeFunctionForward(p, v0, v1) / area; + return make_float3(w0, w1, w2); +} + +// The backward pass for computing the barycentric coordinates of a point +// relative to a triangle. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: (x, y) coordinates of the triangle vertices. +// grad_bary_upstream: vec3 Upstream gradient for each of the +// barycentric coordaintes [grad_w0, grad_w1, grad_w2]. +// +// Returns +// tuple of gradients for each of the triangle vertices: +// (float2 grad_v0, float2 grad_v1, float2 grad_v2) +// +__device__ inline thrust::tuple +BarycentricCoordsBackward( + const float2& p, + const float2& v0, + const float2& v1, + const float2& v2, + const float3& grad_bary_upstream) { + const float area = EdgeFunctionForward(v2, v0, v1) + kEpsilon; + const float area2 = pow(area, 2.0); + const float e0 = EdgeFunctionForward(p, v1, v2); + const float e1 = EdgeFunctionForward(p, v2, v0); + const float e2 = EdgeFunctionForward(p, v0, v1); + + const float grad_w0 = grad_bary_upstream.x; + const float grad_w1 = grad_bary_upstream.y; + const float grad_w2 = grad_bary_upstream.z; + + // Calculate component of the gradient from each of w0, w1 and w2. + // e.g. for w0: + // dloss/dw0_v = dl/dw0 * dw0/dw0_top * dw0_top/dv + // + dl/dw0 * dw0/dw0_bot * dw0_bot/dv + const float dw0_darea = -e0 / (area2); + const float dw0_e0 = 1 / area; + const float dloss_d_w0area = grad_w0 * dw0_darea; + const float dloss_e0 = grad_w0 * dw0_e0; + auto de0_dv = EdgeFunctionBackward(p, v1, v2, dloss_e0); + auto dw0area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w0area); + const float2 dw0_p = thrust::get<0>(de0_dv); + const float2 dw0_dv0 = thrust::get<1>(dw0area_dv); + const float2 dw0_dv1 = thrust::get<1>(de0_dv) + thrust::get<2>(dw0area_dv); + const float2 dw0_dv2 = thrust::get<2>(de0_dv) + thrust::get<0>(dw0area_dv); + + const float dw1_darea = -e1 / (area2); + const float dw1_e1 = 1 / area; + const float dloss_d_w1area = grad_w1 * dw1_darea; + const float dloss_e1 = grad_w1 * dw1_e1; + auto de1_dv = EdgeFunctionBackward(p, v2, v0, dloss_e1); + auto dw1area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w1area); + const float2 dw1_p = thrust::get<0>(de1_dv); + const float2 dw1_dv0 = thrust::get<2>(de1_dv) + thrust::get<1>(dw1area_dv); + const float2 dw1_dv1 = thrust::get<2>(dw1area_dv); + const float2 dw1_dv2 = thrust::get<1>(de1_dv) + thrust::get<0>(dw1area_dv); + + const float dw2_darea = -e2 / (area2); + const float dw2_e2 = 1 / area; + const float dloss_d_w2area = grad_w2 * dw2_darea; + const float dloss_e2 = grad_w2 * dw2_e2; + auto de2_dv = EdgeFunctionBackward(p, v0, v1, dloss_e2); + auto dw2area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w2area); + const float2 dw2_p = thrust::get<0>(de2_dv); + const float2 dw2_dv0 = thrust::get<1>(de2_dv) + thrust::get<1>(dw2area_dv); + const float2 dw2_dv1 = thrust::get<2>(de2_dv) + thrust::get<2>(dw2area_dv); + const float2 dw2_dv2 = thrust::get<0>(dw2area_dv); + + const float2 dbary_p = dw0_p + dw1_p + dw2_p; + const float2 dbary_dv0 = dw0_dv0 + dw1_dv0 + dw2_dv0; + const float2 dbary_dv1 = dw0_dv1 + dw1_dv1 + dw2_dv1; + const float2 dbary_dv2 = dw0_dv2 + dw1_dv2 + dw2_dv2; + + return thrust::make_tuple(dbary_p, dbary_dv0, dbary_dv1, dbary_dv2); +} + +// Forward pass for applying perspective correction to barycentric coordinates. +// +// Args: +// bary: Screen-space barycentric coordinates for a point +// z0, z1, z2: Camera-space z-coordinates of the triangle vertices +// +// Returns +// World-space barycentric coordinates +// +__device__ inline float3 BarycentricPerspectiveCorrectionForward( + const float3& bary, + const float z0, + const float z1, + const float z2) { + const float w0_top = bary.x * z1 * z2; + const float w1_top = z0 * bary.y * z2; + const float w2_top = z0 * z1 * bary.z; + const float denom = w0_top + w1_top + w2_top; + const float w0 = w0_top / denom; + const float w1 = w1_top / denom; + const float w2 = w2_top / denom; + return make_float3(w0, w1, w2); +} + +// Backward pass for applying perspective correction to barycentric coordinates. +// +// Args: +// bary: Screen-space barycentric coordinates for a point +// z0, z1, z2: Camera-space z-coordinates of the triangle vertices +// grad_out: Upstream gradient of the loss with respect to the corrected +// barycentric coordinates. +// +// Returns a tuple of: +// grad_bary: Downstream gradient of the loss with respect to the the +// uncorrected barycentric coordinates. +// grad_z0, grad_z1, grad_z2: Downstream gradient of the loss with respect +// to the z-coordinates of the triangle verts +__device__ inline thrust::tuple +BarycentricPerspectiveCorrectionBackward( + const float3& bary, + const float z0, + const float z1, + const float z2, + const float3& grad_out) { + // Recompute forward pass + const float w0_top = bary.x * z1 * z2; + const float w1_top = z0 * bary.y * z2; + const float w2_top = z0 * z1 * bary.z; + const float denom = w0_top + w1_top + w2_top; + + // Now do backward pass + const float grad_denom_top = + -w0_top * grad_out.x - w1_top * grad_out.y - w2_top * grad_out.z; + const float grad_denom = grad_denom_top / (denom * denom); + const float grad_w0_top = grad_denom + grad_out.x / denom; + const float grad_w1_top = grad_denom + grad_out.y / denom; + const float grad_w2_top = grad_denom + grad_out.z / denom; + const float grad_bary_x = grad_w0_top * z1 * z2; + const float grad_bary_y = grad_w1_top * z0 * z2; + const float grad_bary_z = grad_w2_top * z0 * z1; + const float3 grad_bary = make_float3(grad_bary_x, grad_bary_y, grad_bary_z); + const float grad_z0 = grad_w1_top * bary.y * z2 + grad_w2_top * bary.z * z1; + const float grad_z1 = grad_w0_top * bary.x * z2 + grad_w2_top * bary.z * z0; + const float grad_z2 = grad_w0_top * bary.x * z1 + grad_w1_top * bary.y * z0; + return thrust::make_tuple(grad_bary, grad_z0, grad_z1, grad_z2); +} + +// Return minimum distance between line segment (v1 - v0) and point p. +// +// Args: +// p: Coordinates of a point. +// v0, v1: Coordinates of the end points of the line segment. +// +// Returns: +// non-square distance to the boundary of the triangle. +// +__device__ inline float +PointLineDistanceForward(const float2& p, const float2& a, const float2& b) { + const float2 ba = b - a; + float l2 = dot(ba, ba); + float t = dot(ba, p - a) / l2; + if (l2 <= kEpsilon) { + return dot(p - b, p - b); + } + t = __saturatef(t); // clamp to the interval [+0.0, 1.0] + const float2 p_proj = a + t * ba; + const float2 d = (p_proj - p); + return dot(d, d); // squared distance +} + +// Backward pass for point to line distance in 2D. +// +// Args: +// p: Coordinates of a point. +// v0, v1: Coordinates of the end points of the line segment. +// grad_dist: Upstream gradient for the distance. +// +// Returns: +// tuple of gradients for each of the input points: +// (float2 grad_p, float2 grad_v0, float2 grad_v1) +// +__device__ inline thrust::tuple +PointLineDistanceBackward( + const float2& p, + const float2& v0, + const float2& v1, + const float& grad_dist) { + // Redo some of the forward pass calculations. + const float2 v1v0 = v1 - v0; + const float2 pv0 = p - v0; + const float t_bot = dot(v1v0, v1v0); + const float t_top = dot(v1v0, pv0); + float tt = t_top / t_bot; + tt = __saturatef(tt); + const float2 p_proj = (1.0f - tt) * v0 + tt * v1; + const float2 d = p - p_proj; + const float dist = sqrt(dot(d, d)); + + const float2 grad_p = -1.0f * grad_dist * 2.0f * (p_proj - p); + const float2 grad_v0 = grad_dist * (1.0f - tt) * 2.0f * (p_proj - p); + const float2 grad_v1 = grad_dist * tt * 2.0f * (p_proj - p); + + return thrust::make_tuple(grad_p, grad_v0, grad_v1); +} + +// The forward pass for calculating the shortest distance between a point +// and a triangle. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the three triangle vertices. +// +// Returns: +// shortest absolute distance from a point to a triangle. +// +__device__ inline float PointTriangleDistanceForward( + const float2& p, + const float2& v0, + const float2& v1, + const float2& v2) { + // Compute distance to all 3 edges of the triangle and return the min. + const float e01_dist = PointLineDistanceForward(p, v0, v1); + const float e02_dist = PointLineDistanceForward(p, v0, v2); + const float e12_dist = PointLineDistanceForward(p, v1, v2); + const float edge_dist = fminf(fminf(e01_dist, e02_dist), e12_dist); + return edge_dist; +} + +// Backward pass for point triangle distance. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the three triangle vertices. +// grad_dist: Upstream gradient for the distance. +// +// Returns: +// tuple of gradients for each of the triangle vertices: +// (float2 grad_v0, float2 grad_v1, float2 grad_v2) +// +__device__ inline thrust::tuple +PointTriangleDistanceBackward( + const float2& p, + const float2& v0, + const float2& v1, + const float2& v2, + const float& grad_dist) { + // Compute distance to all 3 edges of the triangle. + const float e01_dist = PointLineDistanceForward(p, v0, v1); + const float e02_dist = PointLineDistanceForward(p, v0, v2); + const float e12_dist = PointLineDistanceForward(p, v1, v2); + + // Initialize output tensors. + float2 grad_v0 = make_float2(0.0f, 0.0f); + float2 grad_v1 = make_float2(0.0f, 0.0f); + float2 grad_v2 = make_float2(0.0f, 0.0f); + float2 grad_p = make_float2(0.0f, 0.0f); + + // Find which edge is the closest and return PointLineDistanceBackward for + // that edge. + if (e01_dist <= e02_dist && e01_dist <= e12_dist) { + // Closest edge is v1 - v0. + auto grad_e01 = PointLineDistanceBackward(p, v0, v1, grad_dist); + grad_p = thrust::get<0>(grad_e01); + grad_v0 = thrust::get<1>(grad_e01); + grad_v1 = thrust::get<2>(grad_e01); + } else if (e02_dist <= e01_dist && e02_dist <= e12_dist) { + // Closest edge is v2 - v0. + auto grad_e02 = PointLineDistanceBackward(p, v0, v2, grad_dist); + grad_p = thrust::get<0>(grad_e02); + grad_v0 = thrust::get<1>(grad_e02); + grad_v2 = thrust::get<2>(grad_e02); + } else if (e12_dist <= e01_dist && e12_dist <= e02_dist) { + // Closest edge is v2 - v1. + auto grad_e12 = PointLineDistanceBackward(p, v1, v2, grad_dist); + grad_p = thrust::get<0>(grad_e12); + grad_v1 = thrust::get<1>(grad_e12); + grad_v2 = thrust::get<2>(grad_e12); + } + + return thrust::make_tuple(grad_p, grad_v0, grad_v1, grad_v2); +} diff --git a/pytorch3d/csrc/rasterize_meshes/geometry_utils.h b/pytorch3d/csrc/rasterize_meshes/geometry_utils.h new file mode 100644 index 00000000..c64b7dc4 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/geometry_utils.h @@ -0,0 +1,397 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include +#include "vec2.h" +#include "vec3.h" + +// Set epsilon for preventing floating point errors and division by 0. +const auto kEpsilon = 1e-30; + +// Determines whether a point p is on the right side of a 2D line segment +// given by the end points v0, v1. +// +// Args: +// p: vec2 Coordinates of a point. +// v0, v1: vec2 Coordinates of the end points of the edge. +// +// Returns: +// area: The signed area of the parallelogram given by the vectors +// A = p - v0 +// B = v1 - v0 +// +// v1 ________ +// /\ / +// A / \ / +// / \ / +// v0 /______\/ +// B p +// +// The area can also be interpreted as the cross product A x B. +// If the sign of the area is positive, the point p is on the +// right side of the edge. Negative area indicates the point is on +// the left side of the edge. i.e. for an edge v1 - v0: +// +// v1 +// / +// / +// - / + +// / +// / +// v0 +// +template +T EdgeFunctionForward(const vec2& p, const vec2& v0, const vec2& v1) { + const T edge = (p.x - v0.x) * (v1.y - v0.y) - (p.y - v0.y) * (v1.x - v0.x); + return edge; +} + +// Backward pass for the edge function returning partial dervivatives for each +// of the input points. +// +// Args: +// p: vec2 Coordinates of a point. +// v0, v1: vec2 Coordinates of the end points of the edge. +// grad_edge: Upstream gradient for output from edge function. +// +// Returns: +// tuple of gradients for each of the input points: +// (vec2 d_edge_dp, vec2 d_edge_dv0, vec2 d_edge_dv1) +// +template +inline std::tuple, vec2, vec2> EdgeFunctionBackward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const T grad_edge) { + const vec2 dedge_dp(v1.y - v0.y, v0.x - v1.x); + const vec2 dedge_dv0(p.y - v1.y, v1.x - p.x); + const vec2 dedge_dv1(v0.y - p.y, p.x - v0.x); + return std::make_tuple( + grad_edge * dedge_dp, grad_edge * dedge_dv0, grad_edge * dedge_dv1); +} + +// The forward pass for computing the barycentric coordinates of a point +// relative to a triangle. +// Ref: +// https://www.scratchapixel.com/lessons/3d-basic-rendering/ray-tracing-rendering-a-triangle/barycentric-coordinates +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the triangle vertices. +// +// Returns +// bary: (w0, w1, w2) barycentric coordinates in the range [0, 1]. +// +template +vec3 BarycentricCoordinatesForward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const vec2& v2) { + const T area = EdgeFunctionForward(v2, v0, v1) + kEpsilon; + const T w0 = EdgeFunctionForward(p, v1, v2) / area; + const T w1 = EdgeFunctionForward(p, v2, v0) / area; + const T w2 = EdgeFunctionForward(p, v0, v1) / area; + return vec3(w0, w1, w2); +} + +// The backward pass for computing the barycentric coordinates of a point +// relative to a triangle. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: (x, y) coordinates of the triangle vertices. +// grad_bary_upstream: vec3 Upstream gradient for each of the +// barycentric coordaintes [grad_w0, grad_w1, grad_w2]. +// +// Returns +// tuple of gradients for each of the triangle vertices: +// (vec2 grad_v0, vec2 grad_v1, vec2 grad_v2) +// +template +inline std::tuple, vec2, vec2, vec2> BarycentricCoordsBackward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const vec2& v2, + const vec3& grad_bary_upstream) { + const T area = EdgeFunctionForward(v2, v0, v1) + kEpsilon; + const T area2 = pow(area, 2.0f); + const T area_inv = 1.0f / area; + const T e0 = EdgeFunctionForward(p, v1, v2); + const T e1 = EdgeFunctionForward(p, v2, v0); + const T e2 = EdgeFunctionForward(p, v0, v1); + + const T grad_w0 = grad_bary_upstream.x; + const T grad_w1 = grad_bary_upstream.y; + const T grad_w2 = grad_bary_upstream.z; + + // Calculate component of the gradient from each of w0, w1 and w2. + // e.g. for w0: + // dloss/dw0_v = dl/dw0 * dw0/dw0_top * dw0_top/dv + // + dl/dw0 * dw0/dw0_bot * dw0_bot/dv + const T dw0_darea = -e0 / (area2); + const T dw0_e0 = area_inv; + const T dloss_d_w0area = grad_w0 * dw0_darea; + const T dloss_e0 = grad_w0 * dw0_e0; + auto de0_dv = EdgeFunctionBackward(p, v1, v2, dloss_e0); + auto dw0area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w0area); + const vec2 dw0_p = std::get<0>(de0_dv); + const vec2 dw0_dv0 = std::get<1>(dw0area_dv); + const vec2 dw0_dv1 = std::get<1>(de0_dv) + std::get<2>(dw0area_dv); + const vec2 dw0_dv2 = std::get<2>(de0_dv) + std::get<0>(dw0area_dv); + + const T dw1_darea = -e1 / (area2); + const T dw1_e1 = area_inv; + const T dloss_d_w1area = grad_w1 * dw1_darea; + const T dloss_e1 = grad_w1 * dw1_e1; + auto de1_dv = EdgeFunctionBackward(p, v2, v0, dloss_e1); + auto dw1area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w1area); + const vec2 dw1_p = std::get<0>(de1_dv); + const vec2 dw1_dv0 = std::get<2>(de1_dv) + std::get<1>(dw1area_dv); + const vec2 dw1_dv1 = std::get<2>(dw1area_dv); + const vec2 dw1_dv2 = std::get<1>(de1_dv) + std::get<0>(dw1area_dv); + + const T dw2_darea = -e2 / (area2); + const T dw2_e2 = area_inv; + const T dloss_d_w2area = grad_w2 * dw2_darea; + const T dloss_e2 = grad_w2 * dw2_e2; + auto de2_dv = EdgeFunctionBackward(p, v0, v1, dloss_e2); + auto dw2area_dv = EdgeFunctionBackward(v2, v0, v1, dloss_d_w2area); + const vec2 dw2_p = std::get<0>(de2_dv); + const vec2 dw2_dv0 = std::get<1>(de2_dv) + std::get<1>(dw2area_dv); + const vec2 dw2_dv1 = std::get<2>(de2_dv) + std::get<2>(dw2area_dv); + const vec2 dw2_dv2 = std::get<0>(dw2area_dv); + + const vec2 dbary_p = dw0_p + dw1_p + dw2_p; + const vec2 dbary_dv0 = dw0_dv0 + dw1_dv0 + dw2_dv0; + const vec2 dbary_dv1 = dw0_dv1 + dw1_dv1 + dw2_dv1; + const vec2 dbary_dv2 = dw0_dv2 + dw1_dv2 + dw2_dv2; + + return std::make_tuple(dbary_p, dbary_dv0, dbary_dv1, dbary_dv2); +} + +// Forward pass for applying perspective correction to barycentric coordinates. +// +// Args: +// bary: Screen-space barycentric coordinates for a point +// z0, z1, z2: Camera-space z-coordinates of the triangle vertices +// +// Returns +// World-space barycentric coordinates +// +template +inline vec3 BarycentricPerspectiveCorrectionForward( + const vec3& bary, + const T z0, + const T z1, + const T z2) { + const T w0_top = bary.x * z1 * z2; + const T w1_top = bary.y * z0 * z2; + const T w2_top = bary.z * z0 * z1; + const T denom = w0_top + w1_top + w2_top; + const T w0 = w0_top / denom; + const T w1 = w1_top / denom; + const T w2 = w2_top / denom; + return vec3(w0, w1, w2); +} + +// Backward pass for applying perspective correction to barycentric coordinates. +// +// Args: +// bary: Screen-space barycentric coordinates for a point +// z0, z1, z2: Camera-space z-coordinates of the triangle vertices +// grad_out: Upstream gradient of the loss with respect to the corrected +// barycentric coordinates. +// +// Returns a tuple of: +// grad_bary: Downstream gradient of the loss with respect to the the +// uncorrected barycentric coordinates. +// grad_z0, grad_z1, grad_z2: Downstream gradient of the loss with respect +// to the z-coordinates of the triangle verts +template +inline std::tuple, T, T, T> BarycentricPerspectiveCorrectionBackward( + const vec3& bary, + const T z0, + const T z1, + const T z2, + const vec3& grad_out) { + // Recompute forward pass + const T w0_top = bary.x * z1 * z2; + const T w1_top = bary.y * z0 * z2; + const T w2_top = bary.z * z0 * z1; + const T denom = w0_top + w1_top + w2_top; + + // Now do backward pass + const T grad_denom_top = + -w0_top * grad_out.x - w1_top * grad_out.y - w2_top * grad_out.z; + const T grad_denom = grad_denom_top / (denom * denom); + const T grad_w0_top = grad_denom + grad_out.x / denom; + const T grad_w1_top = grad_denom + grad_out.y / denom; + const T grad_w2_top = grad_denom + grad_out.z / denom; + const T grad_bary_x = grad_w0_top * z1 * z2; + const T grad_bary_y = grad_w1_top * z0 * z2; + const T grad_bary_z = grad_w2_top * z0 * z1; + const vec3 grad_bary(grad_bary_x, grad_bary_y, grad_bary_z); + const T grad_z0 = grad_w1_top * bary.y * z2 + grad_w2_top * bary.z * z1; + const T grad_z1 = grad_w0_top * bary.x * z2 + grad_w2_top * bary.z * z0; + const T grad_z2 = grad_w0_top * bary.x * z1 + grad_w1_top * bary.y * z0; + return std::make_tuple(grad_bary, grad_z0, grad_z1, grad_z2); +} + +// Calculate minimum distance between a line segment (v1 - v0) and point p. +// +// Args: +// p: Coordinates of a point. +// v0, v1: Coordinates of the end points of the line segment. +// +// Returns: +// non-square distance of the point to the line. +// +// Consider the line extending the segment - this can be parameterized as: +// v0 + t (v1 - v0). +// +// First find the projection of point p onto the line. It falls where: +// t = [(p - v0) . (v1 - v0)] / |v1 - v0|^2 +// where . is the dot product. +// +// The parameter t is clamped from [0, 1] to handle points outside the +// segment (v1 - v0). +// +// Once the projection of the point on the segment is known, the distance from +// p to the projection gives the minimum distance to the segment. +// +template +T PointLineDistanceForward( + const vec2& p, + const vec2& v0, + const vec2& v1) { + const vec2 v1v0 = v1 - v0; + const T l2 = dot(v1v0, v1v0); + if (l2 <= kEpsilon) { + return sqrt(dot(p - v1, p - v1)); + } + + const T t = dot(v1v0, p - v0) / l2; + const T tt = std::min(std::max(t, 0.00f), 1.00f); + const vec2 p_proj = v0 + tt * v1v0; + return dot(p - p_proj, p - p_proj); +} + +// Backward pass for point to line distance in 2D. +// +// Args: +// p: Coordinates of a point. +// v0, v1: Coordinates of the end points of the line segment. +// grad_dist: Upstream gradient for the distance. +// +// Returns: +// tuple of gradients for each of the input points: +// (vec2 grad_p, vec2 grad_v0, vec2 grad_v1) +// +template +inline std::tuple, vec2, vec2> PointLineDistanceBackward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const T& grad_dist) { + // Redo some of the forward pass calculations. + const vec2 v1v0 = v1 - v0; + const vec2 pv0 = p - v0; + const T t_bot = dot(v1v0, v1v0); + const T t_top = dot(v1v0, pv0); + const T t = t_top / t_bot; + const T tt = std::min(std::max(t, 0.00f), 1.00f); + const vec2 p_proj = (1.0f - tt) * v0 + tt * v1; + + const vec2 grad_v0 = grad_dist * (1.0f - tt) * 2.0f * (p_proj - p); + const vec2 grad_v1 = grad_dist * tt * 2.0f * (p_proj - p); + const vec2 grad_p = -1.0f * grad_dist * 2.0f * (p_proj - p); + + return std::make_tuple(grad_p, grad_v0, grad_v1); +} + +// The forward pass for calculating the shortest distance between a point +// and a triangle. +// Ref: https://www.randygaul.net/2014/07/23/distance-point-to-line-segment/ +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the three triangle vertices. +// +// Returns: +// shortest absolute distance from a point to a triangle. +// +// +template +T PointTriangleDistanceForward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const vec2& v2) { + // Compute distance of point to 3 edges of the triangle and return the + // minimum value. + const T e01_dist = PointLineDistanceForward(p, v0, v1); + const T e02_dist = PointLineDistanceForward(p, v0, v2); + const T e12_dist = PointLineDistanceForward(p, v1, v2); + const T edge_dist = std::min(std::min(e01_dist, e02_dist), e12_dist); + + return edge_dist; +} + +// Backward pass for point triangle distance. +// +// Args: +// p: Coordinates of a point. +// v0, v1, v2: Coordinates of the three triangle vertices. +// grad_dist: Upstream gradient for the distance. +// +// Returns: +// tuple of gradients for each of the triangle vertices: +// (vec2 grad_v0, vec2 grad_v1, vec2 grad_v2) +// +template +inline std::tuple, vec2, vec2, vec2> +PointTriangleDistanceBackward( + const vec2& p, + const vec2& v0, + const vec2& v1, + const vec2& v2, + const T& grad_dist) { + // Compute distance to all 3 edges of the triangle. + const T e01_dist = PointLineDistanceForward(p, v0, v1); + const T e02_dist = PointLineDistanceForward(p, v0, v2); + const T e12_dist = PointLineDistanceForward(p, v1, v2); + + // Initialize output tensors. + vec2 grad_v0(0.0f, 0.0f); + vec2 grad_v1(0.0f, 0.0f); + vec2 grad_v2(0.0f, 0.0f); + vec2 grad_p(0.0f, 0.0f); + + // Find which edge is the closest and return PointLineDistanceBackward for + // that edge. + if (e01_dist <= e02_dist && e01_dist <= e12_dist) { + // Closest edge is v1 - v0. + auto grad_e01 = PointLineDistanceBackward(p, v0, v1, grad_dist); + grad_p = std::get<0>(grad_e01); + grad_v0 = std::get<1>(grad_e01); + grad_v1 = std::get<2>(grad_e01); + } else if (e02_dist <= e01_dist && e02_dist <= e12_dist) { + // Closest edge is v2 - v0. + auto grad_e02 = PointLineDistanceBackward(p, v0, v2, grad_dist); + grad_p = std::get<0>(grad_e02); + grad_v0 = std::get<1>(grad_e02); + grad_v2 = std::get<2>(grad_e02); + } else if (e12_dist <= e01_dist && e12_dist <= e02_dist) { + // Closest edge is v2 - v1. + auto grad_e12 = PointLineDistanceBackward(p, v1, v2, grad_dist); + grad_p = std::get<0>(grad_e12); + grad_v1 = std::get<1>(grad_e12); + grad_v2 = std::get<2>(grad_e12); + } + + return std::make_tuple(grad_p, grad_v0, grad_v1, grad_v2); +} diff --git a/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu new file mode 100644 index 00000000..43035507 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.cu @@ -0,0 +1,803 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include +#include +#include +#include +#include "float_math.cuh" +#include "geometry_utils.cuh" +#include "rasterize_points/bitmask.cuh" +#include "rasterize_points/rasterization_utils.cuh" + +namespace { +// A structure for holding details about a pixel. +struct Pixel { + float z; + int64_t idx; + float dist; + float3 bary; +}; + +__device__ bool operator<(const Pixel& a, const Pixel& b) { + return a.z < b.z; +} + +__device__ float FloatMin3(const float p1, const float p2, const float p3) { + return fminf(p1, fminf(p2, p3)); +} + +__device__ float FloatMax3(const float p1, const float p2, const float p3) { + return fmaxf(p1, fmaxf(p2, p3)); +} + +// Get the xyz coordinates of the three vertices for the face given by the +// index face_idx into face_verts. +__device__ thrust::tuple GetSingleFaceVerts( + const float* face_verts, + int face_idx) { + const float x0 = face_verts[face_idx * 9 + 0]; + const float y0 = face_verts[face_idx * 9 + 1]; + const float z0 = face_verts[face_idx * 9 + 2]; + const float x1 = face_verts[face_idx * 9 + 3]; + const float y1 = face_verts[face_idx * 9 + 4]; + const float z1 = face_verts[face_idx * 9 + 5]; + const float x2 = face_verts[face_idx * 9 + 6]; + const float y2 = face_verts[face_idx * 9 + 7]; + const float z2 = face_verts[face_idx * 9 + 8]; + + const float3 v0xyz = make_float3(x0, y0, z0); + const float3 v1xyz = make_float3(x1, y1, z1); + const float3 v2xyz = make_float3(x2, y2, z2); + + return thrust::make_tuple(v0xyz, v1xyz, v2xyz); +} + +// Get the min/max x/y/z values for the face given by vertices v0, v1, v2. +__device__ thrust::tuple +GetFaceBoundingBox(float3 v0, float3 v1, float3 v2) { + const float xmin = FloatMin3(v0.x, v1.x, v2.x); + const float ymin = FloatMin3(v0.y, v1.y, v2.y); + const float zmin = FloatMin3(v0.z, v1.z, v2.z); + const float xmax = FloatMax3(v0.x, v1.x, v2.x); + const float ymax = FloatMax3(v0.y, v1.y, v2.y); + const float zmax = FloatMax3(v0.z, v1.z, v2.z); + + return thrust::make_tuple( + make_float2(xmin, xmax), + make_float2(ymin, ymax), + make_float2(zmin, zmax)); +} + +// Check if the point (px, py) lies outside the face bounding box face_bbox. +// Return true if the point is outside. +__device__ bool CheckPointOutsideBoundingBox( + float3 v0, + float3 v1, + float3 v2, + float blur_radius, + float2 pxy) { + const auto bbox = GetFaceBoundingBox(v0, v1, v2); + const float2 xlims = thrust::get<0>(bbox); + const float2 ylims = thrust::get<1>(bbox); + const float2 zlims = thrust::get<2>(bbox); + + const float x_min = xlims.x - blur_radius; + const float y_min = ylims.x - blur_radius; + const float x_max = xlims.y + blur_radius; + const float y_max = ylims.y + blur_radius; + + // Check if the current point is oustside the triangle bounding box. + return (pxy.x > x_max || pxy.x < x_min || pxy.y > y_max || pxy.y < y_min); +} + +// This function checks if a pixel given by xy location pxy lies within the +// face with index face_idx in face_verts. One of the inputs is a list (q) +// which contains Pixel structs with the indices of the faces which intersect +// with this pixel sorted by closest z distance. If the point pxy lies in the +// face, the list (q) is updated and re-orderered in place. In addition +// the auxillary variables q_size, q_max_z and q_max_idx are also modified. +// This code is shared between RasterizeMeshesNaiveCudaKernel and +// RasterizeMeshesFineCudaKernel. +template +__device__ void CheckPixelInsideFace( + const float* face_verts, // (N, P, 3) + int face_idx, + int& q_size, + float& q_max_z, + int& q_max_idx, + FaceQ& q, + float blur_radius, + float2 pxy, // Coordinates of the pixel + int K, + bool perspective_correct) { + const auto v012 = GetSingleFaceVerts(face_verts, face_idx); + const float3 v0 = thrust::get<0>(v012); + const float3 v1 = thrust::get<1>(v012); + const float3 v2 = thrust::get<2>(v012); + + // Only need xy for barycentric coordinates and distance calculations. + const float2 v0xy = make_float2(v0.x, v0.y); + const float2 v1xy = make_float2(v1.x, v1.y); + const float2 v2xy = make_float2(v2.x, v2.y); + + // Perform checks and skip if: + // 1. the face is behind the camera + // 2. the face has very small face area + // 3. the pixel is outside the face bbox + const float zmax = FloatMax3(v0.z, v1.z, v2.z); + const bool outside_bbox = CheckPointOutsideBoundingBox( + v0, v1, v2, sqrt(blur_radius), pxy); // use sqrt of blur for bbox + const float face_area = EdgeFunctionForward(v0xy, v1xy, v2xy); + const bool zero_face_area = + (face_area <= kEpsilon && face_area >= -1.0f * kEpsilon); + + if (zmax < 0 || outside_bbox || zero_face_area) { + return; + } + + // Calculate barycentric coords and euclidean dist to triangle. + const float3 p_bary0 = BarycentricCoordsForward(pxy, v0xy, v1xy, v2xy); + const float3 p_bary = !perspective_correct + ? p_bary0 + : BarycentricPerspectiveCorrectionForward(p_bary0, v0.z, v1.z, v2.z); + + const float pz = p_bary.x * v0.z + p_bary.y * v1.z + p_bary.z * v2.z; + if (pz < 0) { + return; // Face is behind the image plane. + } + + // Get abs squared distance + const float dist = PointTriangleDistanceForward(pxy, v0xy, v1xy, v2xy); + + // Use the bary coordinates to determine if the point is inside the face. + const bool inside = p_bary.x > 0.0f && p_bary.y > 0.0f && p_bary.z > 0.0f; + const float signed_dist = inside ? -dist : dist; + + // Check if pixel is outside blur region + if (!inside && dist >= blur_radius) { + return; + } + + if (q_size < K) { + // Just insert it. + q[q_size] = {pz, face_idx, signed_dist, p_bary}; + if (pz > q_max_z) { + q_max_z = pz; + q_max_idx = q_size; + } + q_size++; + } else if (pz < q_max_z) { + // Overwrite the old max, and find the new max. + q[q_max_idx] = {pz, face_idx, signed_dist, p_bary}; + q_max_z = pz; + for (int i = 0; i < K; i++) { + if (q[i].z > q_max_z) { + q_max_z = q[i].z; + q_max_idx = i; + } + } + } +} +} // namespace + +// **************************************************************************** +// * NAIVE RASTERIZATION * +// **************************************************************************** +__global__ void RasterizeMeshesNaiveCudaKernel( + const float* face_verts, + const int64_t* mesh_to_face_first_idx, + const int64_t* num_faces_per_mesh, + float blur_radius, + bool perspective_correct, + int N, + int H, + int W, + int K, + int64_t* face_idxs, + float* zbuf, + float* pix_dists, + float* bary) { + // Simple version: One thread per output pixel + int num_threads = gridDim.x * blockDim.x; + int tid = blockDim.x * blockIdx.x + threadIdx.x; + + for (int i = tid; i < N * H * W; i += num_threads) { + // Convert linear index to 3D index + const int n = i / (H * W); // batch index. + const int pix_idx = i % (H * W); + const int yi = pix_idx / H; + const int xi = pix_idx % W; + + // screen coordinates to ndc coordiantes of pixel. + const float xf = PixToNdc(xi, W); + const float yf = PixToNdc(yi, H); + const float2 pxy = make_float2(xf, yf); + + // For keeping track of the K closest points we want a data structure + // that (1) gives O(1) access to the closest point for easy comparisons, + // and (2) allows insertion of new elements. In the CPU version we use + // std::priority_queue; then (2) is O(log K). We can't use STL + // containers in CUDA; we could roll our own max heap in an array, but + // that would likely have a lot of warp divergence so we do something + // simpler instead: keep the elements in an unsorted array, but keep + // track of the max value and the index of the max value. Then (1) is + // still O(1) time, while (2) is O(K) with a clean loop. Since K <= 8 + // this should be fast enough for our purposes. + Pixel q[kMaxPointsPerPixel]; + int q_size = 0; + float q_max_z = -1000; + int q_max_idx = -1; + + // Using the batch index of the thread get the start and stop + // indices for the faces. + const int64_t face_start_idx = mesh_to_face_first_idx[n]; + const int64_t face_stop_idx = face_start_idx + num_faces_per_mesh[n]; + + // Loop through the faces in the mesh. + for (int f = face_start_idx; f < face_stop_idx; ++f) { + // Check if the pixel pxy is inside the face bounding box and if it is, + // update q, q_size, q_max_z and q_max_idx in place. + CheckPixelInsideFace( + face_verts, + f, + q_size, + q_max_z, + q_max_idx, + q, + blur_radius, + pxy, + K, + perspective_correct); + } + + // TODO: make sorting an option as only top k is needed, not sorted values. + BubbleSort(q, q_size); + int idx = n * H * W * K + yi * H * K + xi * K; + for (int k = 0; k < q_size; ++k) { + face_idxs[idx + k] = q[k].idx; + zbuf[idx + k] = q[k].z; + pix_dists[idx + k] = q[k].dist; + bary[(idx + k) * 3 + 0] = q[k].bary.x; + bary[(idx + k) * 3 + 1] = q[k].bary.y; + bary[(idx + k) * 3 + 2] = q[k].bary.z; + } + } +} + +std::tuple +RasterizeMeshesNaiveCuda( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_faces_packed_first_idx, + const torch::Tensor& num_faces_per_mesh, + const int image_size, + const float blur_radius, + const int num_closest, + bool perspective_correct) { + if (face_verts.ndimension() != 3 || face_verts.size(1) != 3 || + face_verts.size(2) != 3) { + AT_ERROR("face_verts must have dimensions (num_faces, 3, 3)"); + } + if (num_faces_per_mesh.size(0) != mesh_to_faces_packed_first_idx.size(0)) { + AT_ERROR( + "num_faces_per_mesh must have save size first dimension as mesh_to_faces_packed_first_idx"); + } + + if (num_closest > kMaxPointsPerPixel) { + std::stringstream ss; + ss << "Must have points_per_pixel <= " << kMaxPointsPerPixel; + AT_ERROR(ss.str()); + } + + const int N = num_faces_per_mesh.size(0); // batch size. + const int H = image_size; // Assume square images. + const int W = image_size; + const int K = num_closest; + + auto long_opts = face_verts.options().dtype(torch::kInt64); + auto float_opts = face_verts.options().dtype(torch::kFloat32); + + torch::Tensor face_idxs = torch::full({N, H, W, K}, -1, long_opts); + torch::Tensor zbuf = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor bary = torch::full({N, H, W, K, 3}, -1, float_opts); + + const size_t blocks = 1024; + const size_t threads = 64; + + RasterizeMeshesNaiveCudaKernel<<>>( + face_verts.contiguous().data(), + mesh_to_faces_packed_first_idx.contiguous().data(), + num_faces_per_mesh.contiguous().data(), + blur_radius, + perspective_correct, + N, + H, + W, + K, + face_idxs.contiguous().data(), + zbuf.contiguous().data(), + pix_dists.contiguous().data(), + bary.contiguous().data()); + + return std::make_tuple(face_idxs, zbuf, bary, pix_dists); +} + +// **************************************************************************** +// * BACKWARD PASS * +// **************************************************************************** +// TODO: benchmark parallelizing over faces_verts instead of over pixels. +__global__ void RasterizeMeshesBackwardCudaKernel( + const float* face_verts, // (F, 3, 3) + const int64_t* pix_to_face, // (N, H, W, K) + bool perspective_correct, + int N, + int F, + int H, + int W, + int K, + const float* grad_zbuf, // (N, H, W, K) + const float* grad_bary, // (N, H, W, K, 3) + const float* grad_dists, // (N, H, W, K) + float* grad_face_verts) { // (F, 3, 3) + + // Parallelize over each pixel in images of + // size H * W, for each image in the batch of size N. + const int num_threads = gridDim.x * blockDim.x; + const int tid = blockIdx.x * blockDim.x + threadIdx.x; + + for (int t_i = tid; t_i < N * H * W; t_i += num_threads) { + // Convert linear index to 3D index + const int n = t_i / (H * W); // batch index. + const int pix_idx = t_i % (H * W); + const int yi = pix_idx / H; + const int xi = pix_idx % W; + const float xf = PixToNdc(xi, W); + const float yf = PixToNdc(yi, H); + const float2 pxy = make_float2(xf, yf); + + // Loop over all the faces for this pixel. + for (int k = 0; k < K; k++) { + // Index into (N, H, W, K, :) grad tensors + const int i = + n * H * W * K + yi * H * K + xi * K + k; // pixel index + face index + + const int f = pix_to_face[i]; + if (f < 0) { + continue; // padded face. + } + // Get xyz coordinates of the three face vertices. + const auto v012 = GetSingleFaceVerts(face_verts, f); + const float3 v0 = thrust::get<0>(v012); + const float3 v1 = thrust::get<1>(v012); + const float3 v2 = thrust::get<2>(v012); + + // Only neex xy for barycentric coordinate and distance calculations. + const float2 v0xy = make_float2(v0.x, v0.y); + const float2 v1xy = make_float2(v1.x, v1.y); + const float2 v2xy = make_float2(v2.x, v2.y); + + // Get upstream gradients for the face. + const float grad_dist_upstream = grad_dists[i]; + const float grad_zbuf_upstream = grad_zbuf[i]; + const float grad_bary_upstream_w0 = grad_bary[i * 3 + 0]; + const float grad_bary_upstream_w1 = grad_bary[i * 3 + 1]; + const float grad_bary_upstream_w2 = grad_bary[i * 3 + 2]; + const float3 grad_bary_upstream = make_float3( + grad_bary_upstream_w0, grad_bary_upstream_w1, grad_bary_upstream_w2); + + const float3 bary0 = BarycentricCoordsForward(pxy, v0xy, v1xy, v2xy); + const float3 bary = !perspective_correct + ? bary0 + : BarycentricPerspectiveCorrectionForward(bary0, v0.z, v1.z, v2.z); + const bool inside = bary.x > 0.0f && bary.y > 0.0f && bary.z > 0.0f; + const float sign = inside ? -1.0f : 1.0f; + + // TODO(T52813608) Add support for non-square images. + auto grad_dist_f = PointTriangleDistanceBackward( + pxy, v0xy, v1xy, v2xy, sign * grad_dist_upstream); + const float2 ddist_d_v0 = thrust::get<1>(grad_dist_f); + const float2 ddist_d_v1 = thrust::get<2>(grad_dist_f); + const float2 ddist_d_v2 = thrust::get<3>(grad_dist_f); + + // Upstream gradient for barycentric coords from zbuf calculation: + // zbuf = bary_w0 * z0 + bary_w1 * z1 + bary_w2 * z2 + // Therefore + // d_zbuf/d_bary_w0 = z0 + // d_zbuf/d_bary_w1 = z1 + // d_zbuf/d_bary_w2 = z2 + const float3 d_zbuf_d_bary = make_float3(v0.z, v1.z, v2.z); + + // Total upstream barycentric gradients are the sum of + // external upstream gradients and contribution from zbuf. + const float3 grad_bary_f_sum = + (grad_bary_upstream + grad_zbuf_upstream * d_zbuf_d_bary); + float3 grad_bary0 = grad_bary_f_sum; + float dz0_persp = 0.0f, dz1_persp = 0.0f, dz2_persp = 0.0f; + if (perspective_correct) { + auto perspective_grads = BarycentricPerspectiveCorrectionBackward( + bary0, v0.z, v1.z, v2.z, grad_bary_f_sum); + grad_bary0 = thrust::get<0>(perspective_grads); + dz0_persp = thrust::get<1>(perspective_grads); + dz1_persp = thrust::get<2>(perspective_grads); + dz2_persp = thrust::get<3>(perspective_grads); + } + auto grad_bary_f = + BarycentricCoordsBackward(pxy, v0xy, v1xy, v2xy, grad_bary0); + const float2 dbary_d_v0 = thrust::get<1>(grad_bary_f); + const float2 dbary_d_v1 = thrust::get<2>(grad_bary_f); + const float2 dbary_d_v2 = thrust::get<3>(grad_bary_f); + + atomicAdd(grad_face_verts + f * 9 + 0, dbary_d_v0.x + ddist_d_v0.x); + atomicAdd(grad_face_verts + f * 9 + 1, dbary_d_v0.y + ddist_d_v0.y); + atomicAdd( + grad_face_verts + f * 9 + 2, grad_zbuf_upstream * bary.x + dz0_persp); + atomicAdd(grad_face_verts + f * 9 + 3, dbary_d_v1.x + ddist_d_v1.x); + atomicAdd(grad_face_verts + f * 9 + 4, dbary_d_v1.y + ddist_d_v1.y); + atomicAdd( + grad_face_verts + f * 9 + 5, grad_zbuf_upstream * bary.y + dz1_persp); + atomicAdd(grad_face_verts + f * 9 + 6, dbary_d_v2.x + ddist_d_v2.x); + atomicAdd(grad_face_verts + f * 9 + 7, dbary_d_v2.y + ddist_d_v2.y); + atomicAdd( + grad_face_verts + f * 9 + 8, grad_zbuf_upstream * bary.z + dz2_persp); + } + } +} + +torch::Tensor RasterizeMeshesBackwardCuda( + const torch::Tensor& face_verts, // (F, 3, 3) + const torch::Tensor& pix_to_face, // (N, H, W, K) + const torch::Tensor& grad_zbuf, // (N, H, W, K) + const torch::Tensor& grad_bary, // (N, H, W, K, 3) + const torch::Tensor& grad_dists, // (N, H, W, K) + bool perspective_correct) { + const int F = face_verts.size(0); + const int N = pix_to_face.size(0); + const int H = pix_to_face.size(1); + const int W = pix_to_face.size(2); + const int K = pix_to_face.size(3); + + torch::Tensor grad_face_verts = torch::zeros({F, 3, 3}, face_verts.options()); + const size_t blocks = 1024; + const size_t threads = 64; + + RasterizeMeshesBackwardCudaKernel<<>>( + face_verts.contiguous().data(), + pix_to_face.contiguous().data(), + perspective_correct, + N, + F, + H, + W, + K, + grad_zbuf.contiguous().data(), + grad_bary.contiguous().data(), + grad_dists.contiguous().data(), + grad_face_verts.contiguous().data()); + + return grad_face_verts; +} + +// **************************************************************************** +// * COARSE RASTERIZATION * +// **************************************************************************** + +__global__ void RasterizeMeshesCoarseCudaKernel( + const float* face_verts, + const int64_t* mesh_to_face_first_idx, + const int64_t* num_faces_per_mesh, + const float blur_radius, + const int N, + const int F, + const int H, + const int W, + const int bin_size, + const int chunk_size, + const int max_faces_per_bin, + int* faces_per_bin, + int* bin_faces) { + extern __shared__ char sbuf[]; + const int M = max_faces_per_bin; + const int num_bins = 1 + (W - 1) / bin_size; // Integer divide round up + const float half_pix = 1.0f / W; // Size of half a pixel in NDC units + // This is a boolean array of shape (num_bins, num_bins, chunk_size) + // stored in shared memory that will track whether each point in the chunk + // falls into each bin of the image. + BitMask binmask((unsigned int*)sbuf, num_bins, num_bins, chunk_size); + + // Have each block handle a chunk of faces + const int chunks_per_batch = 1 + (F - 1) / chunk_size; + const int num_chunks = N * chunks_per_batch; + for (int chunk = blockIdx.x; chunk < num_chunks; chunk += gridDim.x) { + const int batch_idx = chunk / chunks_per_batch; // batch index + const int chunk_idx = chunk % chunks_per_batch; + const int face_start_idx = chunk_idx * chunk_size; + + binmask.block_clear(); + const int64_t mesh_face_start_idx = mesh_to_face_first_idx[batch_idx]; + const int64_t mesh_face_stop_idx = + mesh_face_start_idx + num_faces_per_mesh[batch_idx]; + + // Have each thread handle a different face within the chunk + for (int f = threadIdx.x; f < chunk_size; f += blockDim.x) { + const int f_idx = face_start_idx + f; + + // Check if face index corresponds to the mesh in the batch given by + // batch_idx + if (f_idx >= mesh_face_stop_idx || f_idx < mesh_face_start_idx) { + continue; + } + + // Get xyz coordinates of the three face vertices. + const auto v012 = GetSingleFaceVerts(face_verts, f_idx); + const float3 v0 = thrust::get<0>(v012); + const float3 v1 = thrust::get<1>(v012); + const float3 v2 = thrust::get<2>(v012); + + // Compute screen-space bbox for the triangle expanded by blur. + float xmin = FloatMin3(v0.x, v1.x, v2.x) - sqrt(blur_radius); + float ymin = FloatMin3(v0.y, v1.y, v2.y) - sqrt(blur_radius); + float xmax = FloatMax3(v0.x, v1.x, v2.x) + sqrt(blur_radius); + float ymax = FloatMax3(v0.y, v1.y, v2.y) + sqrt(blur_radius); + float zmax = FloatMax3(v0.z, v1.z, v2.z); + + if (zmax < 0) { + continue; // Face is behind the camera. + } + + // Brute-force search over all bins; TODO(T54294966) something smarter. + for (int by = 0; by < num_bins; ++by) { + // Y coordinate of the top and bottom of the bin. + // PixToNdc gives the location of the center of each pixel, so we + // need to add/subtract a half pixel to get the true extent of the bin. + const float bin_y_min = PixToNdc(by * bin_size, H) - half_pix; + const float bin_y_max = PixToNdc((by + 1) * bin_size - 1, H) + half_pix; + const bool y_overlap = (ymin <= bin_y_max) && (bin_y_min < ymax); + + for (int bx = 0; bx < num_bins; ++bx) { + // X coordinate of the left and right of the bin. + const float bin_x_min = PixToNdc(bx * bin_size, W) - half_pix; + const float bin_x_max = + PixToNdc((bx + 1) * bin_size - 1, W) + half_pix; + const bool x_overlap = (xmin <= bin_x_max) && (bin_x_min < xmax); + + if (y_overlap && x_overlap) { + binmask.set(by, bx, f); + } + } + } + } + __syncthreads(); + // Now we have processed every face in the current chunk. We need to + // count the number of faces in each bin so we can write the indices + // out to global memory. We have each thread handle a different bin. + for (int byx = threadIdx.x; byx < num_bins * num_bins; byx += blockDim.x) { + const int by = byx / num_bins; + const int bx = byx % num_bins; + const int count = binmask.count(by, bx); + const int faces_per_bin_idx = + batch_idx * num_bins * num_bins + by * num_bins + bx; + + // This atomically increments the (global) number of faces found + // in the current bin, and gets the previous value of the counter; + // this effectively allocates space in the bin_faces array for the + // faces in the current chunk that fall into this bin. + const int start = atomicAdd(faces_per_bin + faces_per_bin_idx, count); + + // Now loop over the binmask and write the active bits for this bin + // out to bin_faces. + int next_idx = batch_idx * num_bins * num_bins * M + by * num_bins * M + + bx * M + start; + for (int f = 0; f < chunk_size; ++f) { + if (binmask.get(by, bx, f)) { + // TODO(T54296346) find the correct method for handling errors in + // CUDA. Throw an error if num_faces_per_bin > max_faces_per_bin. + // Either decrease bin size or increase max_faces_per_bin + bin_faces[next_idx] = face_start_idx + f; + next_idx++; + } + } + } + __syncthreads(); + } +} + +torch::Tensor RasterizeMeshesCoarseCuda( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + const int image_size, + const float blur_radius, + const int bin_size, + const int max_faces_per_bin) { + if (face_verts.ndimension() != 3 || face_verts.size(1) != 3 || + face_verts.size(2) != 3) { + AT_ERROR("face_verts must have dimensions (num_faces, 3, 3)"); + } + const int W = image_size; + const int H = image_size; + const int F = face_verts.size(0); + const int N = num_faces_per_mesh.size(0); + const int num_bins = 1 + (image_size - 1) / bin_size; // Divide round up. + const int M = max_faces_per_bin; + if (num_bins >= 22) { + std::stringstream ss; + ss << "Got " << num_bins << "; that's too many!"; + AT_ERROR(ss.str()); + } + auto opts = face_verts.options().dtype(torch::kInt32); + torch::Tensor faces_per_bin = torch::zeros({N, num_bins, num_bins}, opts); + torch::Tensor bin_faces = torch::full({N, num_bins, num_bins, M}, -1, opts); + const int chunk_size = 512; + const size_t shared_size = num_bins * num_bins * chunk_size / 8; + const size_t blocks = 64; + const size_t threads = 512; + + RasterizeMeshesCoarseCudaKernel<<>>( + face_verts.contiguous().data(), + mesh_to_face_first_idx.contiguous().data(), + num_faces_per_mesh.contiguous().data(), + blur_radius, + N, + F, + H, + W, + bin_size, + chunk_size, + M, + faces_per_bin.contiguous().data(), + bin_faces.contiguous().data()); + return bin_faces; +} + +// **************************************************************************** +// * FINE RASTERIZATION * +// **************************************************************************** + +__global__ void RasterizeMeshesFineCudaKernel( + const float* face_verts, // (F, 3, 3) + const int32_t* bin_faces, // (N, B, B, T) + const float blur_radius, + const int bin_size, + const bool perspective_correct, + const int N, + const int F, + const int B, + const int M, + const int H, + const int W, + const int K, + int64_t* face_idxs, // (N, S, S, K) + float* zbuf, // (N, S, S, K) + float* pix_dists, // (N, S, S, K) + float* bary // (N, S, S, K, 3) +) { + // This can be more than S^2 if S % bin_size != 0 + int num_pixels = N * B * B * bin_size * bin_size; + int num_threads = gridDim.x * blockDim.x; + int tid = blockIdx.x * blockDim.x + threadIdx.x; + + for (int pid = tid; pid < num_pixels; pid += num_threads) { + // Convert linear index into bin and pixel indices. We make the within + // block pixel ids move the fastest, so that adjacent threads will fall + // into the same bin; this should give them coalesced memory reads when + // they read from faces and bin_faces. + int i = pid; + const int n = i / (B * B * bin_size * bin_size); + i %= B * B * bin_size * bin_size; + const int by = i / (B * bin_size * bin_size); + i %= B * bin_size * bin_size; + const int bx = i / (bin_size * bin_size); + i %= bin_size * bin_size; + const int yi = i / bin_size + by * bin_size; + const int xi = i % bin_size + bx * bin_size; + + if (yi >= H || xi >= W) + continue; + const float xf = PixToNdc(xi, W); + const float yf = PixToNdc(yi, H); + const float2 pxy = make_float2(xf, yf); + + // This part looks like the naive rasterization kernel, except we use + // bin_faces to only look at a subset of faces already known to fall + // in this bin. TODO abstract out this logic into some data structure + // that is shared by both kernels? + Pixel q[kMaxPointsPerPixel]; + int q_size = 0; + float q_max_z = -1000; + int q_max_idx = -1; + for (int m = 0; m < M; m++) { + const int f = bin_faces[n * B * B * M + by * B * M + bx * M + m]; + if (f < 0) { + continue; // bin_faces uses -1 as a sentinal value. + } + // Check if the pixel pxy is inside the face bounding box and if it is, + // update q, q_size, q_max_z and q_max_idx in place. + CheckPixelInsideFace( + face_verts, + f, + q_size, + q_max_z, + q_max_idx, + q, + blur_radius, + pxy, + K, + perspective_correct); + } + + // Now we've looked at all the faces for this bin, so we can write + // output for the current pixel. + // TODO: make sorting an option as only top k is needed, not sorted values. + BubbleSort(q, q_size); + const int pix_idx = n * H * W * K + yi * H * K + xi * K; + for (int k = 0; k < q_size; k++) { + face_idxs[pix_idx + k] = q[k].idx; + zbuf[pix_idx + k] = q[k].z; + pix_dists[pix_idx + k] = q[k].dist; + bary[(pix_idx + k) * 3 + 0] = q[k].bary.x; + bary[(pix_idx + k) * 3 + 1] = q[k].bary.y; + bary[(pix_idx + k) * 3 + 2] = q[k].bary.z; + } + } +} + +std::tuple +RasterizeMeshesFineCuda( + const torch::Tensor& face_verts, + const torch::Tensor& bin_faces, + const int image_size, + const float blur_radius, + const int bin_size, + const int faces_per_pixel, + bool perspective_correct) { + if (face_verts.ndimension() != 3 || face_verts.size(1) != 3 || + face_verts.size(2) != 3) { + AT_ERROR("face_verts must have dimensions (num_faces, 3, 3)"); + } + if (bin_faces.ndimension() != 4) { + AT_ERROR("bin_faces must have 4 dimensions"); + } + const int F = face_verts.size(0); + const int N = bin_faces.size(0); + const int B = bin_faces.size(1); + const int M = bin_faces.size(3); + const int K = faces_per_pixel; + const int H = image_size; // Assume square images only. + const int W = image_size; + + if (K > kMaxPointsPerPixel) { + AT_ERROR("Must have num_closest <= 8"); + } + auto long_opts = face_verts.options().dtype(torch::kInt64); + auto float_opts = face_verts.options().dtype(torch::kFloat32); + + torch::Tensor face_idxs = torch::full({N, H, W, K}, -1, long_opts); + torch::Tensor zbuf = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor bary = torch::full({N, H, W, K, 3}, -1, float_opts); + + const size_t blocks = 1024; + const size_t threads = 64; + + RasterizeMeshesFineCudaKernel<<>>( + face_verts.contiguous().data(), + bin_faces.contiguous().data(), + blur_radius, + bin_size, + perspective_correct, + N, + F, + B, + M, + H, + W, + K, + face_idxs.contiguous().data(), + zbuf.contiguous().data(), + pix_dists.contiguous().data(), + bary.contiguous().data()); + + return std::make_tuple(face_idxs, zbuf, bary, pix_dists); +} diff --git a/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.h b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.h new file mode 100644 index 00000000..600bec82 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes.h @@ -0,0 +1,411 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include +#include +#include + +// **************************************************************************** +// * FORWARD PASS * +// **************************************************************************** + +std::tuple +RasterizeMeshesNaiveCpu( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int faces_per_pixel, + bool perspective_correct); + +std::tuple +RasterizeMeshesNaiveCuda( + const at::Tensor& face_verts, + const at::Tensor& mesh_to_face_first_idx, + const at::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int num_closest, + bool perspective_correct); + +// Forward pass for rasterizing a batch of meshes. +// +// Args: +// face_verts: Tensor of shape (F, 3, 3) giving (packed) vertex positions for +// faces in all the meshes in the batch. Concretely, +// face_verts[f, i] = [x, y, z] gives the coordinates for the +// ith vertex of the fth face. These vertices are expected to be +// in NDC coordinates in the range [-1, 1]. +// mesh_to_face_first_idx: LongTensor of shape (N) giving the index in +// faces_verts of the first face in each mesh in +// the batch where N is the batch size. +// num_faces_per_mesh: LongTensor of shape (N) giving the number of faces +// for each mesh in the batch. +// image_size: Size in pixels of the output image to be rasterized. +// Assume square images only. +// blur_radius: float distance in NDC coordinates uses to expand the face +// bounding boxes for the rasterization. Set to 0.0 if no blur +// is required. +// faces_per_pixel: the number of closeset faces to rasterize per pixel. +// perspective_correct: Whether to apply perspective correction when +// computing barycentric coordinates. If this is True, +// then this function returns world-space barycentric +// coordinates for each pixel; if this is False then +// this function instead returns screen-space +// barycentric coordinates for each pixel. +// +// Returns: +// A 4 element tuple of: +// pix_to_face: int64 tensor of shape (N, H, W, K) giving the face index of +// each of the closest faces to the pixel in the rasterized +// image, or -1 for pixels that are not covered by any face. +// zbuf: float32 Tensor of shape (N, H, W, K) giving the depth of each of +// the closest faces for each pixel. +// barycentric_coords: float tensor of shape (N, H, W, K, 3) giving +// barycentric coordinates of the pixel with respect to +// each of the closest faces along the z axis, padded +// with -1 for pixels hit by fewer than +// faces_per_pixel faces. +// dists: float tensor of shape (N, H, W, K) giving the euclidean distance +// in the (NDC) x/y plane between each pixel and its K closest +// faces along the z axis padded with -1 for pixels hit by fewer than +// faces_per_pixel faces. +inline std::tuple +RasterizeMeshesNaive( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int faces_per_pixel, + bool perspective_correct) { + // TODO: Better type checking. + if (face_verts.type().is_cuda()) { + return RasterizeMeshesNaiveCuda( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + faces_per_pixel, + perspective_correct); + } else { + return RasterizeMeshesNaiveCpu( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + faces_per_pixel, + perspective_correct); + } +} + +// **************************************************************************** +// * BACKWARD PASS * +// **************************************************************************** + +torch::Tensor RasterizeMeshesBackwardCpu( + const torch::Tensor& face_verts, + const torch::Tensor& pix_to_face, + const torch::Tensor& grad_bary, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_dists, + bool perspective_correct); + +torch::Tensor RasterizeMeshesBackwardCuda( + const torch::Tensor& face_verts, + const torch::Tensor& pix_to_face, + const torch::Tensor& grad_bary, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_dists, + bool perspective_correct); + +// Args: +// face_verts: float32 Tensor of shape (F, 3, 3) (from forward pass) giving +// (packed) vertex positions for faces in all the meshes in +// the batch. +// pix_to_face: int64 tensor of shape (N, H, W, K) giving the face index of +// each of the closest faces to the pixel in the rasterized +// image, or -1 for pixels that are not covered by any face. +// grad_zbuf: Tensor of shape (N, H, W, K) giving upstream gradients +// d(loss)/d(zbuf) of the zbuf tensor from the forward pass. +// grad_bary: Tensor of shape (N, H, W, K, 3) giving upstream gradients +// d(loss)/d(bary) of the barycentric_coords tensor returned by +// the forward pass. +// grad_dists: Tensor of shape (N, H, W, K) giving upstream gradients +// d(loss)/d(dists) of the dists tensor from the forward pass. +// perspective_correct: Whether to apply perspective correction when +// computing barycentric coordinates. If this is True, +// then this function returns world-space barycentric +// coordinates for each pixel; if this is False then +// this function instead returns screen-space +// barycentric coordinates for each pixel. +// +// Returns: +// grad_face_verts: float32 Tensor of shape (F, 3, 3) giving downstream +// gradients for the face vertices. +torch::Tensor RasterizeMeshesBackward( + const torch::Tensor& face_verts, + const torch::Tensor& pix_to_face, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_bary, + const torch::Tensor& grad_dists, + bool perspective_correct) { + if (face_verts.type().is_cuda()) { + return RasterizeMeshesBackwardCuda( + face_verts, + pix_to_face, + grad_zbuf, + grad_bary, + grad_dists, + perspective_correct); + } else { + return RasterizeMeshesBackwardCpu( + face_verts, + pix_to_face, + grad_zbuf, + grad_bary, + grad_dists, + perspective_correct); + } +} + +// **************************************************************************** +// * COARSE RASTERIZATION * +// **************************************************************************** + +torch::Tensor RasterizeMeshesCoarseCpu( + const torch::Tensor& face_verts, + const at::Tensor& mesh_to_face_first_idx, + const at::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int bin_size, + int max_faces_per_bin); + +torch::Tensor RasterizeMeshesCoarseCuda( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int bin_size, + int max_faces_per_bin); + +// Args: +// face_verts: Tensor of shape (F, 3, 3) giving (packed) vertex positions for +// faces in all the meshes in the batch. Concretely, +// face_verts[f, i] = [x, y, z] gives the coordinates for the +// ith vertex of the fth face. These vertices are expected to be +// in NDC coordinates in the range [-1, 1]. +// mesh_to_face_first_idx: LongTensor of shape (N) giving the index in +// faces_verts of the first face in each mesh in +// the batch where N is the batch size. +// num_faces_per_mesh: LongTensor of shape (N) giving the number of faces +// for each mesh in the batch. +// image_size: Size in pixels of the output image to be rasterized. +// blur_radius: float distance in NDC coordinates uses to expand the face +// bounding boxes for the rasterization. Set to 0.0 if no blur +// is required. +// bin_size: Size of each bin within the image (in pixels) +// max_faces_per_bin: Maximum number of faces to count in each bin. +// +// Returns: +// bin_face_idxs: Tensor of shape (N, num_bins, num_bins, K) giving the +// indices of faces that fall into each bin. + +torch::Tensor RasterizeMeshesCoarse( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int bin_size, + int max_faces_per_bin) { + if (face_verts.type().is_cuda()) { + return RasterizeMeshesCoarseCuda( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin); + } else { + return RasterizeMeshesCoarseCpu( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin); + } +} + +// **************************************************************************** +// * FINE RASTERIZATION * +// **************************************************************************** + +std::tuple +RasterizeMeshesFineCuda( + const torch::Tensor& face_verts, + const torch::Tensor& bin_faces, + int image_size, + float blur_radius, + int bin_size, + int faces_per_pixel, + bool perspective_correct); + +// Args: +// face_verts: Tensor of shape (F, 3, 3) giving (packed) vertex positions for +// faces in all the meshes in the batch. Concretely, +// face_verts[f, i] = [x, y, z] gives the coordinates for the +// ith vertex of the fth face. These vertices are expected to be +// in NDC coordinates in the range [-1, 1]. +// bin_faces: int32 Tensor of shape (N, B, B, M) giving the indices of faces +// that fall into each bin (output from coarse rasterization). +// image_size: Size in pixels of the output image to be rasterized. +// blur_radius: float distance in NDC coordinates uses to expand the face +// bounding boxes for the rasterization. Set to 0.0 if no blur +// is required. +// bin_size: Size of each bin within the image (in pixels) +// faces_per_pixel: the number of closeset faces to rasterize per pixel. +// perspective_correct: Whether to apply perspective correction when +// computing barycentric coordinates. If this is True, +// then this function returns world-space barycentric +// coordinates for each pixel; if this is False then +// this function instead returns screen-space +// barycentric coordinates for each pixel. +// +// Returns (same as rasterize_meshes): +// A 4 element tuple of: +// pix_to_face: int64 tensor of shape (N, H, W, K) giving the face index of +// each of the closest faces to the pixel in the rasterized +// image, or -1 for pixels that are not covered by any face. +// zbuf: float32 Tensor of shape (N, H, W, K) giving the depth of each of +// the closest faces for each pixel. +// barycentric_coords: float tensor of shape (N, H, W, K, 3) giving +// barycentric coordinates of the pixel with respect to +// each of the closest faces along the z axis, padded +// with -1 for pixels hit by fewer than +// faces_per_pixel faces. +// dists: float tensor of shape (N, H, W, K) giving the euclidean distance +// in the (NDC) x/y plane between each pixel and its K closest +// faces along the z axis padded with -1 for pixels hit by fewer than +// faces_per_pixel faces. +std::tuple +RasterizeMeshesFine( + const torch::Tensor& face_verts, + const torch::Tensor& bin_faces, + int image_size, + float blur_radius, + int bin_size, + int faces_per_pixel, + bool perspective_correct) { + if (face_verts.type().is_cuda()) { + return RasterizeMeshesFineCuda( + face_verts, + bin_faces, + image_size, + blur_radius, + bin_size, + faces_per_pixel, + perspective_correct); + } else { + AT_ERROR("NOT IMPLEMENTED"); + } +} + +// **************************************************************************** +// * MAIN ENTRY POINT * +// **************************************************************************** + +// This is the main entry point for the forward pass of the mesh rasterizer; +// it uses either naive or coarse-to-fine rasterization based on bin_size. +// +// Args: +// face_verts: Tensor of shape (F, 3, 3) giving (packed) vertex positions for +// faces in all the meshes in the batch. Concretely, +// face_verts[f, i] = [x, y, z] gives the coordinates for the +// ith vertex of the fth face. These vertices are expected to be +// in NDC coordinates in the range [-1, 1]. +// mesh_to_face_first_idx: LongTensor of shape (N) giving the index in +// faces_verts of the first face in each mesh in +// the batch where N is the batch size. +// num_faces_per_mesh: LongTensor of shape (N) giving the number of faces +// for each mesh in the batch. +// image_size: Size in pixels of the output image to be rasterized. +// blur_radius: float distance in NDC coordinates uses to expand the face +// bounding boxes for the rasterization. Set to 0.0 if no blur +// is required. +// bin_size: Bin size (in pixels) for coarse-to-fine rasterization. Setting +// bin_size=0 uses naive rasterization instead. +// max_faces_per_bin: The maximum number of faces allowed to fall into each +// bin when using coarse-to-fine rasterization. +// perspective_correct: Whether to apply perspective correction when +// computing barycentric coordinates. If this is True, +// then this function returns world-space barycentric +// coordinates for each pixel; if this is False then +// this function instead returns screen-space +// barycentric coordinates for each pixel. +// +// Returns: +// A 4 element tuple of: +// pix_to_face: int64 tensor of shape (N, H, W, K) giving the face index of +// each of the closest faces to the pixel in the rasterized +// image, or -1 for pixels that are not covered by any face. +// zbuf: float32 Tensor of shape (N, H, W, K) giving the depth of each of +// the closest faces for each pixel. +// barycentric_coords: float tensor of shape (N, H, W, K, 3) giving +// barycentric coordinates of the pixel with respect to +// each of the closest faces along the z axis, padded +// with -1 for pixels hit by fewer than +// faces_per_pixel faces. +// dists: float tensor of shape (N, H, W, K) giving the euclidean distance +// in the (NDC) x/y plane between each pixel and its K closest +// faces along the z axis padded with -1 for pixels hit by fewer than +// faces_per_pixel faces. +std::tuple +RasterizeMeshes( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int faces_per_pixel, + int bin_size, + int max_faces_per_bin, + bool perspective_correct) { + if (bin_size > 0 && max_faces_per_bin > 0) { + // Use coarse-to-fine rasterization + auto bin_faces = RasterizeMeshesCoarse( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin); + return RasterizeMeshesFine( + face_verts, + bin_faces, + image_size, + blur_radius, + bin_size, + faces_per_pixel, + perspective_correct); + } else { + // Use the naive per-pixel implementation + return RasterizeMeshesNaive( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + faces_per_pixel, + perspective_correct); + } +} diff --git a/pytorch3d/csrc/rasterize_meshes/rasterize_meshes_cpu.cpp b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes_cpu.cpp new file mode 100644 index 00000000..813758bb --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/rasterize_meshes_cpu.cpp @@ -0,0 +1,471 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include +#include +#include +#include "geometry_utils.h" +#include "vec2.h" +#include "vec3.h" + +float PixToNdc(int i, int S) { + // NDC x-offset + (i * pixel_width + half_pixel_width) + return -1 + (2 * i + 1.0f) / S; +} + +// Get (x, y, z) values for vertex from (3, 3) tensor face. +template +auto ExtractVerts(const Face& face, const int vertex_index) { + return std::make_tuple( + face[vertex_index][0], face[vertex_index][1], face[vertex_index][2]); +} + +// Compute min/max x/y for each face. +auto ComputeFaceBoundingBoxes(const torch::Tensor& face_verts) { + const int total_F = face_verts.size(0); + auto float_opts = face_verts.options().dtype(torch::kFloat32); + auto face_verts_a = face_verts.accessor(); + torch::Tensor face_bboxes = torch::full({total_F, 6}, -2.0, float_opts); + + // Loop through all the faces + for (int f = 0; f < total_F; ++f) { + const auto& face = face_verts_a[f]; + float x0, x1, x2, y0, y1, y2, z0, z1, z2; + std::tie(x0, y0, z0) = ExtractVerts(face, 0); + std::tie(x1, y1, z1) = ExtractVerts(face, 1); + std::tie(x2, y2, z2) = ExtractVerts(face, 2); + + const float x_min = std::min(x0, std::min(x1, x2)); + const float y_min = std::min(y0, std::min(y1, y2)); + const float x_max = std::max(x0, std::max(x1, x2)); + const float y_max = std::max(y0, std::max(y1, y2)); + const float z_min = std::min(z0, std::min(z1, z2)); + const float z_max = std::max(z0, std::max(z1, z2)); + + face_bboxes[f][0] = x_min; + face_bboxes[f][1] = y_min; + face_bboxes[f][2] = x_max; + face_bboxes[f][3] = y_max; + face_bboxes[f][4] = z_min; + face_bboxes[f][5] = z_max; + } + + return face_bboxes; +} + +// Check if the point (px, py) lies inside the face bounding box face_bbox. +// Return true if the point is outside. +template +bool CheckPointOutsideBoundingBox( + const Face& face_bbox, + float blur_radius, + float px, + float py) { + // Read triangle bbox coordinates and expand by blur radius. + float x_min = face_bbox[0] - blur_radius; + float y_min = face_bbox[1] - blur_radius; + float x_max = face_bbox[2] + blur_radius; + float y_max = face_bbox[3] + blur_radius; + + // Check if the current point is within the triangle bounding box. + return (px > x_max || px < x_min || py > y_max || py < y_min); +} + +// Calculate areas of all faces. Returns a tensor of shape (total_faces, 1) +// where faces with zero area have value -1. +auto ComputeFaceAreas(const torch::Tensor& face_verts) { + const int total_F = face_verts.size(0); + auto float_opts = face_verts.options().dtype(torch::kFloat32); + auto face_verts_a = face_verts.accessor(); + torch::Tensor face_areas = torch::full({total_F}, -1, float_opts); + + // Loop through all the faces + for (int f = 0; f < total_F; ++f) { + const auto& face = face_verts_a[f]; + float x0, x1, x2, y0, y1, y2, z0, z1, z2; + std::tie(x0, y0, z0) = ExtractVerts(face, 0); + std::tie(x1, y1, z1) = ExtractVerts(face, 1); + std::tie(x2, y2, z2) = ExtractVerts(face, 2); + + const vec2 v0(x0, y0); + const vec2 v1(x1, y1); + const vec2 v2(x2, y2); + + const float face_area = EdgeFunctionForward(v0, v1, v2); + face_areas[f] = face_area; + } + + return face_areas; +} + +std::tuple +RasterizeMeshesNaiveCpu( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int faces_per_pixel, + bool perspective_correct) { + if (face_verts.ndimension() != 3 || face_verts.size(1) != 3 || + face_verts.size(2) != 3) { + AT_ERROR("face_verts must have dimensions (num_faces, 3, 3)"); + } + if (num_faces_per_mesh.size(0) != mesh_to_face_first_idx.size(0)) { + AT_ERROR( + "num_faces_per_mesh must have save size first dimension as mesh_to_face_first_idx"); + } + + const int32_t N = mesh_to_face_first_idx.size(0); // batch_size. + const int H = image_size; + const int W = image_size; + const int K = faces_per_pixel; + + auto long_opts = face_verts.options().dtype(torch::kInt64); + auto float_opts = face_verts.options().dtype(torch::kFloat32); + + // Initialize output tensors. + torch::Tensor face_idxs = torch::full({N, H, W, K}, -1, long_opts); + torch::Tensor zbuf = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, H, W, K}, -1, float_opts); + torch::Tensor barycentric_coords = + torch::full({N, H, W, K, 3}, -1, float_opts); + + auto face_verts_a = face_verts.accessor(); + auto face_idxs_a = face_idxs.accessor(); + auto zbuf_a = zbuf.accessor(); + auto pix_dists_a = pix_dists.accessor(); + auto barycentric_coords_a = barycentric_coords.accessor(); + + auto face_bboxes = ComputeFaceBoundingBoxes(face_verts); + auto face_bboxes_a = face_bboxes.accessor(); + auto face_areas = ComputeFaceAreas(face_verts); + auto face_areas_a = face_areas.accessor(); + + for (int n = 0; n < N; ++n) { + // Loop through each mesh in the batch. + // Get the start index of the faces in faces_packed and the num faces + // in the mesh to avoid having to loop through all the faces. + const int face_start_idx = mesh_to_face_first_idx[n].item().to(); + const int face_stop_idx = + (face_start_idx + num_faces_per_mesh[n].item().to()); + + // Iterate through the horizontal lines of the image from top to bottom. + for (int yi = 0; yi < H; ++yi) { + // Y coordinate of the top of the pixel. + const float yf = PixToNdc(yi, H); + // Iterate through pixels on this horizontal line, left to right. + for (int xi = 0; xi < W; ++xi) { + // X coordinate of the left of the pixel. + const float xf = PixToNdc(xi, W); + // Use a priority queue to hold values: + // (z, idx, r, bary.x, bary.y. bary.z) + std::priority_queue> + q; + + // Loop through the faces in the mesh. + for (int f = face_start_idx; f < face_stop_idx; ++f) { + // Get coordinates of three face vertices. + const auto& face = face_verts_a[f]; + float x0, x1, x2, y0, y1, y2, z0, z1, z2; + std::tie(x0, y0, z0) = ExtractVerts(face, 0); + std::tie(x1, y1, z1) = ExtractVerts(face, 1); + std::tie(x2, y2, z2) = ExtractVerts(face, 2); + + const vec2 v0(x0, y0); + const vec2 v1(x1, y1); + const vec2 v2(x2, y2); + + // Skip faces with zero area. + const float face_area = face_areas_a[f]; + if (face_area <= kEpsilon && face_area >= -1.0f * kEpsilon) { + continue; + } + + // Skip if point is outside the face bounding box. + const auto face_bbox = face_bboxes_a[f]; + const bool outside_bbox = CheckPointOutsideBoundingBox( + face_bbox, std::sqrt(blur_radius), xf, yf); + if (outside_bbox) { + continue; + } + + // Compute barycentric coordinates and use this to get the + // depth of the point on the triangle. + const vec2 pxy(xf, yf); + const vec3 bary0 = + BarycentricCoordinatesForward(pxy, v0, v1, v2); + const vec3 bary = !perspective_correct + ? bary0 + : BarycentricPerspectiveCorrectionForward(bary0, z0, z1, z2); + + // Use barycentric coordinates to get the depth of the current pixel + const float pz = (bary.x * z0 + bary.y * z1 + bary.z * z2); + + if (pz < 0) { + continue; // Point is behind the image plane so ignore. + } + + // Compute absolute distance of the point to the triangle. + // If the point is inside the triangle then the distance + // is negative. + const float dist = PointTriangleDistanceForward(pxy, v0, v1, v2); + + // Use the bary coordinates to determine if the point is + // inside the face. + const bool inside = bary.x > 0.0f && bary.y > 0.0f && bary.z > 0.0f; + const float signed_dist = inside ? -dist : dist; + + // Check if pixel is outside blur region + if (!inside && dist >= blur_radius) { + continue; + } + // The current pixel lies inside the current face. + q.emplace(pz, f, signed_dist, bary.x, bary.y, bary.z); + if (static_cast(q.size()) > K) { + q.pop(); + } + } + while (!q.empty()) { + auto t = q.top(); + q.pop(); + const int i = q.size(); + zbuf_a[n][yi][xi][i] = std::get<0>(t); + face_idxs_a[n][yi][xi][i] = std::get<1>(t); + pix_dists_a[n][yi][xi][i] = std::get<2>(t); + barycentric_coords_a[n][yi][xi][i][0] = std::get<3>(t); + barycentric_coords_a[n][yi][xi][i][1] = std::get<4>(t); + barycentric_coords_a[n][yi][xi][i][2] = std::get<5>(t); + } + } + } + } + return std::make_tuple(face_idxs, zbuf, barycentric_coords, pix_dists); +} + +torch::Tensor RasterizeMeshesBackwardCpu( + const torch::Tensor& face_verts, // (F, 3, 3) + const torch::Tensor& pix_to_face, // (N, H, W, K) + const torch::Tensor& grad_zbuf, // (N, H, W, K) + const torch::Tensor& grad_bary, // (N, H, W, K, 3) + const torch::Tensor& grad_dists, // (N, H, W, K) + bool perspective_correct) { + const int F = face_verts.size(0); + const int N = pix_to_face.size(0); + const int H = pix_to_face.size(1); + const int W = pix_to_face.size(2); + const int K = pix_to_face.size(3); + + torch::Tensor grad_face_verts = torch::zeros({F, 3, 3}, face_verts.options()); + auto face_verts_a = face_verts.accessor(); + auto pix_to_face_a = pix_to_face.accessor(); + auto grad_dists_a = grad_dists.accessor(); + auto grad_zbuf_a = grad_zbuf.accessor(); + auto grad_bary_a = grad_bary.accessor(); + + for (int n = 0; n < N; ++n) { + // Iterate through the horizontal lines of the image from top to bottom. + for (int y = 0; y < H; ++y) { + // Y coordinate of the top of the pixel. + const float yf = PixToNdc(y, H); + // Iterate through pixels on this horizontal line, left to right. + for (int x = 0; x < W; ++x) { + // X coordinate of the left of the pixel. + const float xf = PixToNdc(x, W); + const vec2 pxy(xf, yf); + + // Iterate through the faces that hit this pixel. + for (int k = 0; k < K; ++k) { + // Get face index from forward pass output. + const int f = pix_to_face_a[n][y][x][k]; + if (f < 0) { + continue; // padded face. + } + // Get coordinates of the three face vertices. + const auto face_verts_f = face_verts_a[f]; + const float x0 = face_verts_f[0][0]; + const float y0 = face_verts_f[0][1]; + const float z0 = face_verts_f[0][2]; + const float x1 = face_verts_f[1][0]; + const float y1 = face_verts_f[1][1]; + const float z1 = face_verts_f[1][2]; + const float x2 = face_verts_f[2][0]; + const float y2 = face_verts_f[2][1]; + const float z2 = face_verts_f[2][2]; + const vec2 v0xy(x0, y0); + const vec2 v1xy(x1, y1); + const vec2 v2xy(x2, y2); + + // Get upstream gradients for the face. + const float grad_dist_upstream = grad_dists_a[n][y][x][k]; + const float grad_zbuf_upstream = grad_zbuf_a[n][y][x][k]; + const auto grad_bary_upstream_w012 = grad_bary_a[n][y][x][k]; + const float grad_bary_upstream_w0 = grad_bary_upstream_w012[0]; + const float grad_bary_upstream_w1 = grad_bary_upstream_w012[1]; + const float grad_bary_upstream_w2 = grad_bary_upstream_w012[2]; + const vec3 grad_bary_upstream( + grad_bary_upstream_w0, + grad_bary_upstream_w1, + grad_bary_upstream_w2); + + const vec3 bary0 = + BarycentricCoordinatesForward(pxy, v0xy, v1xy, v2xy); + const vec3 bary = !perspective_correct + ? bary0 + : BarycentricPerspectiveCorrectionForward(bary0, z0, z1, z2); + + // Distances inside the face are negative so get the + // correct sign to apply to the upstream gradient. + const bool inside = bary.x > 0.0f && bary.y > 0.0f && bary.z > 0.0f; + const float sign = inside ? -1.0f : 1.0f; + + // TODO(T52813608) Add support for non-square images. + const auto grad_dist_f = PointTriangleDistanceBackward( + pxy, v0xy, v1xy, v2xy, sign * grad_dist_upstream); + const auto ddist_d_v0 = std::get<1>(grad_dist_f); + const auto ddist_d_v1 = std::get<2>(grad_dist_f); + const auto ddist_d_v2 = std::get<3>(grad_dist_f); + + // Upstream gradient for barycentric coords from zbuf calculation: + // zbuf = bary_w0 * z0 + bary_w1 * z1 + bary_w2 * z2 + // Therefore + // d_zbuf/d_bary_w0 = z0 + // d_zbuf/d_bary_w1 = z1 + // d_zbuf/d_bary_w2 = z2 + const vec3 d_zbuf_d_bary(z0, z1, z2); + + // Total upstream barycentric gradients are the sum of + // external upstream gradients and contribution from zbuf. + vec3 grad_bary_f_sum = + (grad_bary_upstream + grad_zbuf_upstream * d_zbuf_d_bary); + + vec3 grad_bary0 = grad_bary_f_sum; + if (perspective_correct) { + auto perspective_grads = BarycentricPerspectiveCorrectionBackward( + bary0, z0, z1, z2, grad_bary_f_sum); + grad_bary0 = std::get<0>(perspective_grads); + grad_face_verts[f][0][2] += std::get<1>(perspective_grads); + grad_face_verts[f][1][2] += std::get<2>(perspective_grads); + grad_face_verts[f][2][2] += std::get<3>(perspective_grads); + } + auto grad_bary_f = + BarycentricCoordsBackward(pxy, v0xy, v1xy, v2xy, grad_bary0); + const vec2 dbary_d_v0 = std::get<1>(grad_bary_f); + const vec2 dbary_d_v1 = std::get<2>(grad_bary_f); + const vec2 dbary_d_v2 = std::get<3>(grad_bary_f); + + // Update output gradient buffer. + grad_face_verts[f][0][0] += dbary_d_v0.x + ddist_d_v0.x; + grad_face_verts[f][0][1] += dbary_d_v0.y + ddist_d_v0.y; + grad_face_verts[f][0][2] += grad_zbuf_upstream * bary.x; + grad_face_verts[f][1][0] += dbary_d_v1.x + ddist_d_v1.x; + grad_face_verts[f][1][1] += dbary_d_v1.y + ddist_d_v1.y; + grad_face_verts[f][1][2] += grad_zbuf_upstream * bary.y; + grad_face_verts[f][2][0] += dbary_d_v2.x + ddist_d_v2.x; + grad_face_verts[f][2][1] += dbary_d_v2.y + ddist_d_v2.y; + grad_face_verts[f][2][2] += grad_zbuf_upstream * bary.z; + } + } + } + } + return grad_face_verts; +} + +torch::Tensor RasterizeMeshesCoarseCpu( + const torch::Tensor& face_verts, + const torch::Tensor& mesh_to_face_first_idx, + const torch::Tensor& num_faces_per_mesh, + int image_size, + float blur_radius, + int bin_size, + int max_faces_per_bin) { + if (face_verts.ndimension() != 3 || face_verts.size(1) != 3 || + face_verts.size(2) != 3) { + AT_ERROR("face_verts must have dimensions (num_faces, 3, 3)"); + } + if (num_faces_per_mesh.ndimension() != 1) { + AT_ERROR("num_faces_per_mesh can only have one dimension"); + } + const int N = num_faces_per_mesh.size(0); // batch size. + const int M = max_faces_per_bin; + + // Assume square images. TODO(T52813608) Support non square images. + const float height = image_size; + const float width = image_size; + const int BH = 1 + (height - 1) / bin_size; // Integer division round up. + const int BW = 1 + (width - 1) / bin_size; // Integer division round up. + + auto opts = face_verts.options().dtype(torch::kInt32); + torch::Tensor faces_per_bin = torch::zeros({N, BH, BW}, opts); + torch::Tensor bin_faces = torch::full({N, BH, BW, M}, -1, opts); + auto faces_per_bin_a = faces_per_bin.accessor(); + auto bin_faces_a = bin_faces.accessor(); + + // Precompute all face bounding boxes. + auto face_bboxes = ComputeFaceBoundingBoxes(face_verts); + auto face_bboxes_a = face_bboxes.accessor(); + + const float pixel_width = 2.0f / image_size; + const float bin_width = pixel_width * bin_size; + + // Iterate through the meshes in the batch. + for (int n = 0; n < N; ++n) { + const int face_start_idx = mesh_to_face_first_idx[n].item().to(); + const int face_stop_idx = + (face_start_idx + num_faces_per_mesh[n].item().to()); + + float bin_y_min = -1.0f; + float bin_y_max = bin_y_min + bin_width; + + // Iterate through the horizontal bins from top to bottom. + for (int by = 0; by < BH; ++by) { + float bin_x_min = -1.0f; + float bin_x_max = bin_x_min + bin_width; + + // Iterate through bins on this horizontal line, left to right. + for (int bx = 0; bx < BW; ++bx) { + int32_t faces_hit = 0; + + for (int32_t f = face_start_idx; f < face_stop_idx; ++f) { + // Get bounding box and expand by blur radius. + float face_x_min = face_bboxes_a[f][0] - std::sqrt(blur_radius); + float face_y_min = face_bboxes_a[f][1] - std::sqrt(blur_radius); + float face_x_max = face_bboxes_a[f][2] + std::sqrt(blur_radius); + float face_y_max = face_bboxes_a[f][3] + std::sqrt(blur_radius); + float face_z_max = face_bboxes_a[f][5]; + + if (face_z_max < 0) { + continue; // Face is behind the camera. + } + + // Use a half-open interval so that faces exactly on the + // boundary between bins will fall into exactly one bin. + bool x_overlap = + (face_x_min <= bin_x_max) && (bin_x_min < face_x_max); + bool y_overlap = + (face_y_min <= bin_y_max) && (bin_y_min < face_y_max); + + if (x_overlap && y_overlap) { + // Got too many faces for this bin, so throw an error. + if (faces_hit >= max_faces_per_bin) { + AT_ERROR("Got too many faces per bin"); + } + // The current point falls in the current bin, so + // record it. + bin_faces_a[n][by][bx][faces_hit] = f; + faces_hit++; + } + } + + // Shift the bin to the right for the next loop iteration. + bin_x_min = bin_x_max; + bin_x_max = bin_x_min + bin_width; + } + // Shift the bin down for the next loop iteration. + bin_y_min = bin_y_max; + bin_y_max = bin_y_min + bin_width; + } + } + return bin_faces; +} diff --git a/pytorch3d/csrc/rasterize_meshes/vec2.h b/pytorch3d/csrc/rasterize_meshes/vec2.h new file mode 100644 index 00000000..8f1b7fc4 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/vec2.h @@ -0,0 +1,59 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include + +// A fixed-sized vector with basic arithmetic operators useful for +// representing 2D coordinates. +// TODO: switch to Eigen if more functionality is needed. + +template < + typename T, + typename = std::enable_if_t< + std::is_same::value || std::is_same::value>> +struct vec2 { + T x, y; + typedef T scalar_t; + vec2(T x, T y) : x(x), y(y) {} +}; + +template +inline vec2 operator+(const vec2& a, const vec2& b) { + return vec2(a.x + b.x, a.y + b.y); +} + +template +inline vec2 operator-(const vec2& a, const vec2& b) { + return vec2(a.x - b.x, a.y - b.y); +} + +template +inline vec2 operator*(const T a, const vec2& b) { + return vec2(a * b.x, a * b.y); +} + +template +inline vec2 operator/(const vec2& a, const T b) { + if (b == 0.0) { + AT_ERROR( + "denominator in vec2 division is 0"); // prevent divide by 0 errors. + } + return vec2(a.x / b, a.y / b); +} + +template +inline T dot(const vec2& a, const vec2& b) { + return a.x * b.x + a.y * b.y; +} + +template +inline T norm(const vec2& a, const vec2& b) { + const vec2 ba = b - a; + return sqrt(dot(ba, ba)); +} + +template +std::ostream& operator<<(std::ostream& os, const vec2& v) { + os << "vec2(" << v.x << ", " << v.y << ")"; + return os; +} diff --git a/pytorch3d/csrc/rasterize_meshes/vec3.h b/pytorch3d/csrc/rasterize_meshes/vec3.h new file mode 100644 index 00000000..6ab43d13 --- /dev/null +++ b/pytorch3d/csrc/rasterize_meshes/vec3.h @@ -0,0 +1,63 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once + +// A fixed-sized vector with basic arithmetic operators useful for +// representing 3D coordinates. +// TODO: switch to Eigen if more functionality is needed. + +template < + typename T, + typename = std::enable_if_t< + std::is_same::value || std::is_same::value>> +struct vec3 { + T x, y, z; + typedef T scalar_t; + vec3(T x, T y, T z) : x(x), y(y), z(z) {} +}; + +template +inline vec3 operator+(const vec3& a, const vec3& b) { + return vec3(a.x + b.x, a.y + b.y, a.z + b.z); +} + +template +inline vec3 operator-(const vec3& a, const vec3& b) { + return vec3(a.x - b.x, a.y - b.y, a.z - b.z); +} + +template +inline vec3 operator/(const vec3& a, const T b) { + if (b == 0.0) { + AT_ERROR( + "denominator in vec3 division is 0"); // prevent divide by 0 errors. + } + return vec3(a.x / b, a.y / b, a.z / b); +} + +template +inline vec3 operator*(const T a, const vec3& b) { + return vec3(a * b.x, a * b.y, a * b.z); +} + +template +inline vec3 operator*(const vec3& a, const vec3& b) { + return vec3(a.x * b.x, a.y * b.y, a.z * b.z); +} + +template +inline T dot(const vec3& a, const vec3& b) { + return a.x * b.x + a.y * b.y + a.z * b.z; +} + +template +inline vec3 cross(const vec3& a, const vec3& b) { + return vec3( + a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x); +} + +template +std::ostream& operator<<(std::ostream& os, const vec3& v) { + os << "vec3(" << v.x << ", " << v.y << ", " << v.z << ")"; + return os; +} diff --git a/pytorch3d/csrc/rasterize_points/bitmask.cuh b/pytorch3d/csrc/rasterize_points/bitmask.cuh new file mode 100644 index 00000000..b72ce810 --- /dev/null +++ b/pytorch3d/csrc/rasterize_points/bitmask.cuh @@ -0,0 +1,73 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#define BINMASK_H + +// A BitMask represents a bool array of shape (H, W, N). We pack values into +// the bits of unsigned ints; a single unsigned int has B = 32 bits, so to hold +// all values we use H * W * (N / B) = H * W * D values. We want to store +// BitMasks in shared memory, so we assume that the memory has already been +// allocated for it elsewhere. +class BitMask { + public: + __device__ BitMask(unsigned int* data, int H, int W, int N) + : data(data), H(H), W(W), B(8 * sizeof(unsigned int)), D(N / B) { + // TODO: check if the data is null. + N = ceilf(N % 32); // take ceil incase N % 32 != 0 + block_clear(); // clear the data + } + + // Use all threads in the current block to clear all bits of this BitMask + __device__ void block_clear() { + for (int i = threadIdx.x; i < H * W * D; i += blockDim.x) { + data[i] = 0; + } + __syncthreads(); + } + + __device__ int _get_elem_idx(int y, int x, int d) { + return y * W * D + x * D + d / B; + } + + __device__ int _get_bit_idx(int d) { + return d % B; + } + + // Turn on a single bit (y, x, d) + __device__ void set(int y, int x, int d) { + int elem_idx = _get_elem_idx(y, x, d); + int bit_idx = _get_bit_idx(d); + const unsigned int mask = 1U << bit_idx; + atomicOr(data + elem_idx, mask); + } + + // Turn off a single bit (y, x, d) + __device__ void unset(int y, int x, int d) { + int elem_idx = _get_elem_idx(y, x, d); + int bit_idx = _get_bit_idx(d); + const unsigned int mask = ~(1U << bit_idx); + atomicAnd(data + elem_idx, mask); + } + + // Check whether the bit (y, x, d) is on or off + __device__ bool get(int y, int x, int d) { + int elem_idx = _get_elem_idx(y, x, d); + int bit_idx = _get_bit_idx(d); + return (data[elem_idx] >> bit_idx) & 1U; + } + + // Compute the number of bits set in the row (y, x, :) + __device__ int count(int y, int x) { + int total = 0; + for (int i = 0; i < D; ++i) { + int elem_idx = y * W * D + x * D + i; + unsigned int elem = data[elem_idx]; + total += __popc(elem); + } + return total; + } + + private: + unsigned int* data; + int H, W, B, D; +}; diff --git a/pytorch3d/csrc/rasterize_points/rasterization_utils.cuh b/pytorch3d/csrc/rasterize_points/rasterization_utils.cuh new file mode 100644 index 00000000..45fdda26 --- /dev/null +++ b/pytorch3d/csrc/rasterize_points/rasterization_utils.cuh @@ -0,0 +1,33 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once + +// Given a pixel coordinate 0 <= i < S, convert it to a normalized device +// coordinate in the range [-1, 1]. We divide the NDC range into S evenly-sized +// pixels, and assume that each pixel falls in the *center* of its range. +__device__ inline float PixToNdc(int i, int S) { + // NDC x-offset + (i * pixel_width + half_pixel_width) + return -1 + (2 * i + 1.0f) / S; +} + +// The maximum number of points per pixel that we can return. Since we use +// thread-local arrays to hold and sort points, the maximum size of the array +// needs to be known at compile time. There might be some fancy template magic +// we could use to make this more dynamic, but for now just fix a constant. +// TODO: is 8 enough? Would increasing have performance considerations? +const int32_t kMaxPointsPerPixel = 150; + +template +__device__ inline void BubbleSort(T* arr, int n) { + // Bubble sort. We only use it for tiny thread-local arrays (n < 8); in this + // regime we care more about warp divergence than computational complexity. + for (int i = 0; i < n - 1; ++i) { + for (int j = 0; j < n - i - 1; ++j) { + if (arr[j + 1] < arr[j]) { + T temp = arr[j]; + arr[j] = arr[j + 1]; + arr[j + 1] = temp; + } + } + } +} diff --git a/pytorch3d/csrc/rasterize_points/rasterize_points.cu b/pytorch3d/csrc/rasterize_points/rasterize_points.cu new file mode 100644 index 00000000..4dde4699 --- /dev/null +++ b/pytorch3d/csrc/rasterize_points/rasterize_points.cu @@ -0,0 +1,511 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include +#include +#include +#include "rasterize_points/bitmask.cuh" +#include "rasterize_points/rasterization_utils.cuh" + +namespace { +// A little structure for holding details about a pixel. +struct Pix { + float z; // Depth of the reference point. + int32_t idx; // Index of the reference point. + float dist2; // Euclidean distance square to the reference point. +}; + +__device__ inline bool operator<(const Pix& a, const Pix& b) { + return a.z < b.z; +} + +// This function checks if a pixel given by xy location pxy lies within the +// point with index p and batch index n. One of the inputs is a list (q) +// which contains Pixel structs with the indices of the points which intersect +// with this pixel sorted by closest z distance. If the pixel pxy lies in the +// point, the list (q) is updated and re-orderered in place. In addition +// the auxillary variables q_size, q_max_z and q_max_idx are also modified. +// This code is shared between RasterizePointsNaiveCudaKernel and +// RasterizePointsFineCudaKernel. +template +__device__ void CheckPixelInsidePoint( + const float* points, // (N, P, 3) + const int p, + int& q_size, + float& q_max_z, + int& q_max_idx, + PointQ& q, + const float radius2, + const float xf, + const float yf, + const int n, + const int P, + const int K) { + const float px = points[n * P * 3 + p * 3 + 0]; + const float py = points[n * P * 3 + p * 3 + 1]; + const float pz = points[n * P * 3 + p * 3 + 2]; + if (pz < 0) + return; // Don't render points behind the camera + const float dx = xf - px; + const float dy = yf - py; + const float dist2 = dx * dx + dy * dy; + if (dist2 < radius2) { + if (q_size < K) { + // Just insert it + q[q_size] = {pz, p, dist2}; + if (pz > q_max_z) { + q_max_z = pz; + q_max_idx = q_size; + } + q_size++; + } else if (pz < q_max_z) { + // Overwrite the old max, and find the new max + q[q_max_idx] = {pz, p, dist2}; + q_max_z = pz; + for (int i = 0; i < K; i++) { + if (q[i].z > q_max_z) { + q_max_z = q[i].z; + q_max_idx = i; + } + } + } + } +} +} // namespace +// **************************************************************************** +// * NAIVE RASTERIZATION * +// **************************************************************************** + +__global__ void RasterizePointsNaiveCudaKernel( + const float* points, // (N, P, 3) + const float radius, + const int N, + const int P, + const int S, + const int K, + int32_t* point_idxs, // (N, S, S, K) + float* zbuf, // (N, S, S, K) + float* pix_dists) { // (N, S, S, K) + // Simple version: One thread per output pixel + const int num_threads = gridDim.x * blockDim.x; + const int tid = blockDim.x * blockIdx.x + threadIdx.x; + const float radius2 = radius * radius; + for (int i = tid; i < N * S * S; i += num_threads) { + // Convert linear index to 3D index + const int n = i / (S * S); // Batch index + const int pix_idx = i % (S * S); + const int yi = pix_idx / S; + const int xi = pix_idx % S; + + const float xf = PixToNdc(xi, S); + const float yf = PixToNdc(yi, S); + + // For keeping track of the K closest points we want a data structure + // that (1) gives O(1) access to the closest point for easy comparisons, + // and (2) allows insertion of new elements. In the CPU version we use + // std::priority_queue; then (2) is O(log K). We can't use STL + // containers in CUDA; we could roll our own max heap in an array, but + // that would likely have a lot of warp divergence so we do something + // simpler instead: keep the elements in an unsorted array, but keep + // track of the max value and the index of the max value. Then (1) is + // still O(1) time, while (2) is O(K) with a clean loop. Since K <= 8 + // this should be fast enough for our purposes. + // TODO(jcjohns) Abstract this out into a standalone data structure + Pix q[kMaxPointsPerPixel]; + int q_size = 0; + float q_max_z = -1000; + int q_max_idx = -1; + for (int p = 0; p < P; ++p) { + CheckPixelInsidePoint( + points, p, q_size, q_max_z, q_max_idx, q, radius2, xf, yf, n, P, K); + } + BubbleSort(q, q_size); + int idx = n * S * S * K + yi * S * K + xi * K; + for (int k = 0; k < q_size; ++k) { + point_idxs[idx + k] = q[k].idx; + zbuf[idx + k] = q[k].z; + pix_dists[idx + k] = q[k].dist2; + } + } +} + +std::tuple +RasterizePointsNaiveCuda( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel) { + const int N = points.size(0); + const int P = points.size(1); + const int S = image_size; + const int K = points_per_pixel; + if (K > kMaxPointsPerPixel) { + std::stringstream ss; + ss << "Must have points_per_pixel <= " << kMaxPointsPerPixel; + AT_ERROR(ss.str()); + } + + auto int_opts = points.options().dtype(torch::kInt32); + auto float_opts = points.options().dtype(torch::kFloat32); + torch::Tensor point_idxs = torch::full({N, S, S, K}, -1, int_opts); + torch::Tensor zbuf = torch::full({N, S, S, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, S, S, K}, -1, float_opts); + + const size_t blocks = 1024; + const size_t threads = 64; + RasterizePointsNaiveCudaKernel<<>>( + points.contiguous().data(), + radius, + N, + P, + S, + K, + point_idxs.contiguous().data(), + zbuf.contiguous().data(), + pix_dists.contiguous().data()); + return std::make_tuple(point_idxs, zbuf, pix_dists); +} + +// **************************************************************************** +// * COARSE RASTERIZATION * +// **************************************************************************** + +__global__ void RasterizePointsCoarseCudaKernel( + const float* points, + const float radius, + const int N, + const int P, + const int S, + const int bin_size, + const int chunk_size, + const int max_points_per_bin, + int* points_per_bin, + int* bin_points) { + extern __shared__ char sbuf[]; + const int M = max_points_per_bin; + const int num_bins = 1 + (S - 1) / bin_size; // Integer divide round up + const float half_pix = 1.0f / S; // Size of half a pixel in NDC units + + // This is a boolean array of shape (num_bins, num_bins, chunk_size) + // stored in shared memory that will track whether each point in the chunk + // falls into each bin of the image. + BitMask binmask((unsigned int*)sbuf, num_bins, num_bins, chunk_size); + + // Have each block handle a chunk of points and build a 3D bitmask in + // shared memory to mark which points hit which bins. In this first phase, + // each thread processes one point at a time. After processing the chunk, + // one thread is assigned per bin, and the thread counts and writes the + // points for the bin out to global memory. + const int chunks_per_batch = 1 + (P - 1) / chunk_size; + const int num_chunks = N * chunks_per_batch; + for (int chunk = blockIdx.x; chunk < num_chunks; chunk += gridDim.x) { + const int batch_idx = chunk / chunks_per_batch; + const int chunk_idx = chunk % chunks_per_batch; + const int point_start_idx = chunk_idx * chunk_size; + + binmask.block_clear(); + + // Have each thread handle a different point within the chunk + for (int p = threadIdx.x; p < chunk_size; p += blockDim.x) { + const int p_idx = point_start_idx + p; + if (p_idx >= P) + break; + const float px = points[batch_idx * P * 3 + p_idx * 3 + 0]; + const float py = points[batch_idx * P * 3 + p_idx * 3 + 1]; + const float pz = points[batch_idx * P * 3 + p_idx * 3 + 2]; + if (pz < 0) + continue; // Don't render points behind the camera + const float px0 = px - radius; + const float px1 = px + radius; + const float py0 = py - radius; + const float py1 = py + radius; + + // Brute-force search over all bins; TODO something smarter? + // For example we could compute the exact bin where the point falls, + // then check neighboring bins. This way we wouldn't have to check + // all bins (however then we might have more warp divergence?) + for (int by = 0; by < num_bins; ++by) { + // Get y extent for the bin. PixToNdc gives us the location of + // the center of each pixel, so we need to add/subtract a half + // pixel to get the true extent of the bin. + const float by0 = PixToNdc(by * bin_size, S) - half_pix; + const float by1 = PixToNdc((by + 1) * bin_size - 1, S) + half_pix; + const bool y_overlap = (py0 <= by1) && (by0 <= py1); + if (!y_overlap) { + continue; + } + for (int bx = 0; bx < num_bins; ++bx) { + // Get x extent for the bin; again we need to adjust the + // output of PixToNdc by half a pixel. + const float bx0 = PixToNdc(bx * bin_size, S) - half_pix; + const float bx1 = PixToNdc((bx + 1) * bin_size - 1, S) + half_pix; + const bool x_overlap = (px0 <= bx1) && (bx0 <= px1); + if (x_overlap) { + binmask.set(by, bx, p); + } + } + } + } + __syncthreads(); + // Now we have processed every point in the current chunk. We need to + // count the number of points in each bin so we can write the indices + // out to global memory. We have each thread handle a different bin. + for (int byx = threadIdx.x; byx < num_bins * num_bins; byx += blockDim.x) { + const int by = byx / num_bins; + const int bx = byx % num_bins; + const int count = binmask.count(by, bx); + const int points_per_bin_idx = + batch_idx * num_bins * num_bins + by * num_bins + bx; + + // This atomically increments the (global) number of points found + // in the current bin, and gets the previous value of the counter; + // this effectively allocates space in the bin_points array for the + // points in the current chunk that fall into this bin. + const int start = atomicAdd(points_per_bin + points_per_bin_idx, count); + + // Now loop over the binmask and write the active bits for this bin + // out to bin_points. + int next_idx = batch_idx * num_bins * num_bins * M + by * num_bins * M + + bx * M + start; + for (int p = 0; p < chunk_size; ++p) { + if (binmask.get(by, bx, p)) { + // TODO: Throw an error if next_idx >= M -- this means that + // we got more than max_points_per_bin in this bin + // TODO: check if atomicAdd is needed in line 265. + bin_points[next_idx] = point_start_idx + p; + next_idx++; + } + } + } + __syncthreads(); + } +} + +torch::Tensor RasterizePointsCoarseCuda( + const torch::Tensor& points, + const int image_size, + const float radius, + const int bin_size, + const int max_points_per_bin) { + const int N = points.size(0); + const int P = points.size(1); + const int num_bins = 1 + (image_size - 1) / bin_size; // divide round up + const int M = max_points_per_bin; + if (num_bins >= 22) { + // Make sure we do not use too much shared memory. + std::stringstream ss; + ss << "Got " << num_bins << "; that's too many!"; + AT_ERROR(ss.str()); + } + auto opts = points.options().dtype(torch::kInt32); + torch::Tensor points_per_bin = torch::zeros({N, num_bins, num_bins}, opts); + torch::Tensor bin_points = torch::full({N, num_bins, num_bins, M}, -1, opts); + const int chunk_size = 512; + const size_t shared_size = num_bins * num_bins * chunk_size / 8; + const size_t blocks = 64; + const size_t threads = 512; + RasterizePointsCoarseCudaKernel<<>>( + points.contiguous().data(), + radius, + N, + P, + image_size, + bin_size, + chunk_size, + M, + points_per_bin.contiguous().data(), + bin_points.contiguous().data()); + return bin_points; +} + +// **************************************************************************** +// * FINE RASTERIZATION * +// **************************************************************************** + +__global__ void RasterizePointsFineCudaKernel( + const float* points, // (N, P, 3) + const int32_t* bin_points, // (N, B, B, T) + const float radius, + const int bin_size, + const int N, + const int P, + const int B, + const int M, + const int S, + const int K, + int32_t* point_idxs, // (N, S, S, K) + float* zbuf, // (N, S, S, K) + float* pix_dists) { // (N, S, S, K) + // This can be more than S^2 if S is not dividable by bin_size. + const int num_pixels = N * B * B * bin_size * bin_size; + const int num_threads = gridDim.x * blockDim.x; + const int tid = blockIdx.x * blockDim.x + threadIdx.x; + const float radius2 = radius * radius; + for (int pid = tid; pid < num_pixels; pid += num_threads) { + // Convert linear index into bin and pixel indices. We make the within + // block pixel ids move the fastest, so that adjacent threads will fall + // into the same bin; this should give them coalesced memory reads when + // they read from points and bin_points. + int i = pid; + const int n = i / (B * B * bin_size * bin_size); + i %= B * B * bin_size * bin_size; + const int by = i / (B * bin_size * bin_size); + i %= B * bin_size * bin_size; + const int bx = i / (bin_size * bin_size); + i %= bin_size * bin_size; + const int yi = i / bin_size + by * bin_size; + const int xi = i % bin_size + bx * bin_size; + + if (yi >= S || xi >= S) + continue; + const float xf = PixToNdc(xi, S); + const float yf = PixToNdc(yi, S); + + // This part looks like the naive rasterization kernel, except we use + // bin_points to only look at a subset of points already known to fall + // in this bin. TODO abstract out this logic into some data structure + // that is shared by both kernels? + Pix q[kMaxPointsPerPixel]; + int q_size = 0; + float q_max_z = -1000; + int q_max_idx = -1; + for (int m = 0; m < M; ++m) { + const int p = bin_points[n * B * B * M + by * B * M + bx * M + m]; + if (p < 0) { + // bin_points uses -1 as a sentinal value + continue; + } + CheckPixelInsidePoint( + points, p, q_size, q_max_z, q_max_idx, q, radius2, xf, yf, n, P, K); + } + // Now we've looked at all the points for this bin, so we can write + // output for the current pixel. + BubbleSort(q, q_size); + const int pix_idx = n * S * S * K + yi * S * K + xi * K; + for (int k = 0; k < q_size; ++k) { + point_idxs[pix_idx + k] = q[k].idx; + zbuf[pix_idx + k] = q[k].z; + pix_dists[pix_idx + k] = q[k].dist2; + } + } +} + +std::tuple RasterizePointsFineCuda( + const torch::Tensor& points, + const torch::Tensor& bin_points, + const int image_size, + const float radius, + const int bin_size, + const int points_per_pixel) { + const int N = points.size(0); + const int P = points.size(1); + const int B = bin_points.size(1); + const int M = bin_points.size(3); + const int S = image_size; + const int K = points_per_pixel; + if (K > kMaxPointsPerPixel) { + AT_ERROR("Must have num_closest <= 8"); + } + auto int_opts = points.options().dtype(torch::kInt32); + auto float_opts = points.options().dtype(torch::kFloat32); + torch::Tensor point_idxs = torch::full({N, S, S, K}, -1, int_opts); + torch::Tensor zbuf = torch::full({N, S, S, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, S, S, K}, -1, float_opts); + + const size_t blocks = 1024; + const size_t threads = 64; + RasterizePointsFineCudaKernel<<>>( + points.contiguous().data(), + bin_points.contiguous().data(), + radius, + bin_size, + N, + P, + B, + M, + S, + K, + point_idxs.contiguous().data(), + zbuf.contiguous().data(), + pix_dists.contiguous().data()); + + return std::make_tuple(point_idxs, zbuf, pix_dists); +} + +// **************************************************************************** +// * BACKWARD PASS * +// **************************************************************************** +// TODO(T55115174) Add more documentation for backward kernel. +__global__ void RasterizePointsBackwardCudaKernel( + const float* points, // (N, P, 3) + const int32_t* idxs, // (N, H, W, K) + const int N, + const int P, + const int H, + const int W, + const int K, + const float* grad_zbuf, // (N, H, W, K) + const float* grad_dists, // (N, H, W, K) + float* grad_points) { // (N, P, 3) + // Parallelized over each of K points per pixel, for each pixel in images of + // size H * W, for each image in the batch of size N. + int num_threads = gridDim.x * blockDim.x; + int tid = blockIdx.x * blockDim.x + threadIdx.x; + for (int i = tid; i < N * H * W * K; i += num_threads) { + const int n = i / (H * W * K); + const int yxk = i % (H * W * K); + const int yi = yxk / (W * K); + const int xk = yxk % (W * K); + const int xi = xk / K; + // k = xk % K (We don't actually need k, but this would be it.) + const float xf = PixToNdc(xi, W); + const float yf = PixToNdc(yi, H); + + const int p = idxs[i]; + if (p < 0) + continue; + const float grad_dist2 = grad_dists[i]; + const int p_ind = n * P * 3 + p * 3; + const float px = points[p_ind]; + const float py = points[p_ind + 1]; + const float dx = px - xf; + const float dy = py - yf; + const float grad_px = 2.0f * grad_dist2 * dx; + const float grad_py = 2.0f * grad_dist2 * dy; + const float grad_pz = grad_zbuf[i]; + atomicAdd(grad_points + p_ind, grad_px); + atomicAdd(grad_points + p_ind + 1, grad_py); + atomicAdd(grad_points + p_ind + 2, grad_pz); + } +} + +torch::Tensor RasterizePointsBackwardCuda( + const torch::Tensor& points, // (N, P, 3) + const torch::Tensor& idxs, // (N, H, W, K) + const torch::Tensor& grad_zbuf, // (N, H, W, K) + const torch::Tensor& grad_dists) { // (N, H, W, K) + const int N = points.size(0); + const int P = points.size(1); + const int H = idxs.size(1); + const int W = idxs.size(2); + const int K = idxs.size(3); + + torch::Tensor grad_points = torch::zeros({N, P, 3}, points.options()); + const size_t blocks = 1024; + const size_t threads = 64; + + RasterizePointsBackwardCudaKernel<<>>( + points.contiguous().data(), + idxs.contiguous().data(), + N, + P, + H, + W, + K, + grad_zbuf.contiguous().data(), + grad_dists.contiguous().data(), + grad_points.contiguous().data()); + + return grad_points; +} diff --git a/pytorch3d/csrc/rasterize_points/rasterize_points.h b/pytorch3d/csrc/rasterize_points/rasterize_points.h new file mode 100644 index 00000000..de114ea4 --- /dev/null +++ b/pytorch3d/csrc/rasterize_points/rasterize_points.h @@ -0,0 +1,230 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#pragma once +#include +#include +#include + +// **************************************************************************** +// * NAIVE RASTERIZATION * +// **************************************************************************** + +std::tuple RasterizePointsNaiveCpu( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel); + +std::tuple +RasterizePointsNaiveCuda( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel); + +// Naive (forward) pointcloud rasterization: For each pixel, for each point, +// check whether that point hits the pixel. +// +// Args: +// points: Tensor of shape (N, P, 3) (in NDC) +// radius: Radius of each point (in NDC units) +// image_size: (S) Size of the image to return (in pixels) +// points_per_pixel: (K) The number closest of points to return for each pixel +// +// Returns: +// idxs: int32 Tensor of shape (N, S, S, K) giving the indices of the +// closest K points along the z-axis for each pixel, padded with -1 for +// pixels +// hit by fewer than K points. +// zbuf: float32 Tensor of shape (N, S, S, K) giving the depth of each +// closest point for each pixel. +// dists: float32 Tensor of shape (N, S, S, K) giving squared Euclidean +// distance in the (NDC) x/y plane between each pixel and its K closest +// points along the z axis. +std::tuple RasterizePointsNaive( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel) { + if (points.type().is_cuda()) { + return RasterizePointsNaiveCuda( + points, image_size, radius, points_per_pixel); + } else { + return RasterizePointsNaiveCpu( + points, image_size, radius, points_per_pixel); + } +} + +// **************************************************************************** +// * COARSE RASTERIZATION * +// **************************************************************************** + +torch::Tensor RasterizePointsCoarseCpu( + const torch::Tensor& points, + const int image_size, + const float radius, + const int bin_size, + const int max_points_per_bin); + +torch::Tensor RasterizePointsCoarseCuda( + const torch::Tensor& points, + const int image_size, + const float radius, + const int bin_size, + const int max_points_per_bin); + +// Args: +// points: Tensor of shape (N, P, 3) +// radius: Radius of points to rasterize (in NDC units) +// image_size: Size of the image to generate (in pixels) +// bin_size: Size of each bin within the image (in pixels) +// +// Returns: +// points_per_bin: Tensor of shape (N, num_bins, num_bins) giving the number +// of points that fall in each bin +// bin_points: Tensor of shape (N, num_bins, num_bins, K) giving the indices +// of points that fall into each bin. +torch::Tensor RasterizePointsCoarse( + const torch::Tensor& points, + const int image_size, + const float radius, + const int bin_size, + const int max_points_per_bin) { + if (points.type().is_cuda()) { + return RasterizePointsCoarseCuda( + points, image_size, radius, bin_size, max_points_per_bin); + } else { + return RasterizePointsCoarseCpu( + points, image_size, radius, bin_size, max_points_per_bin); + } +} + +// **************************************************************************** +// * FINE RASTERIZATION * +// **************************************************************************** + +std::tuple RasterizePointsFineCuda( + const torch::Tensor& points, + const torch::Tensor& bin_points, + const int image_size, + const float radius, + const int bin_size, + const int points_per_pixel); + +// Args: +// points: float32 Tensor of shape (N, P, 3) +// bin_points: int32 Tensor of shape (N, B, B, M) giving the indices of points +// that fall into each bin (output from coarse rasterization) +// image_size: Size of image to generate (in pixels) +// radius: Radius of points to rasterize (NDC units) +// bin_size: Size of each bin (in pixels) +// points_per_pixel: How many points to rasterize for each pixel +// +// Returns (same as rasterize_points): +// idxs: int32 Tensor of shape (N, S, S, K) giving the indices of the closest +// points_per_pixel points along the z-axis for each pixel, padded with +// -1 for pixels hit by fewer than points_per_pixel points +// zbuf: float32 Tensor of shape (N, S, S, K) giving the depth of each of each +// closest point for each pixel +// dists: float32 Tensor of shape (N, S, S, K) giving squared Euclidean +// distance in the (NDC) x/y plane between each pixel and its K closest +// points along the z axis. +std::tuple RasterizePointsFine( + const torch::Tensor& points, + const torch::Tensor& bin_points, + const int image_size, + const float radius, + const int bin_size, + const int points_per_pixel) { + if (points.type().is_cuda()) { + return RasterizePointsFineCuda( + points, bin_points, image_size, radius, bin_size, points_per_pixel); + } else { + AT_ERROR("NOT IMPLEMENTED"); + } +} + +// **************************************************************************** +// * BACKWARD PASS * +// **************************************************************************** + +torch::Tensor RasterizePointsBackwardCpu( + const torch::Tensor& points, + const torch::Tensor& idxs, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_dists); + +torch::Tensor RasterizePointsBackwardCuda( + const torch::Tensor& points, + const torch::Tensor& idxs, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_dists); + +// Args: +// points: float32 Tensor of shape (N, P, 3) +// idxs: int32 Tensor of shape (N, H, W, K) (from forward pass) +// grad_zbuf: float32 Tensor of shape (N, H, W, K) giving upstream gradient +// d(loss)/d(zbuf) of the distances from each pixel to its nearest +// points. +// grad_dists: Tensor of shape (N, H, W, K) giving upstream gradient +// d(loss)/d(dists) of the dists tensor returned by the forward +// pass. +// +// Returns: +// grad_points: float32 Tensor of shape (N, P, 3) giving downstream gradients +torch::Tensor RasterizePointsBackward( + const torch::Tensor& points, + const torch::Tensor& idxs, + const torch::Tensor& grad_zbuf, + const torch::Tensor& grad_dists) { + if (points.type().is_cuda()) { + return RasterizePointsBackwardCuda(points, idxs, grad_zbuf, grad_dists); + } else { + return RasterizePointsBackwardCpu(points, idxs, grad_zbuf, grad_dists); + } +} + +// **************************************************************************** +// * MAIN ENTRY POINT * +// **************************************************************************** + +// This is the main entry point for the forward pass of the point rasterizer; +// it uses either naive or coarse-to-fine rasterization based on bin_size. +// +// Args: +// points: Tensor of shape (N, P, 3) (in NDC) +// radius: Radius of each point (in NDC units) +// image_size: (S) Size of the image to return (in pixels) +// points_per_pixel: (K) The number of points to return for each pixel +// bin_size: Bin size (in pixels) for coarse-to-fine rasterization. Setting +// bin_size=0 uses naive rasterization instead. +// max_points_per_bin: The maximum number of points allowed to fall into each +// bin when using coarse-to-fine rasterization. +// +// Returns: +// idxs: int32 Tensor of shape (N, S, S, K) giving the indices of the +// closest points_per_pixel points along the z-axis for each pixel, +// padded with -1 for pixels hit by fewer than points_per_pixel points +// zbuf: float32 Tensor of shape (N, S, S, K) giving the depth of each of each +// closest point for each pixel +// dists: float32 Tensor of shape (N, S, S, K) giving squared Euclidean +// distance in the (NDC) x/y plane between each pixel and its K closest +// points along the z axis. +std::tuple RasterizePoints( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel, + const int bin_size, + const int max_points_per_bin) { + if (bin_size == 0) { + // Use the naive per-pixel implementation + return RasterizePointsNaive(points, image_size, radius, points_per_pixel); + } else { + // Use coarse-to-fine rasterization + const auto bin_points = RasterizePointsCoarse( + points, image_size, radius, bin_size, max_points_per_bin); + return RasterizePointsFine( + points, bin_points, image_size, radius, bin_size, points_per_pixel); + } +} diff --git a/pytorch3d/csrc/rasterize_points/rasterize_points_cpu.cpp b/pytorch3d/csrc/rasterize_points/rasterize_points_cpu.cpp new file mode 100644 index 00000000..fdb4f852 --- /dev/null +++ b/pytorch3d/csrc/rasterize_points/rasterize_points_cpu.cpp @@ -0,0 +1,196 @@ +// Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +#include +#include +#include + +// Given a pixel coordinate 0 <= i < S, convert it to a normalized device +// coordinate in the range [-1, 1]. The NDC range is divided into S evenly-sized +// pixels, and assume that each pixel falls in the *center* of its range. +inline float PixToNdc(const int i, const int S) { + // NDC x-offset + (i * pixel_width + half_pixel_width) + return -1 + (2 * i + 1.0f) / S; +} + +std::tuple RasterizePointsNaiveCpu( + const torch::Tensor& points, + const int image_size, + const float radius, + const int points_per_pixel) { + const int N = points.size(0); + const int P = points.size(1); + const int S = image_size; + const int K = points_per_pixel; + auto int_opts = points.options().dtype(torch::kInt32); + auto float_opts = points.options().dtype(torch::kFloat32); + torch::Tensor point_idxs = torch::full({N, S, S, K}, -1, int_opts); + torch::Tensor zbuf = torch::full({N, S, S, K}, -1, float_opts); + torch::Tensor pix_dists = torch::full({N, S, S, K}, -1, float_opts); + + auto points_a = points.accessor(); + auto point_idxs_a = point_idxs.accessor(); + auto zbuf_a = zbuf.accessor(); + auto pix_dists_a = pix_dists.accessor(); + + const float radius2 = radius * radius; + for (int n = 0; n < N; ++n) { + for (int yi = 0; yi < S; ++yi) { + float yf = PixToNdc(yi, S); + for (int xi = 0; xi < S; ++xi) { + float xf = PixToNdc(xi, S); + // Use a priority queue to hold (z, idx, r) + std::priority_queue> q; + for (int p = 0; p < P; ++p) { + const float px = points_a[n][p][0]; + const float py = points_a[n][p][1]; + const float pz = points_a[n][p][2]; + if (pz < 0) { + continue; + } + const float dx = px - xf; + const float dy = py - yf; + const float dist2 = dx * dx + dy * dy; + if (dist2 < radius2) { + // The current point hit the current pixel + q.emplace(pz, p, dist2); + if ((int)q.size() > K) { + q.pop(); + } + } + } + // Now all the points have been seen, so pop elements off the queue + // one by one and write them into the output tensors. + while (!q.empty()) { + auto t = q.top(); + q.pop(); + int i = q.size(); + zbuf_a[n][yi][xi][i] = std::get<0>(t); + point_idxs_a[n][yi][xi][i] = std::get<1>(t); + pix_dists_a[n][yi][xi][i] = std::get<2>(t); + } + } + } + } + return std::make_tuple(point_idxs, zbuf, pix_dists); +} + +std::tuple RasterizePointsCoarseCpu( + const torch::Tensor& points, + const int image_size, + const float radius, + const int bin_size, + const int max_points_per_bin) { + const int N = points.size(0); + const int P = points.size(1); + const int B = 1 + (image_size - 1) / bin_size; // Integer division round up + const int M = max_points_per_bin; + auto opts = points.options().dtype(torch::kInt32); + torch::Tensor points_per_bin = torch::zeros({N, B, B}, opts); + torch::Tensor bin_points = torch::full({N, B, B, M}, -1, opts); + + auto points_a = points.accessor(); + auto points_per_bin_a = points_per_bin.accessor(); + auto bin_points_a = bin_points.accessor(); + + const float pixel_width = 2.0f / image_size; + const float bin_width = pixel_width * bin_size; + for (int n = 0; n < N; ++n) { + float bin_y_min = -1.0f; + float bin_y_max = bin_y_min + bin_width; + for (int by = 0; by < B; by++) { + float bin_x_min = -1.0f; + float bin_x_max = bin_x_min + bin_width; + for (int bx = 0; bx < B; bx++) { + int32_t points_hit = 0; + for (int32_t p = 0; p < P; p++) { + float px = points_a[n][p][0]; + float py = points_a[n][p][1]; + float pz = points_a[n][p][2]; + if (pz < 0) { + continue; + } + float point_x_min = px - radius; + float point_x_max = px + radius; + float point_y_min = py - radius; + float point_y_max = py + radius; + // Use a half-open interval so that points exactly on the + // boundary between bins will fall into exactly one bin. + bool x_hit = (point_x_min <= bin_x_max) && (bin_x_min <= point_x_max); + bool y_hit = (point_y_min <= bin_y_max) && (bin_y_min <= point_y_max); + if (x_hit && y_hit) { + // Got too many points for this bin, so throw an error. + if (points_hit >= max_points_per_bin) { + AT_ERROR("Got too many points per bin"); + } + // The current point falls in the current bin, so + // record it. + bin_points_a[n][by][bx][points_hit] = p; + points_hit++; + } + } + // Record the number of points found in this bin + points_per_bin_a[n][by][bx] = points_hit; + + // Shift the bin to the right for the next loop iteration + bin_x_min = bin_x_max; + bin_x_max = bin_x_min + bin_width; + } + // Shift the bin down for the next loop iteration + bin_y_min = bin_y_max; + bin_y_max = bin_y_min + bin_width; + } + } + return std::make_tuple(points_per_bin, bin_points); +} + +torch::Tensor RasterizePointsBackwardCpu( + const torch::Tensor& points, // (N, P, 3) + const torch::Tensor& idxs, // (N, H, W, K) + const torch::Tensor& grad_zbuf, // (N, H, W, K) + const torch::Tensor& grad_dists) { // (N, H, W, K) + const int N = points.size(0); + const int P = points.size(1); + const int H = idxs.size(1); + const int W = idxs.size(2); + const int K = idxs.size(3); + + // For now only support square images. + // TODO(jcjohns): Extend to non-square images. + if (H != W) { + AT_ERROR("RasterizePointsBackwardCpu only supports square images"); + } + torch::Tensor grad_points = torch::zeros({N, P, 3}, points.options()); + + auto points_a = points.accessor(); + auto idxs_a = idxs.accessor(); + auto grad_dists_a = grad_dists.accessor(); + auto grad_zbuf_a = grad_zbuf.accessor(); + auto grad_points_a = grad_points.accessor(); + + for (int n = 0; n < N; ++n) { // Loop over images in the batch + for (int y = 0; y < H; ++y) { // Loop over rows in the image + const float yf = PixToNdc(y, H); + for (int x = 0; x < W; ++x) { // Loop over pixels in the row + const float xf = PixToNdc(x, W); + for (int k = 0; k < K; ++k) { // Loop over points for the pixel + const int p = idxs_a[n][y][x][k]; + if (p < 0) { + break; + } + const float grad_dist2 = grad_dists_a[n][y][x][k]; + const float px = points_a[n][p][0]; + const float py = points_a[n][p][1]; + const float dx = px - xf; + const float dy = py - yf; + // Remember: dists[n][y][x][k] = dx * dx + dy * dy; + const float grad_px = 2.0f * grad_dist2 * dx; + const float grad_py = 2.0f * grad_dist2 * dy; + grad_points_a[n][p][0] += grad_px; + grad_points_a[n][p][1] += grad_py; + grad_points_a[n][p][2] += grad_zbuf_a[n][y][x][k]; + } + } + } + } + return grad_points; +} diff --git a/pytorch3d/io/__init__.py b/pytorch3d/io/__init__.py new file mode 100644 index 00000000..1ef515ac --- /dev/null +++ b/pytorch3d/io/__init__.py @@ -0,0 +1,7 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from .obj_io import load_obj, save_obj +from .ply_io import load_ply, save_ply + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/io/obj_io.py b/pytorch3d/io/obj_io.py new file mode 100644 index 00000000..1f9aa4aa --- /dev/null +++ b/pytorch3d/io/obj_io.py @@ -0,0 +1,532 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +"""This module implements utility functions for loading and saving meshes.""" +import numpy as np +import os +import pathlib +import warnings +from collections import namedtuple +from typing import List +import torch +from fvcore.common.file_io import PathManager +from PIL import Image + + +def _read_image(file_name: str, format=None): + """ + Read an image from a file using Pillow. + Args: + file_name: image file path. + format: one of ["RGB", "BGR"] + Returns: + image: an image of shape (H, W, C). + """ + if format not in ["RGB", "BGR"]: + raise ValueError("format can only be one of [RGB, BGR]; got %s", format) + with PathManager.open(file_name, "rb") as f: + image = Image.open(f) + if format is not None: + # PIL only supports RGB. First convert to RGB and flip channels + # below for BGR. + image = image.convert("RGB") + image = np.asarray(image).astype(np.float32) + if format == "BGR": + image = image[:, :, ::-1] + return image + + +# Faces & Aux type returned from load_obj function. +_Faces = namedtuple("Faces", "verts_idx normals_idx textures_idx materials_idx") +_Aux = namedtuple( + "Properties", "normals verts_uvs material_colors texture_images" +) + + +def _format_faces_indices(faces_indices, max_index): + """ + Format indices and check for invalid values. Indices can refer to + values in one of the face properties: vertices, textures or normals. + See comments of the load_obj function for more details. + + Args: + faces_indices: List of ints of indices. + max_index: Max index for the face property. + + Returns: + faces_indices: List of ints of indices. + + Raises: + ValueError if indices are not in a valid range. + """ + faces_indices = torch.tensor(faces_indices, dtype=torch.int64) + + # Change to 0 based indexing. + faces_indices[(faces_indices > 0)] -= 1 + + # Negative indexing counts from the end. + faces_indices[(faces_indices < 0)] += max_index + + # Check indices are valid. + if not ( + torch.all(faces_indices < max_index) and torch.all(faces_indices >= 0) + ): + raise ValueError("Faces have invalid indices.") + + return faces_indices + + +def _open_file(f): + new_f = False + if isinstance(f, str): + new_f = True + f = open(f, "r") + elif isinstance(f, pathlib.Path): + new_f = True + f = f.open("r") + return f, new_f + + +def load_obj(f_obj): + """ + Load a mesh and textures from a .obj and .mtl file. + Currently this handles verts, faces, vertex texture uv coordinates, normals, + texture images and material reflectivity values. + + Note .obj files are 1-indexed. The tensors returned from this function + are 0-indexed. OBJ spec reference: http://www.martinreddy.net/gfx/3d/OBJ.spec + + Example .obj file format: + :: + # this is a comment + v 1.000000 -1.000000 -1.000000 + v 1.000000 -1.000000 1.000000 + v -1.000000 -1.000000 1.000000 + v -1.000000 -1.000000 -1.000000 + v 1.000000 1.000000 -1.000000 + vt 0.748573 0.750412 + vt 0.749279 0.501284 + vt 0.999110 0.501077 + vt 0.999455 0.750380 + vn 0.000000 0.000000 -1.000000 + vn -1.000000 -0.000000 -0.000000 + vn -0.000000 -0.000000 1.000000 + f 5/2/1 1/2/1 4/3/1 + f 5/1/1 4/3/1 2/4/1 + + The first character of the line denotes the type of input: + :: + - v is a vertex + - vt is the texture coordinate of one vertex + - vn is the normal of one vertex + - f is a face + + Faces are interpreted as follows: + :: + 5/2/1 describes the first vertex of the first triange + - 5: index of vertex [1.000000 1.000000 -1.000000] + - 2: index of texture coordinate [0.749279 0.501284] + - 1: index of normal [0.000000 0.000000 -1.000000] + + If there are faces with more than 3 vertices + they are subdivided into triangles. Polygonal faces are assummed to have + vertices ordered counter-clockwise so the (right-handed) normal points + into the screen e.g. a proper rectangular face would be specified like this: + :: + 0_________1 + | | + | | + 3 ________2 + + The face would be split into two triangles: (0, 1, 2) and (0, 2, 3), + both of which are also oriented clockwise and have normals + pointing into the screen. + + Args: + f: A file-like object (with methods read, readline, tell, and seek), + a pathlib path or a string containing a file name. + + Returns: + 6-element tuple containing + + - **verts**: FloatTensor of shape (V, 3). + - **faces**: NamedTuple with fields: + - verts_idx: LongTensor of vertex indices, shape (F, 3). + - normals_idx: (optional) LongTensor of normal indices, shape (F, 3). + - textures_idx: (optional) LongTensor of texture indices, shape (F, 3). + This can be used to index into verts_uvs. + - materials_idx: (optional) List of indices indicating which + material the texture is derived from for each face. + If there is no material for a face, the index is -1. + This can be used to retrieve the corresponding values + in material_colors/texture_images after they have been + converted to tensors or Materials/Textures data + structures - see textures.py and materials.py for + more info. + - **aux**: NamedTuple with fields: + - normals: FloatTensor of shape (N, 3) + - verts_uvs: FloatTensor of shape (T, 2), giving the uv coordinate per + vertex. If a vertex is shared between two faces, it can have + a different uv value for each instance. Therefore it is + possible that the number of verts_uvs is greater than + num verts i.e. T > V. + vertex. + - material_colors: dict of material names and associated properties. + If a material does not have any properties it will have an + empty dict. + + .. code-block:: python + + { + material_name_1: { + "ambient_color": tensor of shape (1, 3), + "diffuse_color": tensor of shape (1, 3), + "specular_color": tensor of shape (1, 3), + "shininess": tensor of shape (1) + }, + material_name_2: {}, + ... + } + - texture_images: dict of material names and texture images. + .. code-block:: python + + { + material_name_1: (H, W, 3) image, + ... + } + """ + data_dir = "./" + if isinstance(f_obj, (str, bytes, os.PathLike)): + data_dir = os.path.dirname(f_obj) + f_obj, new_f = _open_file(f_obj) + try: + return _load(f_obj, data_dir) + finally: + if new_f: + f_obj.close() + + +def _parse_face( + line, + material_idx, + faces_verts_idx, + faces_normals_idx, + faces_textures_idx, + faces_materials_idx, +): + face = line.split(" ")[1:] + face_list = [f.split("/") for f in face] + face_verts = [] + face_normals = [] + face_textures = [] + + for vert_props in face_list: + # Vertex index. + face_verts.append(int(vert_props[0])) + if len(vert_props) > 1: + if vert_props[1] != "": + # Texture index is present e.g. f 4/1/1. + face_textures.append(int(vert_props[1])) + if len(vert_props) > 2: + # Normal index present e.g. 4/1/1 or 4//1. + face_normals.append(int(vert_props[2])) + if len(vert_props) > 3: + raise ValueError( + "Face vertices can ony have 3 properties. \ + Face vert %s, Line: %s" + % (str(vert_props), str(line)) + ) + + # Triplets must be consistent for all vertices in a face e.g. + # legal statement: f 4/1/1 3/2/1 2/1/1. + # illegal statement: f 4/1/1 3//1 2//1. + if len(face_normals) > 0: + if not (len(face_verts) == len(face_normals)): + raise ValueError( + "Face %s is an illegal statement. \ + Vertex properties are inconsistent. Line: %s" + % (str(face), str(line)) + ) + if len(face_textures) > 0: + if not (len(face_verts) == len(face_textures)): + raise ValueError( + "Face %s is an illegal statement. \ + Vertex properties are inconsistent. Line: %s" + % (str(face), str(line)) + ) + + # Subdivide faces with more than 3 vertices. See comments of the + # load_obj function for more details. + for i in range(len(face_verts) - 2): + faces_verts_idx.append( + (face_verts[0], face_verts[i + 1], face_verts[i + 2]) + ) + if len(face_normals) > 0: + faces_normals_idx.append( + (face_normals[0], face_normals[i + 1], face_normals[i + 2]) + ) + if len(face_textures) > 0: + faces_textures_idx.append( + (face_textures[0], face_textures[i + 1], face_textures[i + 2]) + ) + faces_materials_idx.append(material_idx) + + +def _load(f_obj, data_dir): + """ + Load a mesh from a file-like object. See load_obj function more details. + Any material files associated with the obj are expected to be in the + directory given by data_dir. + """ + lines = [line.strip() for line in f_obj] + verts = [] + normals = [] + verts_uvs = [] + faces_verts_idx = [] + faces_normals_idx = [] + faces_textures_idx = [] + material_names = [] + faces_materials_idx = [] + f_mtl = None + materials_idx = -1 + + # startswith expects each line to be a string. If the file is read in as + # bytes then first decode to strings. + if isinstance(lines[0], bytes): + lines = [l.decode("utf-8") for l in lines] + + for line in lines: + if line.startswith("mtllib"): + if len(line.split()) < 2: + raise ValueError("material file name is not specified") + # NOTE: this assumes only one mtl file per .obj. + f_mtl = os.path.join(data_dir, line.split()[1]) + elif len(line.split()) != 0 and line.split()[0] == "usemtl": + material_name = line.split()[1] + material_names.append(material_name) + materials_idx = len(material_names) - 1 + elif line.startswith("v "): + # Line is a vertex. + vert = [float(x) for x in line.split()[1:4]] + if len(vert) != 3: + msg = "Vertex %s does not have 3 values. Line: %s" + raise ValueError(msg % (str(vert), str(line))) + verts.append(vert) + elif line.startswith("vt "): + # Line is a texture. + tx = [float(x) for x in line.split()[1:3]] + if len(tx) != 2: + raise ValueError( + "Texture %s does not have 2 values. Line: %s" + % (str(tx), str(line)) + ) + verts_uvs.append(tx) + elif line.startswith("vn "): + # Line is a normal. + norm = [float(x) for x in line.split()[1:4]] + if len(norm) != 3: + msg = "Normal %s does not have 3 values. Line: %s" + raise ValueError(msg % (str(norm), str(line))) + normals.append(norm) + elif line.startswith("f "): + # Line is a face. + _parse_face( + line, + materials_idx, + faces_verts_idx, + faces_normals_idx, + faces_textures_idx, + faces_materials_idx, + ) + + verts = torch.tensor(verts) # (V, 3) + normals = torch.tensor(normals) # (N, 3) + verts_uvs = torch.tensor(verts_uvs) # (T, 3) + + faces_verts_idx = _format_faces_indices(faces_verts_idx, verts.shape[0]) + + # Repeat for normals and textures if present. + if len(faces_normals_idx) > 0: + faces_normals_idx = _format_faces_indices( + faces_normals_idx, normals.shape[0] + ) + if len(faces_textures_idx) > 0: + faces_textures_idx = _format_faces_indices( + faces_textures_idx, verts_uvs.shape[0] + ) + if len(faces_materials_idx) > 0: + faces_materials_idx = torch.tensor( + faces_materials_idx, dtype=torch.int64 + ) + + # Load materials + material_colors, texture_images = None, None + if (len(material_names) > 0) and (f_mtl is not None): + if os.path.isfile(f_mtl): + material_colors, texture_images = load_mtl( + f_mtl, material_names, data_dir + ) + else: + warnings.warn(f"Mtl file does not exist: {f_mtl}") + elif len(material_names) > 0: + warnings.warn("No mtl file provided") + + faces = _Faces( + verts_idx=faces_verts_idx, + normals_idx=faces_normals_idx, + textures_idx=faces_textures_idx, + materials_idx=faces_materials_idx, + ) + + aux = _Aux( + normals=normals if len(normals) > 0 else None, + verts_uvs=verts_uvs if len(verts_uvs) > 0 else None, + material_colors=material_colors, + texture_images=texture_images, + ) + return verts, faces, aux + + +def load_mtl(f_mtl, material_names: List, data_dir: str): + """ + Load texture images and material reflectivity values for ambient, diffuse + and specular light (Ka, Kd, Ks, Ns). + + Args: + f_mtl: a file like object of the material information. + material_names: a list of the material names found in the .obj file. + data_dir: the directory where the material texture files are located. + + Returns: + material_colors: dict of properties for each material. If a material + does not have any properties it will have an emtpy dict. + { + material_name_1: { + "ambient_color": tensor of shape (1, 3), + "diffuse_color": tensor of shape (1, 3), + "specular_color": tensor of shape (1, 3), + "shininess": tensor of shape (1) + }, + material_name_2: {}, + ... + } + texture_images: dict of material names and texture images + { + material_name_1: (H, W, 3) image, + ... + } + """ + texture_files = {} + material_colors = {} + material_properties = {} + texture_images = {} + material_name = "" + + f_mtl, new_f = _open_file(f_mtl) + lines = [line.strip() for line in f_mtl] + for line in lines: + if len(line.split()) != 0: + if line.split()[0] == "newmtl": + material_name = line.split()[1] + material_colors[material_name] = {} + if line.split()[0] == "map_Kd": + # Texture map. + texture_files[material_name] = line.split()[1] + if line.split()[0] == "Kd": + # RGB diffuse reflectivity + kd = np.array(list(line.split()[1:4])).astype(np.float32) + kd = torch.from_numpy(kd) + material_colors[material_name]["diffuse_color"] = kd + if line.split()[0] == "Ka": + # RGB ambient reflectivity + ka = np.array(list(line.split()[1:4])).astype(np.float32) + ka = torch.from_numpy(ka) + material_colors[material_name]["ambient_color"] = ka + if line.split()[0] == "Ks": + # RGB specular reflectivity + ks = np.array(list(line.split()[1:4])).astype(np.float32) + ks = torch.from_numpy(ks) + material_colors[material_name]["specular_color"] = ks + if line.split()[0] == "Ns": + # Specular exponent + ns = np.array(list(line.split()[1:4])).astype(np.float32) + ns = torch.from_numpy(ns) + material_colors[material_name]["shininess"] = ns + + if new_f: + f_mtl.close() + + # Only keep the materials referenced in the obj. + for name in material_names: + if name in texture_files: + # Load the texture image. + filename = texture_files[name] + filename_texture = os.path.join(data_dir, filename) + if os.path.isfile(filename_texture): + image = _read_image(filename_texture, format="RGB") / 255.0 + image = torch.from_numpy(image) + texture_images[name] = image + else: + msg = f"Texture file does not exist: {filename_texture}" + warnings.warn(msg) + + if name in material_colors: + material_properties[name] = material_colors[name] + + return material_properties, texture_images + + +def save_obj(f, verts, faces, decimal_places: int = None): + """ + Save a mesh to an .obj file. + + Args: + f: File (or path) to which the mesh should be written. + verts: FloatTensor of shape (V, 3) giving vertex coordinates. + faces: LongTensor of shape (F, 3) giving faces. + decimal_places: Number of decimal places for saving. + """ + new_f = False + if isinstance(f, str): + new_f = True + f = open(f, "w") + elif isinstance(f, pathlib.Path): + new_f = True + f = f.open("w") + try: + return _save(f, verts, faces, decimal_places) + finally: + if new_f: + f.close() + + +# TODO (nikhilar) Speed up this function. +def _save(f, verts, faces, decimal_places: int = None): + if verts.dim() != 2 or verts.size(1) != 3: + raise ValueError("Argument 'verts' should be of shape (num_verts, 3).") + if faces.dim() != 2 or faces.size(1) != 3: + raise ValueError("Argument 'faces' should be of shape (num_faces, 3).") + verts, faces = verts.cpu(), faces.cpu() + + if decimal_places is None: + float_str = "%f" + else: + float_str = "%" + ".%df" % decimal_places + + lines = "" + V, D = verts.shape + for i in range(V): + vert = [float_str % verts[i, j] for j in range(D)] + lines += "v %s\n" % " ".join(vert) + + F, P = faces.shape + for i in range(F): + face = ["%d" % (faces[i, j] + 1) for j in range(P)] + if i + 1 < F: + lines += "f %s\n" % " ".join(face) + elif i + 1 == F: + # No newline at the end of the file. + lines += "f %s" % " ".join(face) + + f.write(lines) diff --git a/pytorch3d/io/ply_io.py b/pytorch3d/io/ply_io.py new file mode 100644 index 00000000..69833e7e --- /dev/null +++ b/pytorch3d/io/ply_io.py @@ -0,0 +1,748 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. +# This source code is licensed under the license found in the +# LICENSE file in the root directory of this source tree. + + +"""This module implements utility functions for loading and saving meshes.""" +import numpy as np +import pathlib +import struct +import sys +import warnings +from collections import namedtuple +from typing import Optional, Tuple +import torch + +_PlyTypeData = namedtuple("_PlyTypeData", "size struct_char np_type") + +_PLY_TYPES = { + "char": _PlyTypeData(1, "b", np.byte), + "uchar": _PlyTypeData(1, "B", np.ubyte), + "short": _PlyTypeData(2, "h", np.short), + "ushort": _PlyTypeData(2, "H", np.ushort), + "int": _PlyTypeData(4, "i", np.int32), + "uint": _PlyTypeData(4, "I", np.uint32), + "float": _PlyTypeData(4, "f", np.float32), + "double": _PlyTypeData(8, "d", np.float64), +} + +_Property = namedtuple("_Property", "name data_type list_size_type") + + +class _PlyElementType: + """ + Description of an element of a Ply file. + Members: + self.properties: (List[_Property]) description of all the properties. + Each one contains a name and data type. + self.count: (int) number of such elements in the file + self.name: (str) name of the element + """ + + def __init__(self, name: str, count: int): + self.name = name + self.count = count + self.properties = [] + + def add_property( + self, name: str, data_type: str, list_size_type: Optional[str] = None + ): + """Adds a new property. + + Args: + name: (str) name of the property. + data_type: (str) PLY data type. + list_size_type: (str) PLY data type of the list size, or None if not + a list. + """ + for property in self.properties: + if property.name == name: + msg = "Cannot have two properties called %s in %s." + raise ValueError(msg % (name, self.name)) + self.properties.append(_Property(name, data_type, list_size_type)) + + def is_fixed_size(self) -> bool: + """Return whether the Element has no list properties + + Returns: + True if none of the properties are lists. + """ + for property in self.properties: + if property.list_size_type is not None: + return False + return True + + def is_constant_type_fixed_size(self) -> bool: + """Return whether the Element has all properties of the same non-list + type. + + Returns: + True if none of the properties are lists and all the properties + share a type. + """ + if not self.is_fixed_size(): + return False + first_type = self.properties[0].data_type + for property in self.properties: + if property.data_type != first_type: + return False + return True + + def try_constant_list(self) -> bool: + """Whether the element is just a single list, which might have a + constant size, and therefore we could try to parse quickly with numpy. + + Returns: + True if the only property is a list. + """ + if len(self.properties) != 1: + return False + if self.properties[0].list_size_type is None: + return False + return True + + +class _PlyHeader: + def __init__(self, f): + """ + Load a header of a Ply file from a file-like object. + Members: + self.elements: (List[_PlyElementType]) element description + self.ascii: (bool) Whether in ascii format + self.big_endian: (bool) (if not ascii) whether big endian + self.obj_info: (dict) arbitrary extra data + + Args: + f: file-like object. + """ + if f.readline() not in [b"ply\n", b"ply\r\n", "ply\n"]: + raise ValueError("Invalid file header.") + seen_format = False + self.elements = [] + self.obj_info = {} + while True: + line = f.readline() + if isinstance(line, bytes): + line = line.decode("ascii") + line = line.strip() + if line == "end_header": + if not self.elements: + raise ValueError("No elements found.") + if not self.elements[-1].properties: + raise ValueError("Found an element with no properties.") + if not seen_format: + raise ValueError("No format line found.") + break + if not seen_format: + if line == "format ascii 1.0": + seen_format = True + self.ascii = True + continue + if line == "format binary_little_endian 1.0": + seen_format = True + self.ascii = False + self.big_endian = False + continue + if line == "format binary_big_endian 1.0": + seen_format = True + self.ascii = False + self.big_endian = True + continue + if line.startswith("format"): + raise ValueError("Invalid format line.") + if line.startswith("comment") or len(line) == 0: + continue + if line.startswith("element"): + self._parse_element(line) + continue + if line.startswith("obj_info"): + items = line.split(" ") + if len(items) != 3: + raise ValueError("Invalid line: %s" % line) + self.obj_info[items[1]] = items[2] + continue + if line.startswith("property"): + self._parse_property(line) + continue + raise ValueError("Invalid line: %s." % line) + + def _parse_property(self, line: str): + """ + Decode a ply file header property line. + + Args: + line: (str) the ply file's line. + """ + if not self.elements: + raise ValueError("Encountered property before any element.") + items = line.split(" ") + if len(items) not in [3, 5]: + raise ValueError("Invalid line: %s" % line) + datatype = items[1] + name = items[-1] + if datatype == "list": + datatype = items[3] + list_size_type = items[2] + if list_size_type not in _PLY_TYPES: + raise ValueError("Invalid datatype: %s" % list_size_type) + else: + list_size_type = None + if datatype not in _PLY_TYPES: + raise ValueError("Invalid datatype: %s" % datatype) + self.elements[-1].add_property(name, datatype, list_size_type) + + def _parse_element(self, line: str): + """ + Decode a ply file header element line. + + Args: + line: (str) the ply file's line. + """ + if self.elements and not self.elements[-1].properties: + raise ValueError("Found an element with no properties.") + items = line.split(" ") + if len(items) != 3: + raise ValueError("Invalid line: %s" % line) + try: + count = int(items[2]) + except ValueError: + msg = "Number of items for %s was not a number." + raise ValueError(msg % items[1]) + self.elements.append(_PlyElementType(items[1], count)) + + +def _read_ply_fixed_size_element_ascii(f, definition: _PlyElementType): + """ + Given an element which has no lists and one type, read the + corresponding data. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + + Returns: + 2D numpy array corresponding to the data. The rows are the different + values. There is one column for each property. + """ + np_type = _PLY_TYPES[definition.properties[0].data_type].np_type + data = np.loadtxt( + f, dtype=np_type, comments=None, ndmin=2, max_rows=definition.count + ) + if data.shape[1] != len(definition.properties): + raise ValueError("Inconsistent data for %s." % definition.name) + if data.shape[0] != definition.count: + raise ValueError("Not enough data for %s." % definition.name) + return data + + +def _try_read_ply_constant_list_ascii(f, definition: _PlyElementType): + """ + If definition is an element which is a single list, attempt to read the + corresponding data assuming every value has the same length. + If the data is ragged, return None and leave f undisturbed. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + + Returns: + If every element has the same size, 2D numpy array corresponding to the + data. The rows are the different values. Otherwise None. + """ + np_type = _PLY_TYPES[definition.properties[0].data_type].np_type + start_point = f.tell() + try: + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", message=".* Empty input file.*", category=UserWarning + ) + data = np.loadtxt( + f, + dtype=np_type, + comments=None, + ndmin=2, + max_rows=definition.count, + ) + except ValueError: + f.seek(start_point) + return None + if (data.shape[1] - 1 != data[:, 0]).any(): + msg = "A line of %s data did not have the specified length." + raise ValueError(msg % definition.name) + if data.shape[0] != definition.count: + raise ValueError("Not enough data for %s." % definition.name) + return data[:, 1:] + + +def _parse_heterogenous_property_ascii(datum, line_iter, property: _Property): + """ + Read a general data property from an ascii .ply file. + + Args: + datum: list to append the single value to. That value will be a numpy + array if the property is a list property, otherwise an int or + float. + line_iter: iterator to words on the line from which we read. + property: the property object describing the property we are reading. + """ + value = next(line_iter, None) + if value is None: + raise ValueError("Too little data for an element.") + if property.list_size_type is None: + try: + if property.data_type in ["double", "float"]: + datum.append(float(value)) + else: + datum.append(int(value)) + except ValueError: + raise ValueError("Bad numerical data.") + else: + try: + length = int(value) + except ValueError: + raise ValueError("A list length was not a number.") + list_value = np.zeros( + length, dtype=_PLY_TYPES[property.data_type].np_type + ) + for i in range(length): + inner_value = next(line_iter, None) + if inner_value is None: + raise ValueError("Too little data for an element.") + try: + list_value[i] = float(inner_value) + except ValueError: + raise ValueError("Bad numerical data.") + datum.append(list_value) + + +def _read_ply_element_ascii(f, definition: _PlyElementType): + """ + Decode all instances of a single element from an ascii .ply file. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + + Returns: + In simple cases where every element has the same size, 2D numpy array + corresponding to the data. The rows are the different values. + Otherwise a list of lists of values, where the outer list is + each occurence of the element, and the inner lists have one value per + property. + """ + if definition.is_constant_type_fixed_size(): + return _read_ply_fixed_size_element_ascii(f, definition) + if definition.try_constant_list(): + data = _try_read_ply_constant_list_ascii(f, definition) + if data is not None: + return data + + # We failed to read the element as a lump, must process each line manually. + data = [] + for _i in range(definition.count): + line_string = f.readline() + if line_string == "": + raise ValueError("Not enough data for %s." % definition.name) + datum = [] + line_iter = iter(line_string.strip().split()) + for property in definition.properties: + _parse_heterogenous_property_ascii(datum, line_iter, property) + data.append(datum) + if next(line_iter, None) is not None: + raise ValueError("Too much data for an element.") + return data + + +def _read_ply_fixed_size_element_binary( + f, definition: _PlyElementType, big_endian: bool +): + """ + Given an element which has no lists and one type, read the + corresponding data. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + big_endian: (bool) whether the document is encoded as big endian. + + Returns: + 2D numpy array corresponding to the data. The rows are the different + values. There is one column for each property. + """ + ply_type = _PLY_TYPES[definition.properties[0].data_type] + np_type = ply_type.np_type + type_size = ply_type.size + needed_length = definition.count * len(definition.properties) + needed_bytes = needed_length * type_size + bytes_data = f.read(needed_bytes) + if len(bytes_data) != needed_bytes: + raise ValueError("Not enough data for %s." % definition.name) + data = np.frombuffer(bytes_data, dtype=np_type) + + if (sys.byteorder == "big") != big_endian: + data = data.byteswap() + return data.reshape(definition.count, len(definition.properties)) + + +def _read_ply_element_struct(f, definition: _PlyElementType, endian_str: str): + """ + Given an element which has no lists, read the corresponding data. Uses the + struct library. + + Note: It looks like struct would also support lists where + type=size_type=char, but it is hard to know how much data to read in that + case. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + endian_str: ">" or "<" according to whether the document is big or + little endian. + + Returns: + 2D numpy array corresponding to the data. The rows are the different + values. There is one column for each property. + """ + format = "".join( + _PLY_TYPES[property.data_type].struct_char + for property in definition.properties + ) + format = endian_str + format + pattern = struct.Struct(format) + size = pattern.size + needed_bytes = size * definition.count + bytes_data = f.read(needed_bytes) + if len(bytes_data) != needed_bytes: + raise ValueError("Not enough data for %s." % definition.name) + data = [ + pattern.unpack_from(bytes_data, i * size) + for i in range(definition.count) + ] + return data + + +def _try_read_ply_constant_list_binary( + f, definition: _PlyElementType, big_endian: bool +): + """ + If definition is an element which is a single list, attempt to read the + corresponding data assuming every value has the same length. + If the data is ragged, return None and leave f undisturbed. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + big_endian: (bool) whether the document is encoded as big endian. + + Returns: + If every element has the same size, 2D numpy array corresponding to the + data. The rows are the different values. Otherwise None. + """ + property = definition.properties[0] + endian_str = ">" if big_endian else "<" + length_format = endian_str + _PLY_TYPES[property.list_size_type].struct_char + length_struct = struct.Struct(length_format) + + def get_length(): + bytes_data = f.read(length_struct.size) + if len(bytes_data) != length_struct.size: + raise ValueError("Not enough data for %s." % definition.name) + [length] = length_struct.unpack(bytes_data) + return length + + start_point = f.tell() + + length = get_length() + np_type = _PLY_TYPES[definition.properties[0].data_type].np_type + type_size = _PLY_TYPES[definition.properties[0].data_type].size + data_size = type_size * length + + output = np.zeros((definition.count, length), dtype=np_type) + + for i in range(definition.count): + bytes_data = f.read(data_size) + if len(bytes_data) != data_size: + raise ValueError("Not enough data for %s" % definition.name) + output[i] = np.frombuffer(bytes_data, dtype=np_type) + if i + 1 == definition.count: + break + if length != get_length(): + f.seek(start_point) + return None + if (sys.byteorder == "big") != big_endian: + output = output.byteswap() + + return output + + +def _read_ply_element_binary( + f, definition: _PlyElementType, big_endian: bool +) -> list: + """ + Decode all instances of a single element from a binary .ply file. + + Args: + f: file-like object being read. + definition: The element object which describes what we are reading. + big_endian: (bool) whether the document is encoded as big endian. + + Returns: + In simple cases where every element has the same size, 2D numpy array + corresponding to the data. The rows are the different values. + Otherwise a list of lists/tuples of values, where the outer list is + each occurence of the element, and the inner lists have one value per + property. + """ + endian_str = ">" if big_endian else "<" + + if definition.is_constant_type_fixed_size(): + return _read_ply_fixed_size_element_binary(f, definition, big_endian) + if definition.is_fixed_size(): + return _read_ply_element_struct(f, definition, endian_str) + if definition.try_constant_list(): + data = _try_read_ply_constant_list_binary(f, definition, big_endian) + if data is not None: + return data + + # We failed to read the element as a lump, must process each line manually. + property_structs = [] + for property in definition.properties: + initial_type = property.list_size_type or property.data_type + property_structs.append( + struct.Struct(endian_str + _PLY_TYPES[initial_type].struct_char) + ) + + data = [] + for _i in range(definition.count): + datum = [] + for property, property_struct in zip( + definition.properties, property_structs + ): + size = property_struct.size + initial_data = f.read(size) + if len(initial_data) != size: + raise ValueError("Not enough data for %s" % definition.name) + [initial] = property_struct.unpack(initial_data) + if property.list_size_type is None: + datum.append(initial) + else: + type_size = _PLY_TYPES[property.data_type].size + needed_bytes = type_size * initial + list_data = f.read(needed_bytes) + if len(list_data) != needed_bytes: + raise ValueError("Not enough data for %s" % definition.name) + np_type = _PLY_TYPES[property.data_type].np_type + list_np = np.frombuffer(list_data, dtype=np_type) + if (sys.byteorder == "big") != big_endian: + list_np = list_np.byteswap() + datum.append(list_np) + data.append(datum) + return data + + +def _load_ply_raw_stream(f) -> Tuple[_PlyHeader, dict]: + """ + Implementation for _load_ply_raw which takes a stream. + + Args: + f: A binary or text file-like object. + + Returns: + header: A _PlyHeader object describing the metadata in the ply file. + elements: A dictionary of element names to values. If an element is regular, in + the sense of having no lists or being one uniformly-sized list, then the + value will be a 2D numpy array. If not, it is a list of the relevant + property values. + """ + + header = _PlyHeader(f) + elements = {} + if header.ascii: + for element in header.elements: + elements[element.name] = _read_ply_element_ascii(f, element) + else: + big = header.big_endian + for element in header.elements: + elements[element.name] = _read_ply_element_binary(f, element, big) + end = f.read().strip() + if len(end) != 0: + raise ValueError("Extra data at end of file: " + str(end[:20])) + return header, elements + + +def _load_ply_raw(f) -> Tuple[_PlyHeader, dict]: + """ + Load the data from a .ply file. + + Args: + f: A binary or text file-like object (with methods read, readline, + tell and seek), a pathlib path or a string containing a file name. + If the ply file is binary, a text stream is not supported. + It is recommended to use a binary stream. + + Returns: + header: A _PlyHeader object describing the metadata in the ply file. + elements: A dictionary of element names to values. If an element is + regular, in the sense of having no lists or being one + uniformly-sized list, then the value will be a 2D numpy array. + If not, it is a list of the relevant property values. + """ + new_f = False + if isinstance(f, str): + new_f = True + f = open(f, "rb") + elif isinstance(f, pathlib.Path): + new_f = True + f = f.open("rb") + try: + header, elements = _load_ply_raw_stream(f) + finally: + if new_f: + f.close() + + return header, elements + + +def load_ply(f): + """ + Load the data from a .ply file. + + Example .ply file format: + + ply + format ascii 1.0 { ascii/binary, format version number } + comment made by Greg Turk { comments keyword specified, like all lines } + comment this file is a cube + element vertex 8 { define "vertex" element, 8 of them in file } + property float x { vertex contains float "x" coordinate } + property float y { y coordinate is also a vertex property } + property float z { z coordinate, too } + element face 6 { there are 6 "face" elements in the file } + property list uchar int vertex_index { "vertex_indices" is a list of ints } + end_header { delimits the end of the header } + 0 0 0 { start of vertex list } + 0 0 1 + 0 1 1 + 0 1 0 + 1 0 0 + 1 0 1 + 1 1 1 + 1 1 0 + 4 0 1 2 3 { start of face list } + 4 7 6 5 4 + 4 0 4 5 1 + 4 1 5 6 2 + 4 2 6 7 3 + 4 3 7 4 0 + + Args: + f: A binary or text file-like object (with methods read, readline, + tell and seek), a pathlib path or a string containing a file name. + If the ply file is in the binary ply format rather than the text + ply format, then a text stream is not supported. + It is easiest to use a binary stream in all cases. + + Returns: + verts: FloatTensor of shape (V, 3). + faces: LongTensor of vertex indices, shape (F, 3). + """ + header, elements = _load_ply_raw(f) + + vertex = elements.get("vertex", None) + if vertex is None: + raise ValueError("The ply file has no vertex element.") + + face = elements.get("face", None) + if face is None: + raise ValueError("The ply file has no face element.") + + if ( + not isinstance(vertex, np.ndarray) + or vertex.ndim != 2 + or vertex.shape[1] != 3 + ): + raise ValueError("Invalid vertices in file.") + verts = torch.tensor(vertex, dtype=torch.float32) + + face_head = next(head for head in header.elements if head.name == "face") + if ( + len(face_head.properties) != 1 + or face_head.properties[0].list_size_type is None + ): + raise ValueError("Unexpected form of faces data.") + # face_head.properties[0].name is usually "vertex_index" or "vertex_indices" + # but we don't need to enforce this. + if isinstance(face, np.ndarray) and face.ndim == 2: + if face.shape[1] < 3: + raise ValueError("Faces must have at least 3 vertices.") + face_arrays = [ + face[:, [0, i + 1, i + 2]] for i in range(face.shape[1] - 2) + ] + faces = torch.tensor(np.vstack(face_arrays), dtype=torch.int64) + else: + face_list = [] + for face_item in face: + if face_item.ndim != 1: + raise ValueError("Bad face data.") + if face_item.shape[0] < 3: + raise ValueError("Faces must have at least 3 vertices.") + for i in range(face_item.shape[0] - 2): + face_list.append( + [face_item[0], face_item[i + 1], face_item[i + 2]] + ) + faces = torch.tensor(face_list, dtype=torch.int64) + + return verts, faces + + +def _save_ply(f, verts, faces, decimal_places: Optional[int]): + """ + Internal implementation for saving a mesh to a .ply file. + + Args: + f: File object to which the mesh should be written. + verts: FloatTensor of shape (V, 3) giving vertex coordinates. + faces: LongTensor of shape (F, 3) giving faces. + decimal_places: Number of decimal places for saving. + """ + print("ply\nformat ascii 1.0", file=f) + print(f"element vertex {verts.shape[0]}", file=f) + print("property float x", file=f) + print("property float y", file=f) + print("property float z", file=f) + print(f"element face {faces.shape[0]}", file=f) + print("property list uchar int vertex_index", file=f) + print("end_header", file=f) + + if decimal_places is None: + float_str = "%f" + else: + float_str = "%" + ".%df" % decimal_places + + np.savetxt(f, verts.detach().numpy(), float_str) + np.savetxt(f, faces.detach().numpy(), "3 %d %d %d") + + +def save_ply(f, verts, faces, decimal_places: Optional[int] = None): + """ + Save a mesh to a .ply file. + + Args: + f: File (or path) to which the mesh should be written. + verts: FloatTensor of shape (V, 3) giving vertex coordinates. + faces: LongTensor of shape (F, 3) giving faces. + decimal_places: Number of decimal places for saving. + """ + new_f = False + if isinstance(f, str): + new_f = True + f = open(f, "w") + elif isinstance(f, pathlib.Path): + new_f = True + f = f.open("w") + try: + _save_ply(f, verts, faces, decimal_places) + finally: + if new_f: + f.close() diff --git a/pytorch3d/loss/__init__.py b/pytorch3d/loss/__init__.py new file mode 100644 index 00000000..adb362fd --- /dev/null +++ b/pytorch3d/loss/__init__.py @@ -0,0 +1,9 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from .chamfer import chamfer_distance +from .mesh_edge_loss import mesh_edge_loss +from .mesh_laplacian_smoothing import mesh_laplacian_smoothing +from .mesh_normal_consistency import mesh_normal_consistency + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/loss/chamfer.py b/pytorch3d/loss/chamfer.py new file mode 100644 index 00000000..c9472fcc --- /dev/null +++ b/pytorch3d/loss/chamfer.py @@ -0,0 +1,152 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import torch +import torch.nn.functional as F + +from pytorch3d.ops.nearest_neighbor_points import nn_points_idx + + +def _validate_chamfer_reduction_inputs( + batch_reduction: str, point_reduction: str +): + """Check the requested reductions are valid. + + Args: + batch_reduction: Reduction operation to apply for the loss across the + batch, can be one of ["none", "mean", "sum"]. + point_reduction: Reduction operation to apply for the loss across the + points, can be one of ["none", "mean", "sum"]. + """ + if batch_reduction not in ["none", "mean", "sum"]: + raise ValueError( + 'batch_reduction must be one of ["none", "mean", "sum"]' + ) + if point_reduction not in ["none", "mean", "sum"]: + raise ValueError( + 'point_reduction must be one of ["none", "mean", "sum"]' + ) + if batch_reduction == "none" and point_reduction == "none": + raise ValueError( + 'batch_reduction and point_reduction cannot both be "none".' + ) + + +def chamfer_distance( + x, + y, + x_normals=None, + y_normals=None, + weights=None, + batch_reduction: str = "mean", + point_reduction: str = "mean", +): + """ + Chamfer distance between two pointclouds x and y. + + Args: + x: FloatTensor of shape (N, P1, D) representing a batch of point clouds + with P1 points in each batch element, batch size N and feature + dimension D. + y: FloatTensor of shape (N, P2, D) representing a batch of point clouds + with P2 points in each batch element, batch size N and feature + dimension D. + x_normals: Optional FloatTensor of shape (N, P1, D). + y_normals: Optional FloatTensor of shape (N, P2, D). + weights: Optional FloatTensor of shape (N,) giving weights for + batch elements for reduction operation. + batch_reduction: Reduction operation to apply for the loss across the + batch, can be one of ["none", "mean", "sum"]. + point_reduction: Reduction operation to apply for the loss across the + points, can be one of ["none", "mean", "sum"]. + + Returns: + 2-element tuple containing + + - **loss**: Tensor giving the reduced distance between the pointclouds + in x and the pointclouds in y. + - **loss_normals**: Tensor giving the reduced cosine distance of normals + between pointclouds in x and pointclouds in y. Returns None if + x_normals and y_normals are None. + """ + _validate_chamfer_reduction_inputs(batch_reduction, point_reduction) + + N, P1, D = x.shape + P2 = y.shape[1] + + if y.shape[0] != N or y.shape[2] != D: + raise ValueError("y does not have the correct shape.") + if weights is not None: + if weights.size(0) != N: + raise ValueError("weights must be of shape (N,).") + if not (weights >= 0).all(): + raise ValueError("weights can not be nonnegative.") + if weights.sum() == 0.0: + weights = weights.view(N, 1) + if batch_reduction in ["mean", "sum"]: + return ( + (x.sum((1, 2)) * weights).sum() * 0.0, + (x.sum((1, 2)) * weights).sum() * 0.0, + ) + return ( + (x.sum((1, 2)) * weights) * 0.0, + (x.sum((1, 2)) * weights) * 0.0, + ) + + return_normals = x_normals is not None and y_normals is not None + cham_norm_x = x.new_zeros(()) + cham_norm_y = x.new_zeros(()) + + x_near, xidx_near, x_normals_near = nn_points_idx(x, y, y_normals) + y_near, yidx_near, y_normals_near = nn_points_idx(y, x, x_normals) + + cham_x = (x - x_near).norm(dim=2, p=2) ** 2.0 # (N, P1) + cham_y = (y - y_near).norm(dim=2, p=2) ** 2.0 # (N, P2) + + if weights is not None: + cham_x *= weights.view(N, 1) + cham_y *= weights.view(N, 1) + + if return_normals: + cham_norm_x = 1 - torch.abs( + F.cosine_similarity(x_normals, x_normals_near, dim=2, eps=1e-6) + ) + cham_norm_y = 1 - torch.abs( + F.cosine_similarity(y_normals, y_normals_near, dim=2, eps=1e-6) + ) + if weights is not None: + cham_norm_x *= weights.view(N, 1) + cham_norm_y *= weights.view(N, 1) + + if point_reduction != "none": + # If not 'none' then either 'sum' or 'mean'. + cham_x = cham_x.sum(1) # (N,) + cham_y = cham_y.sum(1) # (N,) + if return_normals: + cham_norm_x = cham_norm_x.sum(1) # (N,) + cham_norm_y = cham_norm_y.sum(1) # (N,) + if point_reduction == "mean": + cham_x /= P1 + cham_y /= P2 + if return_normals: + cham_norm_x /= P1 + cham_norm_y /= P2 + + if batch_reduction != "none": + cham_x = cham_x.sum() + cham_y = cham_y.sum() + if return_normals: + cham_norm_x = cham_norm_x.sum() + cham_norm_y = cham_norm_y.sum() + if batch_reduction == "mean": + div = weights.sum() if weights is not None else N + cham_x /= div + cham_y /= div + if return_normals: + cham_norm_x /= div + cham_norm_y /= div + + cham_dist = cham_x + cham_y + cham_normals = cham_norm_x + cham_norm_y if return_normals else None + + return cham_dist, cham_normals diff --git a/pytorch3d/loss/mesh_edge_loss.py b/pytorch3d/loss/mesh_edge_loss.py new file mode 100644 index 00000000..77eaa9dc --- /dev/null +++ b/pytorch3d/loss/mesh_edge_loss.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import torch + + +def mesh_edge_loss(meshes, target_length: float = 0.0): + """ + Computes mesh edge length regularization loss averaged across all meshes + in a batch. Each edge contributes equally to the final loss, regardless of + numbers of edges per mesh in the batch by weighting each mesh with the + inverse number of edges. For example, if mesh 3 (out of N) has only E=4 + edges, then the loss for each edge in mesh 3 should be multiplied by 1/E to + contribute to the final loss. + + Args: + meshes: Meshes object with a batch of meshes. + target_length: Resting value for the edge length. + + Returns: + loss: Average loss across the batch. Returns 0 if meshes contains + no meshes or all empty meshes. + """ + if meshes.isempty(): + return torch.tensor( + [0.0], dtype=torch.float32, device=meshes.device, requires_grad=True + ) + + N = len(meshes) + edges_packed = meshes.edges_packed() # (sum(E_n), 3) + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + edge_to_mesh_idx = meshes.edges_packed_to_mesh_idx() # (sum(E_n), ) + num_edges_per_mesh = meshes.num_edges_per_mesh() # N + + # Determine the weight for each edge based on the number of edges in the + # mesh it corresponds to. + # TODO (nikhilar) Find a faster way of computing the weights for each edge + # as this is currently a bottleneck for meshes with a large number of faces. + weights = num_edges_per_mesh.gather(0, edge_to_mesh_idx) + weights = 1.0 / weights.float() + + verts_edges = verts_packed[edges_packed] + v0, v1 = verts_edges.unbind(1) + loss = ((v0 - v1).norm(dim=1, p=2) - target_length) ** 2.0 + loss = loss * weights + + return loss.sum() / N diff --git a/pytorch3d/loss/mesh_laplacian_smoothing.py b/pytorch3d/loss/mesh_laplacian_smoothing.py new file mode 100644 index 00000000..fb35ac41 --- /dev/null +++ b/pytorch3d/loss/mesh_laplacian_smoothing.py @@ -0,0 +1,195 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +import torch + + +def mesh_laplacian_smoothing(meshes, method: str = "uniform"): + r""" + Computes the laplacian smoothing objective for a batch of meshes. + This function supports three variants of Laplacian smoothing, + namely with uniform weights("uniform"), with cotangent weights ("cot"), + and cotangent cuvature ("cotcurv").For more details read [1, 2]. + + Args: + meshes: Meshes object with a batch of meshes. + method: str specifying the method for the laplacian. + Returns: + loss: Average laplacian smoothing loss across the batch. + Returns 0 if meshes contains no meshes or all empty meshes. + + Consider a mesh M = (V, F), with verts of shape Nx3 and faces of shape Mx3. + The Laplacian matrix L is a NxN tensor such that LV gives a tensor of vectors: + for a uniform Laplacian, LuV[i] points to the centroid of its neighboring + vertices, a cotangent Laplacian LcV[i] is known to be an approximation of + the surface normal, while the curvature variant LckV[i] scales the normals + by the discrete mean curvature. For vertex i, assume S[i] is the set of + neighboring vertices to i, a_ij and b_ij are the "outside" angles in the + two triangles connecting vertex v_i and its neighboring vertex v_j + for j in S[i], as seen in the diagram below. + + .. code-block:: python + + a_ij + /\ + / \ + / \ + / \ + v_i /________\ v_j + \ / + \ / + \ / + \ / + \/ + b_ij + + The definition of the Laplacian is LV[i] = sum_j w_ij (v_j - v_i) + For the uniform variant, w_ij = 1 / |S[i]| + For the cotangent variant, + w_ij = (cot a_ij + cot b_ij) / (sum_k cot a_ik + cot b_ik) + For the cotangent curvature, w_ij = (cot a_ij + cot b_ij) / (4 A[i]) + where A[i] is the sum of the areas of all triangles containing vertex v_i. + + There is a nice trigonometry identity to compute cotangents. Consider a triangle + with side lengths A, B, C and angles a, b, c. + + .. code-block:: python + + c + /|\ + / | \ + / | \ + B / H| \ A + / | \ + / | \ + /a_____|_____b\ + C + + Then cot a = (B^2 + C^2 - A^2) / 4 * area + We know that area = CH/2, and by the law of cosines we have + + A^2 = B^2 + C^2 - 2BC cos a => B^2 + C^2 - A^2 = 2BC cos a + + Putting these together, we get: + + B^2 + C^2 - A^2 2BC cos a + _______________ = _________ = (B/H) cos a = cos a / sin a = cot a + 4 * area 2CH + + + [1] Desbrun et al, "Implicit fairing of irregular meshes using diffusion + and curvature flow", SIGGRAPH 1999. + + [2] Nealan et al, "Laplacian Mesh Optimization", Graphite 2006. + """ + + if meshes.isempty(): + return torch.tensor( + [0.0], dtype=torch.float32, device=meshes.device, requires_grad=True + ) + + N = len(meshes) + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + num_verts_per_mesh = meshes.num_verts_per_mesh() # (N,) + verts_packed_idx = meshes.verts_packed_to_mesh_idx() # (sum(V_n),) + weights = num_verts_per_mesh.gather(0, verts_packed_idx) # (sum(V_n),) + weights = 1.0 / weights.float() + + # We don't want to backprop through the computation of the Laplacian; + # just treat it as a magic constant matrix that is used to transform + # verts into normals + with torch.no_grad(): + if method == "uniform": + L = meshes.laplacian_packed() + elif method in ["cot", "cotcurv"]: + L, inv_areas = laplacian_cot(meshes) + if method == "cot": + norm_w = torch.sparse.sum(L, dim=1).to_dense().view(-1, 1) + idx = norm_w > 0 + norm_w[idx] = 1.0 / norm_w[idx] + else: + norm_w = 0.25 * inv_areas + else: + raise ValueError("Method should be one of {uniform, cot, cotcurv}") + + if method == "uniform": + loss = L.mm(verts_packed) + elif method == "cot": + loss = L.mm(verts_packed) * norm_w - verts_packed + elif method == "cotcurv": + loss = (L.mm(verts_packed) - verts_packed) * norm_w + loss = loss.norm(dim=1) + + loss = loss * weights + return loss.sum() / N + + +def laplacian_cot(meshes): + """ + Returns the Laplacian matrix with cotangent weights and the inverse of the + face areas. + + Args: + meshes: Meshes object with a batch of meshes. + Returns: + 2-element tuple containing + - **L**: FloatTensor of shape (V,V) for the Laplacian matrix (V = sum(V_n)) + Here, L[i, j] = cot a_ij + cot b_ij iff (i, j) is an edge in meshes. + See the description above for more clarity. + - **inv_areas**: FloatTensor of shape (V,) containing the inverse of sum of + face areas containing each vertex + """ + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + faces_packed = meshes.faces_packed() # (sum(F_n), 3) + # V = sum(V_n), F = sum(F_n) + V, F = verts_packed.shape[0], faces_packed.shape[0] + + face_verts = verts_packed[faces_packed] + v0, v1, v2 = face_verts[:, 0], face_verts[:, 1], face_verts[:, 2] + + # Side lengths of each triangle, of shape (sum(F_n),) + # A is the side opposite v1, B is opposite v2, and C is opposite v3 + A = (v1 - v2).norm(dim=1) + B = (v0 - v2).norm(dim=1) + C = (v0 - v1).norm(dim=1) + + # Area of each triangle (with Heron's formula); shape is (sum(F_n),) + s = 0.5 * (A + B + C) + # note that the area can be negative (close to 0) causing nans after sqrt() + # we clip it to a small positive value + area = (s * (s - A) * (s - B) * (s - C)).clamp_(min=1e-12).sqrt() + + # Compute cotangents of angles, of shape (sum(F_n), 3) + A2, B2, C2 = A * A, B * B, C * C + cota = (B2 + C2 - A2) / area + cotb = (A2 + C2 - B2) / area + cotc = (A2 + B2 - C2) / area + cot = torch.stack([cota, cotb, cotc], dim=1) + cot /= 4.0 + + # Construct a sparse matrix by basically doing: + # L[v1, v2] = cota + # L[v2, v0] = cotb + # L[v0, v1] = cotc + ii = faces_packed[:, [1, 2, 0]] + jj = faces_packed[:, [2, 0, 1]] + idx = torch.stack([ii, jj], dim=0).view(2, F * 3) + L = torch.sparse.FloatTensor(idx, cot.view(-1), (V, V)) + + # Make it symmetric; this means we are also setting + # L[v2, v1] = cota + # L[v0, v2] = cotb + # L[v1, v0] = cotc + L += L.t() + + # For each vertex, compute the sum of areas for triangles containing it. + idx = faces_packed.view(-1) + inv_areas = torch.zeros(V, dtype=torch.float32, device=meshes.device) + val = torch.stack([area] * 3, dim=1).view(-1) + inv_areas.scatter_add_(0, idx, val) + idx = inv_areas > 0 + inv_areas[idx] = 1.0 / inv_areas[idx] + inv_areas = inv_areas.view(-1, 1) + + return L, inv_areas diff --git a/pytorch3d/loss/mesh_normal_consistency.py b/pytorch3d/loss/mesh_normal_consistency.py new file mode 100644 index 00000000..19660291 --- /dev/null +++ b/pytorch3d/loss/mesh_normal_consistency.py @@ -0,0 +1,148 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +from itertools import islice +import torch + + +def mesh_normal_consistency(meshes): + r""" + Computes the normal consistency of each mesh in meshes. + We compute the normal consistency for each pair of neighboring faces. + If e = (v0, v1) is the connecting edge of two neighboring faces f0 and f1, + then the normal consistency between f0 and f1 + + .. code-block:: python + + a + /\ + / \ + / f0 \ + / \ + v0 /____e___\ v1 + \ / + \ / + \ f1 / + \ / + \/ + b + + The normal consistency is + + .. code-block:: python + + nc(f0, f1) = 1 - cos(n0, n1) + + where cos(n0, n1) = n0^n1 / ||n0|| / ||n1|| is the cosine of the angle + between the normals n0 and n1, and + + n0 = (v1 - v0) x (a - v0) + n1 = - (v1 - v0) x (b - v0) = (b - v0) x (v1 - v0) + + This means that if nc(f0, f1) = 0 then n0 and n1 point to the same + direction, while if nc(f0, f1) = 2 then n0 and n1 point opposite direction. + + .. note:: + For well-constructed meshes the assumption that only two faces share an + edge is true. This assumption could make the implementation easier and faster. + This implementation does not follow this assumption. All the faces sharing e, + which can be any in number, are discovered. + + Args: + meshes: Meshes object with a batch of meshes. + + Returns: + loss: Average normal consistency across the batch. + Returns 0 if meshes contains no meshes or all empty meshes. + """ + if meshes.isempty(): + return torch.tensor( + [0.0], dtype=torch.float32, device=meshes.device, requires_grad=True + ) + + N = len(meshes) + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + faces_packed = meshes.faces_packed() # (sum(F_n), 3) + edges_packed = meshes.edges_packed() # (sum(E_n), 2) + verts_packed_to_mesh_idx = meshes.verts_packed_to_mesh_idx() # (sum(V_n),) + face_to_edge = meshes.faces_packed_to_edges_packed() # (sum(F_n), 3) + E = edges_packed.shape[0] # sum(E_n) + F = faces_packed.shape[0] # sum(F_n) + + # We don't want gradients for the following operation. The goal is to + # find for each edge e all the vertices associated with e. In the example above, + # the vertices associated with e are (v0, v1, a, b), i.e. points on e (=v0, v1) + # and points connected on faces to e (=a, b). + with torch.no_grad(): + edge_idx = face_to_edge.reshape(F * 3) # (3 * F,) indexes into edges + vert_idx = ( + faces_packed.view(1, F, 3) + .expand(3, F, 3) + .transpose(0, 1) + .reshape(3 * F, 3) + ) + edge_idx, edge_sort_idx = edge_idx.sort() + vert_idx = vert_idx[edge_sort_idx] + + # In well constructed meshes each edge is shared by precisely 2 faces + # However, in many meshes, this assumption is not always satisfied. + # We want to find all faces that share an edge, a number which can + # vary and which depends on the topology. + # In particular, we find the vertices not on the edge on the shared faces. + # In the example above, we want to associate edge e with vertices a and b. + # This operation is done more efficiently in cpu with lists. + # TODO(gkioxari) find a better way to do this. + + # edge_idx represents the index of the edge for each vertex. We can count + # the number of vertices which are associated with each edge. + # There can be a different number for each edge. + edge_num = edge_idx.bincount(minlength=E) + # Create pairs of vertices associated to e. We generate a list of lists: + # each list has the indices of the vertices which are opposite to one edge. + # The length of the list for each edge will vary. + vert_edge_pair_idx = split_list( + list(range(edge_idx.shape[0])), edge_num.tolist() + ) + # For each list find all combinations of pairs in the list. This represents + # all pairs of vertices which are opposite to the same edge. + vert_edge_pair_idx = [ + [e[i], e[j]] + for e in vert_edge_pair_idx + for i in range(len(e) - 1) + for j in range(1, len(e)) + if i != j + ] + vert_edge_pair_idx = torch.tensor( + vert_edge_pair_idx, device=meshes.device, dtype=torch.int64 + ) + + v0_idx = edges_packed[edge_idx, 0] + v0 = verts_packed[v0_idx] + v1_idx = edges_packed[edge_idx, 1] + v1 = verts_packed[v1_idx] + + # two of the following cross products are zeros as they are cross product + # with either (v1-v0)x(v1-v0) or (v1-v0)x(v0-v0) + n_temp0 = (v1 - v0).cross(verts_packed[vert_idx[:, 0]] - v0, dim=1) + n_temp1 = (v1 - v0).cross(verts_packed[vert_idx[:, 1]] - v0, dim=1) + n_temp2 = (v1 - v0).cross(verts_packed[vert_idx[:, 2]] - v0, dim=1) + n = n_temp0 + n_temp1 + n_temp2 + n0 = n[vert_edge_pair_idx[:, 0]] + n1 = -n[vert_edge_pair_idx[:, 1]] + loss = 1 - torch.cosine_similarity(n0, n1, dim=1) + + verts_packed_to_mesh_idx = verts_packed_to_mesh_idx[vert_idx[:, 0]] + verts_packed_to_mesh_idx = verts_packed_to_mesh_idx[ + vert_edge_pair_idx[:, 0] + ] + num_normals = verts_packed_to_mesh_idx.bincount(minlength=N) + weights = 1.0 / num_normals[verts_packed_to_mesh_idx].float() + + loss = loss * weights + return loss.sum() / N + + +def split_list(input, length_to_split): + inputt = iter(input) + return [list(islice(inputt, elem)) for elem in length_to_split] diff --git a/pytorch3d/ops/__init__.py b/pytorch3d/ops/__init__.py new file mode 100644 index 00000000..9cd3b4dc --- /dev/null +++ b/pytorch3d/ops/__init__.py @@ -0,0 +1,11 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from .cubify import cubify +from .graph_conv import GraphConv +from .nearest_neighbor_points import nn_points_idx +from .sample_points_from_meshes import sample_points_from_meshes +from .subdivide_meshes import SubdivideMeshes +from .vert_align import vert_align + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/ops/cubify.py b/pytorch3d/ops/cubify.py new file mode 100644 index 00000000..a64826f3 --- /dev/null +++ b/pytorch3d/ops/cubify.py @@ -0,0 +1,208 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn.functional as F + +from pytorch3d.structures import Meshes + + +def unravel_index(idx, dims) -> torch.Tensor: + r""" + Equivalent to np.unravel_index + Args: + idx: A LongTensor whose elements are indices into the + flattened version of an array of dimensions dims. + dims: The shape of the array to be indexed. + Implemented only for dims=(N, H, W, D) + """ + if len(dims) != 4: + raise ValueError("Expects a 4-element list.") + N, H, W, D = dims + n = torch.div(idx, H * W * D) + h = torch.div(idx - n * H * W * D, W * D) + w = torch.div(idx - n * H * W * D - h * W * D, D) + d = idx - n * H * W * D - h * W * D - w * D + return torch.stack((n, h, w, d), dim=1) + + +def ravel_index(idx, dims) -> torch.Tensor: + """ + Computes the linear index in an array of shape dims. + It performs the reverse functionality of unravel_index + Args: + idx: A LongTensor of shape (N, 3). Each row corresponds to indices into an + array of dimensions dims. + dims: The shape of the array to be indexed. + Implemented only for dims=(H, W, D) + """ + if len(dims) != 3: + raise ValueError("Expects a 3-element list") + if idx.shape[1] != 3: + raise ValueError("Expects an index tensor of shape Nx3") + H, W, D = dims + linind = idx[:, 0] * W * D + idx[:, 1] * D + idx[:, 2] + return linind + + +@torch.no_grad() +def cubify(voxels, thresh, device=None) -> Meshes: + r""" + Converts a voxel to a mesh by replacing each occupied voxel with a cube + consisting of 12 faces and 8 vertices. Shared vertices are merged, and + internal faces are removed. + Args: + voxels: A FloatTensor of shape (N, D, H, W) containing occupancy probabilities. + thresh: A scalar threshold. If a voxel occupancy is larger than + thresh, the voxel is considered occupied. + Returns: + meshes: A Meshes object of the corresponding meshes. + """ + + if device is None: + device = voxels.device + + if len(voxels) == 0: + return Meshes(verts=[], faces=[]) + + N, D, H, W = voxels.size() + # vertices corresponding to a unit cube: 8x3 + cube_verts = torch.tensor( + [ + [0, 0, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 1], + [1, 0, 0], + [1, 0, 1], + [1, 1, 0], + [1, 1, 1], + ], + dtype=torch.int64, + device=device, + ) + + # faces corresponding to a unit cube: 12x3 + cube_faces = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], # left face: 0, 1 + [2, 3, 6], + [3, 7, 6], # bottom face: 2, 3 + [0, 2, 6], + [0, 6, 4], # front face: 4, 5 + [0, 5, 1], + [0, 4, 5], # up face: 6, 7 + [6, 7, 5], + [6, 5, 4], # right face: 8, 9 + [1, 7, 3], + [1, 5, 7], # back face: 10, 11 + ], + dtype=torch.int64, + device=device, + ) + + wx = torch.tensor([0.5, 0.5], device=device).view(1, 1, 1, 1, 2) + wy = torch.tensor([0.5, 0.5], device=device).view(1, 1, 1, 2, 1) + wz = torch.tensor([0.5, 0.5], device=device).view(1, 1, 2, 1, 1) + + voxelt = voxels.ge(thresh).float() + # N x 1 x D x H x W + voxelt = voxelt.view(N, 1, D, H, W) + + # N x 1 x (D-1) x (H-1) x (W-1) + voxelt_x = F.conv3d(voxelt, wx).gt(0.5).float() + voxelt_y = F.conv3d(voxelt, wy).gt(0.5).float() + voxelt_z = F.conv3d(voxelt, wz).gt(0.5).float() + + # 12 x N x 1 x D x H x W + faces_idx = torch.ones((cube_faces.size(0), N, 1, D, H, W), device=device) + + # add left face + faces_idx[0, :, :, :, :, 1:] = 1 - voxelt_x + faces_idx[1, :, :, :, :, 1:] = 1 - voxelt_x + # add bottom face + faces_idx[2, :, :, :, :-1, :] = 1 - voxelt_y + faces_idx[3, :, :, :, :-1, :] = 1 - voxelt_y + # add front face + faces_idx[4, :, :, 1:, :, :] = 1 - voxelt_z + faces_idx[5, :, :, 1:, :, :] = 1 - voxelt_z + # add up face + faces_idx[6, :, :, :, 1:, :] = 1 - voxelt_y + faces_idx[7, :, :, :, 1:, :] = 1 - voxelt_y + # add right face + faces_idx[8, :, :, :, :, :-1] = 1 - voxelt_x + faces_idx[9, :, :, :, :, :-1] = 1 - voxelt_x + # add back face + faces_idx[10, :, :, :-1, :, :] = 1 - voxelt_z + faces_idx[11, :, :, :-1, :, :] = 1 - voxelt_z + + faces_idx *= voxelt + + # N x H x W x D x 12 + faces_idx = faces_idx.permute(1, 2, 4, 5, 3, 0).squeeze(1) + # (NHWD) x 12 + faces_idx = faces_idx.contiguous() + faces_idx = faces_idx.view(-1, cube_faces.size(0)) + + # boolean to linear index + # NF x 2 + linind = torch.nonzero(faces_idx) + # NF x 4 + nyxz = unravel_index(linind[:, 0], (N, H, W, D)) + + # NF x 3: faces + faces = torch.index_select(cube_faces, 0, linind[:, 1]) + + grid_faces = [] + for d in range(cube_faces.size(1)): + # NF x 3 + xyz = torch.index_select(cube_verts, 0, faces[:, d]) + permute_idx = torch.tensor([1, 0, 2], device=device) + yxz = torch.index_select(xyz, 1, permute_idx) + yxz += nyxz[:, 1:] + # NF x 1 + temp = ravel_index(yxz, (H + 1, W + 1, D + 1)) + grid_faces.append(temp) + # NF x 3 + grid_faces = torch.stack(grid_faces, dim=1) + + y, x, z = torch.meshgrid( + torch.arange(H + 1), torch.arange(W + 1), torch.arange(D + 1) + ) + y = y.to(device=device, dtype=torch.float32) + y = y * 2.0 / (H - 1.0) - 1.0 + x = x.to(device=device, dtype=torch.float32) + x = x * 2.0 / (W - 1.0) - 1.0 + z = z.to(device=device, dtype=torch.float32) + z = z * 2.0 / (D - 1.0) - 1.0 + # ((H+1)(W+1)(D+1)) x 3 + grid_verts = torch.stack((x, y, z), dim=3).view(-1, 3) + + if len(nyxz) == 0: + verts_list = [torch.tensor([], dtype=torch.float32, device=device)] * N + faces_list = [torch.tensor([], dtype=torch.int64, device=device)] * N + return Meshes(verts=verts_list, faces=faces_list) + + num_verts = grid_verts.size(0) + grid_faces += nyxz[:, 0].view(-1, 1) * num_verts + idleverts = torch.ones(num_verts * N, dtype=torch.uint8, device=device) + + idleverts.scatter_(0, grid_faces.flatten(), 0) + grid_faces -= nyxz[:, 0].view(-1, 1) * num_verts + split_size = torch.bincount(nyxz[:, 0], minlength=N) + faces_list = list(torch.split(grid_faces, split_size.tolist(), 0)) + + idleverts = idleverts.view(N, num_verts) + idlenum = idleverts.cumsum(1) + + verts_list = [ + grid_verts.index_select(0, (idleverts[n] == 0).nonzero()[:, 0]) + for n in range(N) + ] + faces_list = [ + nface - idlenum[n][nface] for n, nface in enumerate(faces_list) + ] + + return Meshes(verts=verts_list, faces=faces_list) diff --git a/pytorch3d/ops/graph_conv.py b/pytorch3d/ops/graph_conv.py new file mode 100644 index 00000000..4aac8a84 --- /dev/null +++ b/pytorch3d/ops/graph_conv.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn as nn +from torch.autograd import Function +from torch.autograd.function import once_differentiable + +from pytorch3d import _C + + +class GraphConv(nn.Module): + """A single graph convolution layer.""" + + def __init__( + self, + input_dim: int, + output_dim: int, + init: str = "normal", + directed: bool = False, + ): + """ + Args: + input_dim: Number of input features per vertex. + output_dim: Number of output features per vertex. + init: Weight initialization method. Can be one of ['zero', 'normal']. + directed: Bool indicating if edges in the graph are directed. + """ + super().__init__() + self.input_dim = input_dim + self.output_dim = output_dim + self.directed = directed + self.w0 = nn.Linear(input_dim, output_dim) + self.w1 = nn.Linear(input_dim, output_dim) + + if init == "normal": + nn.init.normal_(self.w0.weight, mean=0, std=0.01) + nn.init.normal_(self.w1.weight, mean=0, std=0.01) + self.w0.bias.data.zero_() + self.w1.bias.data.zero_() + elif init == "zero": + self.w0.weight.data.zero_() + self.w1.weight.data.zero_() + else: + raise ValueError('Invalid GraphConv initialization "%s"' % init) + + def forward(self, verts, edges): + """ + Args: + verts: FloatTensor of shape (V, input_dim) where V is the number of + vertices and input_dim is the number of input features + per vertex. input_dim has to match the input_dim specified + in __init__. + edges: LongTensor of shape (E, 2) where E is the number of edges + where each edge has the indices of the two vertices which + form the edge. + + Returns: + out: FloatTensor of shape (V, output_dim) where output_dim is the + number of output features per vertex. + """ + if verts.is_cuda != edges.is_cuda: + raise ValueError( + "verts and edges tensors must be on the same device." + ) + if verts.shape[0] == 0: + # empty graph. + return verts.sum() * 0.0 + + verts_w0 = self.w0(verts) # (V, output_dim) + verts_w1 = self.w1(verts) # (V, output_dim) + + if torch.cuda.is_available() and verts.is_cuda and edges.is_cuda: + neighbor_sums = gather_scatter(verts_w1, edges, self.directed) + else: + neighbor_sums = gather_scatter_python( + verts_w1, edges, self.directed + ) # (V, output_dim) + + # Add neighbor features to each vertex's features. + out = verts_w0 + neighbor_sums + return out + + def __repr__(self): + Din, Dout, directed = self.input_dim, self.output_dim, self.directed + return "GraphConv(%d -> %d, directed=%r)" % (Din, Dout, directed) + + +def gather_scatter_python(input, edges, directed: bool = False): + """ + Python implementation of gather_scatter for aggregating features of + neighbor nodes in a graph. + + Given a directed graph: v0 -> v1 -> v2 the updated feature for v1 depends + on v2 in order to be consistent with Morris et al. AAAI 2019 + (https://arxiv.org/abs/1810.02244). This only affects + directed graphs; for undirected graphs v1 will depend on both v0 and v2, + no matter which way the edges are physically stored. + + Args: + input: Tensor of shape (num_vertices, input_dim). + edges: Tensor of edge indices of shape (num_edges, 2). + directed: bool indicating if edges are directed. + + Returns: + output: Tensor of same shape as input. + """ + if not (input.dim() == 2): + raise ValueError("input can only have 2 dimensions.") + if not (edges.dim() == 2): + raise ValueError("edges can only have 2 dimensions.") + if not (edges.shape[1] == 2): + raise ValueError("edges must be of shape (num_edges, 2).") + + num_vertices, input_feature_dim = input.shape + num_edges = edges.shape[0] + output = torch.zeros_like(input) + idx0 = edges[:, 0].view(num_edges, 1).expand(num_edges, input_feature_dim) + idx1 = edges[:, 1].view(num_edges, 1).expand(num_edges, input_feature_dim) + + output = output.scatter_add(0, idx0, input.gather(0, idx1)) + if not directed: + output = output.scatter_add(0, idx1, input.gather(0, idx0)) + return output + + +class GatherScatter(Function): + """ + Torch autograd Function wrapper for gather_scatter C++/CUDA implementations. + """ + + @staticmethod + def forward(ctx, input, edges, directed=False): + """ + Args: + ctx: Context object used to calculate gradients. + input: Tensor of shape (num_vertices, input_dim) + edges: Tensor of edge indices of shape (num_edges, 2) + directed: Bool indicating if edges are directed. + + Returns: + output: Tensor of same shape as input. + """ + if not (input.dim() == 2): + raise ValueError("input can only have 2 dimensions.") + if not (edges.dim() == 2): + raise ValueError("edges can only have 2 dimensions.") + if not (edges.shape[1] == 2): + raise ValueError("edges must be of shape (num_edges, 2).") + if not (input.dtype == torch.float32): + raise ValueError("input has to be of type torch.float32.") + + ctx.directed = directed + input, edges = input.contiguous(), edges.contiguous() + ctx.save_for_backward(edges) + backward = False + output = _C.gather_scatter(input, edges, directed, backward) + return output + + @staticmethod + @once_differentiable + def backward(ctx, grad_output): + grad_output = grad_output.contiguous() + edges = ctx.saved_tensors[0] + directed = ctx.directed + backward = True + grad_input = _C.gather_scatter(grad_output, edges, directed, backward) + grad_edges = None + grad_directed = None + return grad_input, grad_edges, grad_directed + + +gather_scatter = GatherScatter.apply diff --git a/pytorch3d/ops/nearest_neighbor_points.py b/pytorch3d/ops/nearest_neighbor_points.py new file mode 100644 index 00000000..0ea44055 --- /dev/null +++ b/pytorch3d/ops/nearest_neighbor_points.py @@ -0,0 +1,47 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch + +from pytorch3d import _C + + +def nn_points_idx(p1, p2, p2_normals=None) -> torch.Tensor: + """ + Compute the coordinates of nearest neighbors in pointcloud p2 to points in p1. + Args: + p1: FloatTensor of shape (N, P1, D) giving a batch of pointclouds each + containing P1 points of dimension D. + p2: FloatTensor of shape (N, P2, D) giving a batch of pointclouds each + containing P2 points of dimension D. + p2_normals: [optional] FloatTensor of shape (N, P2, D) giving + normals for p2. Default: None. + + Returns: + 3-element tuple containing + + - **p1_nn_points**: FloatTensor of shape (N, P1, D) where + p1_neighbors[n, i] is the point in p2[n] which is + the nearest neighbor to p1[n, i]. + - **p1_nn_idx**: LongTensor of shape (N, P1) giving the indices of + the neighbors. + - **p1_nn_normals**: Normal vectors for each point in p1_neighbors; + only returned if p2_normals is passed + else return []. + """ + N, P1, D = p1.shape + with torch.no_grad(): + p1_nn_idx = _C.nn_points_idx( + p1.contiguous(), p2.contiguous() + ) # (N, P1) + p1_nn_idx_expanded = p1_nn_idx.view(N, P1, 1).expand(N, P1, D) + p1_nn_points = p2.gather(1, p1_nn_idx_expanded) + if p2_normals is None: + p1_nn_normals = [] + else: + if p2_normals.shape != p2.shape: + raise ValueError("p2_normals has incorrect shape.") + p1_nn_normals = p2_normals.gather(1, p1_nn_idx_expanded) + + return p1_nn_points, p1_nn_idx, p1_nn_normals diff --git a/pytorch3d/ops/sample_points_from_meshes.py b/pytorch3d/ops/sample_points_from_meshes.py new file mode 100644 index 00000000..0fab7830 --- /dev/null +++ b/pytorch3d/ops/sample_points_from_meshes.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +""" +This module implements utility functions for sampling points from +batches of meshes. +""" +import sys +from typing import Tuple, Union +import torch + +from pytorch3d import _C + + +def sample_points_from_meshes( + meshes, num_samples: int = 10000, return_normals: bool = False +) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]: + """ + Convert a batch of meshes to a pointcloud by uniformly sampling points on + the surface of the mesh with probability proportional to the face area. + + Args: + meshes: A Meshes object with a batch of N meshes. + num_samples: Integer giving the number of point samples per mesh. + return_normals: If True, return normals for the sampled points. + eps: (float) used to clamp the norm of the normals to avoid dividing by 0. + + Returns: + 2-element tuple containing + + - **samples**: FloatTensor of shape (N, num_samples, 3) giving the + coordinates of sampled points for each mesh in the batch. For empty + meshes the corresponding row in the samples array will be filled with 0. + - **normals**: FloatTensor of shape (N, num_samples, 3) giving a normal vector + to each sampled point. Only returned if return_normals is True. + For empty meshes the corresponding row in the normals array will + be filled with 0. + """ + if meshes.isempty(): + raise ValueError("Meshes are empty.") + + verts = meshes.verts_packed() + faces = meshes.faces_packed() + mesh_to_face = meshes.mesh_to_faces_packed_first_idx() + num_meshes = len(meshes) + num_valid_meshes = torch.sum(meshes.valid) # Non empty meshes. + + # Intialize samples tensor with fill value 0 for empty meshes. + samples = torch.zeros((num_meshes, num_samples, 3), device=meshes.device) + + # Only compute samples for non empty meshes + with torch.no_grad(): + areas, _ = _C.face_areas_normals( + verts, faces + ) # Face areas can be zero. + max_faces = meshes.num_faces_per_mesh().max().item() + areas_padded = _C.packed_to_padded_tensor( + areas, mesh_to_face[meshes.valid], max_faces + ) # (N, F) + + # TODO (gkioxari) Confirm multinomial bug is not present with real data. + sample_face_idxs = areas_padded.multinomial( + num_samples, replacement=True + ) # (N, num_samples) + sample_face_idxs += mesh_to_face[meshes.valid].view(num_valid_meshes, 1) + + # Get the vertex coordinates of the sampled faces. + face_verts = verts[faces.long()] + v0, v1, v2 = face_verts[:, 0], face_verts[:, 1], face_verts[:, 2] + + # Randomly generate barycentric coords. + w0, w1, w2 = _rand_barycentric_coords( + num_valid_meshes, num_samples, verts.dtype, verts.device + ) + + # Use the barycentric coords to get a point on each sampled face. + a = v0[sample_face_idxs] # (N, num_samples, 3) + b = v1[sample_face_idxs] + c = v2[sample_face_idxs] + samples[meshes.valid] = ( + w0[:, :, None] * a + w1[:, :, None] * b + w2[:, :, None] * c + ) + + if return_normals: + # Intialize normals tensor with fill value 0 for empty meshes. + # Normals for the sampled points are face normals computed from + # the vertices of the face in which the sampled point lies. + normals = torch.zeros( + (num_meshes, num_samples, 3), device=meshes.device + ) + vert_normals = (v1 - v0).cross(v2 - v1, dim=1) + vert_normals = vert_normals / vert_normals.norm( + dim=1, p=2, keepdim=True + ).clamp(min=sys.float_info.epsilon) + vert_normals = vert_normals[sample_face_idxs] + normals[meshes.valid] = vert_normals + + return samples, normals + else: + return samples + + +def _rand_barycentric_coords( + size1, size2, dtype, device +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Helper function to generate random barycentric coordinates which are uniformly + distributed over a triangle. + + Args: + size1, size2: The number of coordinates generated will be size1*size2. + Output tensors will each be of shape (size1, size2). + dtype: Datatype to generate. + device: A torch.device object on which the outputs will be allocated. + + Returns: + w0, w1, w2: Tensors of shape (size1, size2) giving random barycentric + coordinates + """ + uv = torch.rand(2, size1, size2, dtype=dtype, device=device) + u, v = uv[0], uv[1] + u_sqrt = u.sqrt() + w0 = 1.0 - u_sqrt + w1 = u_sqrt * (1.0 - v) + w2 = u_sqrt * v + return w0, w1, w2 diff --git a/pytorch3d/ops/subdivide_meshes.py b/pytorch3d/ops/subdivide_meshes.py new file mode 100644 index 00000000..900687ff --- /dev/null +++ b/pytorch3d/ops/subdivide_meshes.py @@ -0,0 +1,479 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn as nn + +from pytorch3d.structures import Meshes + + +class SubdivideMeshes(nn.Module): + """ + Subdivide a triangle mesh by adding a new vertex at the center of each edge + and dividing each face into four new faces. Vectors of vertex + attributes can also be subdivided by averaging the values of the attributes + at the two vertices which form each edge. This implementation + preserves face orientation - if the vertices of a face are all ordered + counter-clockwise, then the faces in the subdivided meshes will also have + their vertices ordered counter-clockwise. + + If meshes is provided as an input, the initializer performs the relatively + expensive computation of determining the new face indices. This one-time + computation can be reused for all meshes with the same face topology + but different vertex positions. + """ + + def __init__(self, meshes=None): + """ + Args: + meshes: Meshes object or None. If a meshes object is provided, + the first mesh is used to compute the new faces of the + subdivided topology which can be reused for meshes with + the same input topology. + """ + super(SubdivideMeshes, self).__init__() + + self.precomputed = False + self._N = -1 + if meshes is not None: + # This computation is on indices, so gradients do not need to be + # tracked. + mesh = meshes[0] + with torch.no_grad(): + subdivided_faces = self.subdivide_faces(mesh) + if subdivided_faces.shape[1] != 3: + raise ValueError("faces can only have three vertices") + self.register_buffer("_subdivided_faces", subdivided_faces) + self.precomputed = True + + def subdivide_faces(self, meshes): + r""" + Args: + meshes: a Meshes object. + + Returns: + subdivided_faces_packed: (4*sum(F_n), 3) shape LongTensor of + original and new faces. + + Refer to pytorch3d.structures.meshes.py for more details on packed + representations of faces. + + Each face is split into 4 faces e.g. Input face + :: + v0 + /\ + / \ + / \ + e1 / \ e0 + / \ + / \ + / \ + /______________\ + v2 e2 v1 + + faces_packed = [[0, 1, 2]] + faces_packed_to_edges_packed = [[2, 1, 0]] + + `faces_packed_to_edges_packed` is used to represent all the new + vertex indices corresponding to the mid-points of edges in the mesh. + The actual vertex coordinates will be computed in the forward function. + To get the indices of the new vertices, offset + `faces_packed_to_edges_packed` by the total number of vertices. + :: + faces_packed_to_edges_packed = [[2, 1, 0]] + 3 = [[5, 4, 3]] + + e.g. subdivided face + :: + v0 + /\ + / \ + / f0 \ + v4 /______\ v3 + /\ /\ + / \ f3 / \ + / f2 \ / f1 \ + /______\/______\ + v2 v5 v1 + + f0 = [0, 3, 4] + f1 = [1, 5, 3] + f2 = [2, 4, 5] + f3 = [5, 4, 3] + + """ + verts_packed = meshes.verts_packed() + with torch.no_grad(): + faces_packed = meshes.faces_packed() + faces_packed_to_edges_packed = meshes.faces_packed_to_edges_packed() + faces_packed_to_edges_packed += verts_packed.shape[0] + + f0 = torch.stack( + [ + faces_packed[:, 0], + faces_packed_to_edges_packed[:, 2], + faces_packed_to_edges_packed[:, 1], + ], + dim=1, + ) + f1 = torch.stack( + [ + faces_packed[:, 1], + faces_packed_to_edges_packed[:, 0], + faces_packed_to_edges_packed[:, 2], + ], + dim=1, + ) + f2 = torch.stack( + [ + faces_packed[:, 2], + faces_packed_to_edges_packed[:, 1], + faces_packed_to_edges_packed[:, 0], + ], + dim=1, + ) + f3 = faces_packed_to_edges_packed + subdivided_faces_packed = torch.cat( + [f0, f1, f2, f3], dim=0 + ) # (4*sum(F_n), 3) + + return subdivided_faces_packed + + def forward(self, meshes, feats=None): + """ + Subdivide a batch of meshes by adding a new vertex on each edge, and + dividing each face into four new faces. New meshes contains two types + of vertices: + 1) Vertices that appear in the input meshes. + Data for these vertices are copied from the input meshes. + 2) New vertices at the midpoint of each edge. + Data for these vertices is the average of the data for the two + vertices that make up the edge. + + Args: + meshes: Meshes object representing a batch of meshes. + feats: Per-vertex features to be subdivided along with the verts. + Should be parallel to the packed vert representation of the + input meshes; so it should have shape (V, D) where V is the + total number of verts in the input meshes. Default: None. + + Returns: + 2-element tuple containing + + - **new_meshes**: Meshes object of a batch of subdivided meshes. + - **new_feats**: (optional) Tensor of subdivided feats, parallel to the + (packed) vertices of the subdivided meshes. Only returned + if feats is not None. + + """ + self._N = len(meshes) + if self.precomputed: + return self.subdivide_homogeneous(meshes, feats) + else: + return self.subdivide_heterogenerous(meshes, feats) + + def subdivide_homogeneous(self, meshes, feats=None): + """ + Subdivide verts (and optionally features) of a batch of meshes + where each mesh has the same topology of faces. The subdivided faces + are precomputed in the initializer. + + Args: + meshes: Meshes object representing a batch of meshes. + feats: Per-vertex features to be subdivided along with the verts. + + Returns: + 2-element tuple containing + + - **new_meshes**: Meshes object of a batch of subdivided meshes. + - **new_feats**: (optional) Tensor of subdivided feats, parallel to the + (packed) vertices of the subdivided meshes. Only returned + if feats is not None. + """ + verts = meshes.verts_padded() # (N, V, D) + edges = meshes[0].edges_packed() + + # The set of faces is the same across the different meshes. + new_faces = self._subdivided_faces.view(1, -1, 3).expand( + self._N, -1, -1 + ) + + # Add one new vertex at the midpoint of each edge by taking the average + # of the vertices that form each edge. + new_verts = verts[:, edges].mean(dim=2) + new_verts = torch.cat( + [verts, new_verts], dim=1 + ) # (sum(V_n)+sum(E_n), 3) + new_feats = None + + # Calculate features for new vertices. + if feats is not None: + if feats.dim() == 2: + # feats is in packed format, transform it from packed to + # padded, i.e. (N*V, D) to (N, V, D). + feats = feats.view(verts.size(0), verts.size(1), feats.size(1)) + if feats.dim() != 3: + raise ValueError( + "features need to be of shape (N, V, D) or (N*V, D)" + ) + + # Take average of the features at the vertices that form each edge. + new_feats = feats[:, edges].mean(dim=2) + new_feats = torch.cat( + [feats, new_feats], dim=1 + ) # (sum(V_n)+sum(E_n), 3) + + new_meshes = Meshes(verts=new_verts, faces=new_faces) + + if feats is None: + return new_meshes + else: + return new_meshes, new_feats + + def subdivide_heterogenerous(self, meshes, feats=None): + """ + Subdivide faces, verts (and optionally features) of a batch of meshes + where each mesh can have different face topologies. + + Args: + meshes: Meshes object representing a batch of meshes. + feats: Per-vertex features to be subdivided along with the verts. + + Returns: + 2-element tuple containing + + - **new_meshes**: Meshes object of a batch of subdivided meshes. + - **new_feats**: (optional) Tensor of subdivided feats, parallel to the + (packed) vertices of the subdivided meshes. Only returned + if feats is not None. + """ + + # The computation of new faces is on face indices, so gradients do not + # need to be tracked. + verts = meshes.verts_packed() + with torch.no_grad(): + new_faces = self.subdivide_faces(meshes) + edges = meshes.edges_packed() + face_to_mesh_idx = meshes.faces_packed_to_mesh_idx() + edge_to_mesh_idx = meshes.edges_packed_to_mesh_idx() + num_edges_per_mesh = edge_to_mesh_idx.bincount(minlength=self._N) + num_verts_per_mesh = meshes.num_verts_per_mesh() + num_faces_per_mesh = meshes.num_faces_per_mesh() + + # Add one new vertex at the midpoint of each edge. + new_verts_per_mesh = num_verts_per_mesh + num_edges_per_mesh # (N,) + new_face_to_mesh_idx = torch.cat([face_to_mesh_idx] * 4, dim=0) + + # Calculate the indices needed to group the new and existing verts + # for each mesh. + verts_sort_idx = create_verts_index( + num_verts_per_mesh, num_edges_per_mesh, meshes.device + ) # (sum(V_n)+sum(E_n),) + + verts_ordered_idx_init = torch.zeros( + new_verts_per_mesh.sum(), + dtype=torch.int64, + device=meshes.device, + ) # (sum(V_n)+sum(E_n),) + + # Reassign vertex indices so that existing and new vertices for each + # mesh are sequential. + verts_ordered_idx = verts_ordered_idx_init.scatter_add( + 0, + verts_sort_idx, + torch.arange(new_verts_per_mesh.sum(), device=meshes.device), + ) + + # Retrieve vertex indices for each face. + new_faces = verts_ordered_idx[new_faces] + + # Calculate the indices needed to group the existing and new faces + # for each mesh. + face_sort_idx = create_faces_index( + num_faces_per_mesh, device=meshes.device + ) + + # Reorder the faces to sequentially group existing and new faces + # for each mesh. + new_faces = new_faces[face_sort_idx] + new_face_to_mesh_idx = new_face_to_mesh_idx[face_sort_idx] + new_faces_per_mesh = new_face_to_mesh_idx.bincount( + minlength=self._N + ) # (sum(F_n)*4) + + # Add one new vertex at the midpoint of each edge by taking the average + # of the verts that form each edge. + new_verts = verts[edges].mean(dim=1) + new_verts = torch.cat([verts, new_verts], dim=0) + + # Reorder the verts to sequentially group existing and new verts for + # each mesh. + new_verts = new_verts[verts_sort_idx] + + if feats is not None: + new_feats = feats[edges].mean(dim=1) + new_feats = torch.cat([feats, new_feats], dim=0) + new_feats = new_feats[verts_sort_idx] + + verts_list = list(new_verts.split(new_verts_per_mesh.tolist(), 0)) + faces_list = list(new_faces.split(new_faces_per_mesh.tolist(), 0)) + new_verts_per_mesh_cumsum = torch.cat( + [ + new_verts_per_mesh.new_full(size=(1,), fill_value=0.0), + new_verts_per_mesh.cumsum(0)[:-1], + ], + dim=0, + ) + faces_list = [ + faces_list[n] - new_verts_per_mesh_cumsum[n] for n in range(self._N) + ] + if feats is not None: + feats_list = new_feats.split(new_verts_per_mesh.tolist(), 0) + new_meshes = Meshes(verts=verts_list, faces=faces_list) + + if feats is None: + return new_meshes + else: + new_feats = torch.cat(feats_list, dim=0) + return new_meshes, new_feats + + +def create_verts_index(verts_per_mesh, edges_per_mesh, device=None): + """ + Helper function to group the vertex indices for each mesh. New vertices are + stacked at the end of the original verts tensor, so in order to have + sequential packing, the verts tensor needs to be reordered so that the + vertices corresponding to each mesh are grouped together. + + Args: + verts_per_mesh: Tensor of shape (N,) giving the number of vertices + in each mesh in the batch where N is the batch size. + edges_per_mesh: Tensor of shape (N,) giving the number of edges + in each mesh in the batch + + Returns: + verts_idx: A tensor with vert indices for each mesh ordered sequentially + by mesh index. + """ + # e.g. verts_per_mesh = (4, 5, 6) + # e.g. edges_per_mesh = (5, 7, 9) + + V = verts_per_mesh.sum() # e.g. 15 + E = edges_per_mesh.sum() # e.g. 21 + + verts_per_mesh_cumsum = verts_per_mesh.cumsum(dim=0) # (N,) e.g. (4, 9, 15) + edges_per_mesh_cumsum = edges_per_mesh.cumsum( + dim=0 + ) # (N,) e.g. (5, 12, 21) + + v_to_e_idx = verts_per_mesh_cumsum.clone() + + # vertex to edge index. + v_to_e_idx[1:] += edges_per_mesh_cumsum[ + :-1 + ] # e.g. (4, 9, 15) + (0, 5, 12) = (4, 14, 27) + + # vertex to edge offset. + v_to_e_offset = ( + V - verts_per_mesh_cumsum + ) # e.g. 15 - (4, 9, 15) = (11, 6, 0) + v_to_e_offset[1:] += edges_per_mesh_cumsum[ + :-1 + ] # e.g. (11, 6, 0) + (0, 5, 12) = (11, 11, 12) + e_to_v_idx = ( + verts_per_mesh_cumsum[:-1] + edges_per_mesh_cumsum[:-1] + ) # (4, 9) + (5, 12) = (9, 21) + e_to_v_offset = ( + verts_per_mesh_cumsum[:-1] - edges_per_mesh_cumsum[:-1] - V + ) # (4, 9) - (5, 12) - 15 = (-16, -18) + + # Add one new vertex per edge. + idx_diffs = torch.ones(V + E, device=device, dtype=torch.int64) # (36,) + idx_diffs[v_to_e_idx] += v_to_e_offset + idx_diffs[e_to_v_idx] += e_to_v_offset + + # e.g. + # [ + # 1, 1, 1, 1, 12, 1, 1, 1, 1, + # -15, 1, 1, 1, 1, 12, 1, 1, 1, 1, 1, 1, + # -17, 1, 1, 1, 1, 1, 13, 1, 1, 1, 1, 1, 1, 1 + # ] + + verts_idx = idx_diffs.cumsum(dim=0) - 1 + + # e.g. + # [ + # 0, 1, 2, 3, 15, 16, 17, 18, 19, --> mesh 0 + # 4, 5, 6, 7, 8, 20, 21, 22, 23, 24, 25, 26, --> mesh 1 + # 9, 10, 11, 12, 13, 14, 27, 28, 29, 30, 31, 32, 33, 34, 35 --> mesh 2 + # ] + # where for mesh 0, [0, 1, 2, 3] are the indices of the existing verts, and + # [15, 16, 17, 18, 19] are the indices of the new verts after subdivision. + + return verts_idx + + +def create_faces_index(faces_per_mesh, device=None): + """ + Helper function to group the faces indices for each mesh. New faces are + stacked at the end of the original faces tensor, so in order to have + sequential packing, the faces tensor needs to be reordered to that faces + corresponding to each mesh are grouped together. + + Args: + faces_per_mesh: Tensor of shape (N,) giving the number of faces + in each mesh in the batch where N is the batch size. + + Returns: + faces_idx: A tensor with face indices for each mesh ordered sequentially + by mesh index. + """ + # e.g. faces_per_mesh = [2, 5, 3] + + F = faces_per_mesh.sum() # e.g. 10 + faces_per_mesh_cumsum = faces_per_mesh.cumsum(dim=0) # (N,) e.g. (2, 7, 10) + + switch1_idx = faces_per_mesh_cumsum.clone() + switch1_idx[1:] += ( + 3 * faces_per_mesh_cumsum[:-1] + ) # e.g. (2, 7, 10) + (0, 6, 21) = (2, 13, 31) + + switch2_idx = 2 * faces_per_mesh_cumsum # e.g. (4, 14, 20) + switch2_idx[1:] += ( + 2 * faces_per_mesh_cumsum[:-1] + ) # e.g. (4, 14, 20) + (0, 4, 14) = (4, 18, 34) + + switch3_idx = 3 * faces_per_mesh_cumsum # e.g. (6, 21, 30) + switch3_idx[1:] += faces_per_mesh_cumsum[ + :-1 + ] # e.g. (6, 21, 30) + (0, 2, 7) = (6, 23, 37) + + switch4_idx = 4 * faces_per_mesh_cumsum[:-1] # e.g. (8, 28) + + switch123_offset = F - faces_per_mesh # e.g. (8, 5, 7) + + idx_diffs = torch.ones(4 * F, device=device, dtype=torch.int64) + idx_diffs[switch1_idx] += switch123_offset + idx_diffs[switch2_idx] += switch123_offset + idx_diffs[switch3_idx] += switch123_offset + idx_diffs[switch4_idx] -= 3 * F + + # e.g + # [ + # 1, 1, 9, 1, 9, 1, 9, 1, -> mesh 0 + # -29, 1, 1, 1, 1, 6, 1, 1, 1, 1, 6, 1, 1, 1, 1, 6, 1, 1, 1, 1, -> mesh 1 + # -29, 1, 1, 8, 1, 1, 8, 1, 1, 8, 1, 1 -> mesh 2 + # ] + + faces_idx = idx_diffs.cumsum(dim=0) - 1 + + # e.g. + # [ + # 0, 1, 10, 11, 20, 21, 30, 31, + # 2, 3, 4, 5, 6, 12, 13, 14, 15, 16, 22, 23, 24, 25, 26, 32, 33, 34, 35, 36, + # 7, 8, 9, 17, 18, 19, 27, 28, 29, 37, 38, 39 + # ] + # where for mesh 0, [0, 1] are the indices of the existing faces, and + # [10, 11, 20, 21, 30, 31] are the indices of the new faces after subdivision. + + return faces_idx diff --git a/pytorch3d/ops/vert_align.py b/pytorch3d/ops/vert_align.py new file mode 100644 index 00000000..34d666be --- /dev/null +++ b/pytorch3d/ops/vert_align.py @@ -0,0 +1,101 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn.functional as F + + +def vert_align( + feats, + verts, + return_packed: bool = False, + interp_mode: str = "bilinear", + padding_mode: str = "zeros", + align_corners: bool = True, +) -> torch.Tensor: + """ + Sample vertex features from a feature map. This operation is called + "perceptual feaure pooling" in [1] or "vert align" in [2]. + + [1] Wang et al, "Pixel2Mesh: Generating 3D Mesh Models from Single + RGB Images", ECCV 2018. + [2] Gkioxari et al, "Mesh R-CNN", ICCV 2019 + + Args: + feats: FloatTensor of shape (N, C, H, W) representing image features + from which to sample or a list of features each with potentially + different C, H or W dimensions. + verts: FloatTensor of shape (N, V, 3) or an object (e.g. Meshes) with + 'verts_padded' as an attribute giving the (x, y, z) vertex positions + for which to sample. (x, y) verts should be normalized such that + (-1, -1) corresponds to top-left and (+1, +1) to bottom-right + location in the input feature map. + return_packed: (bool) Indicates whether to return packed features + interp_mode: (str) Specifies how to interpolate features. + ('bilinear' or 'nearest') + padding_mode: (str) Specifies how to handle vertices outside of the + [-1, 1] range. ('zeros', 'reflection', or 'border') + align_corners (bool): Geometrically, we consider the pixels of the + input as squares rather than points. + If set to ``True``, the extrema (``-1`` and ``1``) are considered as + referring to the center points of the input's corner pixels. If set + to ``False``, they are instead considered as referring to the corner + points of the input's corner pixels, making the sampling more + resolution agnostic. Default: ``True`` + + Returns: + feats_sampled: FloatTensor of shape (N, V, C) giving sampled features for + each vertex. If feats is a list, we return concatentated + features in axis=2 of shape (N, V, sum(C_n)) where + C_n = feats[n].shape[1]. If return_packed = True, the + features are transformed to a packed representation + of shape (sum(V), C) + + """ + if torch.is_tensor(verts): + if verts.dim() != 3: + raise ValueError("verts tensor should be 3 dimensional") + grid = verts + elif hasattr(verts, "verts_padded"): + grid = verts.verts_padded() + else: + raise ValueError( + "verts must be a tensor or have a `verts_padded` attribute" + ) + + grid = grid[:, None, :, :2] # (N, 1, V, 2) + + if torch.is_tensor(feats): + feats = [feats] + for feat in feats: + if feat.dim() != 4: + raise ValueError("feats must have shape (N, C, H, W)") + if grid.shape[0] != feat.shape[0]: + raise ValueError("inconsistent batch dimension") + + feats_sampled = [] + for feat in feats: + feat_sampled = F.grid_sample( + feat, + grid, + mode=interp_mode, + padding_mode=padding_mode, + align_corners=align_corners, + ) # (N, C, 1, V) + feat_sampled = feat_sampled.squeeze(dim=2).transpose(1, 2) # (N, V, C) + feats_sampled.append(feat_sampled) + feats_sampled = torch.cat(feats_sampled, dim=2) # (N, V, sum(C)) + + if return_packed: + # flatten the first two dimensions: (N*V, C) + feats_sampled = feats_sampled.view(-1, feats_sampled.shape[-1]) + if hasattr(verts, "verts_padded_to_packed_idx"): + idx = ( + verts.verts_padded_to_packed_idx() + .view(-1, 1) + .expand(-1, feats_sampled.shape[-1]) + ) + feats_sampled = feats_sampled.gather(0, idx) # (sum(V), C) + + return feats_sampled diff --git a/pytorch3d/renderer/__init__.py b/pytorch3d/renderer/__init__.py new file mode 100644 index 00000000..cd547ac1 --- /dev/null +++ b/pytorch3d/renderer/__init__.py @@ -0,0 +1,36 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .blending import ( + BlendParams, + hard_rgb_blend, + sigmoid_alpha_blend, + softmax_rgb_blend, +) +from .cameras import ( + OpenGLOrthographicCameras, + OpenGLPerspectiveCameras, + camera_position_from_spherical_angles, + get_world_to_view_transform, + look_at_rotation, + look_at_view_transform, +) +from .lighting import DirectionalLights, PointLights, diffuse, specular +from .materials import Materials +from .mesh import ( + GouradShader, + MeshRasterizer, + MeshRenderer, + PhongShader, + RasterizationSettings, + SilhouetteShader, + TexturedPhongShader, + gourad_shading, + interpolate_face_attributes, + interpolate_texture_map, + interpolate_vertex_colors, + phong_shading, + rasterize_meshes, +) +from .utils import TensorProperties, convert_to_tensors_and_broadcast + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/renderer/blending.py b/pytorch3d/renderer/blending.py new file mode 100644 index 00000000..1816e767 --- /dev/null +++ b/pytorch3d/renderer/blending.py @@ -0,0 +1,184 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +from typing import NamedTuple +import torch + +# Example functions for blending the top K colors per pixel using the outputs +# from rasterization. +# NOTE: All blending function should return an RGBA image per batch element + + +# Data class to store blending params with defaults +class BlendParams(NamedTuple): + sigma: float = 1e-4 + gamma: float = 1e-4 + background_color = (1.0, 1.0, 1.0) + + +def hard_rgb_blend(colors, fragments) -> torch.Tensor: + """ + Naive blending of top K faces to return an RGBA image + - **RGB** - choose color of the closest point i.e. K=0 + - **A** - 1.0 + + Args: + colors: (N, H, W, K, 3) RGB color for each of the top K faces per pixel. + fragments: the outputs of rasterization. From this we use + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. This is used to + determine the output shape. + Returns: + RGBA pixel_colors: (N, H, W, 4) + """ + N, H, W, K = fragments.pix_to_face.shape + device = fragments.pix_to_face.device + pixel_colors = torch.ones((N, H, W, 4), dtype=colors.dtype, device=device) + pixel_colors[..., :3] = colors[..., 0, :] + return torch.flip(pixel_colors, [1]) + + +def sigmoid_alpha_blend(colors, fragments, blend_params) -> torch.Tensor: + """ + Silhouette blending to return an RGBA image + - **RGB** - choose color of the closest point. + - **A** - blend based on the 2D distance based probability map [0]. + + Args: + colors: (N, H, W, K, 3) RGB color for each of the top K faces per pixel. + fragments: the outputs of rasterization. From this we use + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. + - dists: FloatTensor of shape (N, H, W, K) specifying + the 2D euclidean distance from the center of each pixel + to each of the top K overlapping faces. + + Returns: + RGBA pixel_colors: (N, H, W, 4) + + [0] Liu et al, 'Soft Rasterizer: A Differentiable Renderer for Image-based + 3D Reasoning', ICCV 2019 + """ + N, H, W, K = fragments.pix_to_face.shape + pixel_colors = torch.ones( + (N, H, W, 4), dtype=colors.dtype, device=colors.device + ) + mask = fragments.pix_to_face >= 0 + + # The distance is negative if a pixel is inside a face and positive outside + # the face. Therefore use -1.0 * fragments.dists to get the correct sign. + prob = torch.sigmoid(-fragments.dists / blend_params.sigma) * mask + + # The cumulative product ensures that alpha will be 1 if at least 1 face + # fully covers the pixel as for that face prob will be 1.0 + # TODO: investigate why torch.cumprod backwards is very slow for large + # values of K. + # Temporarily replace this with exp(sum(log))) using the fact that + # a*b = exp(log(a*b)) = exp(log(a) + log(b)) + # alpha = 1.0 - torch.cumprod((1.0 - prob), dim=-1)[..., -1] + + alpha = 1.0 - torch.exp(torch.log((1.0 - prob)).sum(dim=-1)) + + pixel_colors[..., :3] = colors[..., 0, :] # Hard assign for RGB + pixel_colors[..., 3] = alpha + + pixel_colors = torch.clamp(pixel_colors, min=0, max=1.0) + return torch.flip(pixel_colors, [1]) + + +def softmax_rgb_blend(colors, fragments, blend_params) -> torch.Tensor: + """ + RGB and alpha channel blending to return an RGBA image based on the method + proposed in [0] + - **RGB** - blend the colors based on the 2D distance based probability map and + relative z distances. + - **A** - blend based on the 2D distance based probability map. + + Args: + colors: (N, H, W, K, 3) RGB color for each of the top K faces per pixel. + fragments: namedtuple with outputs of rasterization. We use properties + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. + - dists: FloatTensor of shape (N, H, W, K) specifying + the 2D euclidean distance from the center of each pixel + to each of the top K overlapping faces. + - zbuf: FloatTensor of shape (N, H, W, K) specifying + the interpolated depth from each pixel to to each of the + top K overlapping faces. + blend_params: instance of BlendParams dataclass containing properties + - sigma: float, parameter which controls the width of the sigmoid + function used to calculate the 2D distance based probability. + Sigma controls the sharpness of the edges of the shape. + - gamma: float, parameter which controls the scaling of the + exponential function used to control the opacity of the color. + - background_color: (3) element list/tuple/torch.Tensor specifying + the RGB values for the background color. + + Returns: + RGBA pixel_colors: (N, H, W, 4) + + [0] Shichen Liu et al, 'Soft Rasterizer: A Differentiable Renderer for + Image-based 3D Reasoning' + """ + N, H, W, K = fragments.pix_to_face.shape + device = fragments.pix_to_face.device + pix_colors = torch.ones( + (N, H, W, 4), dtype=colors.dtype, device=colors.device + ) + background = blend_params.background_color + if not torch.is_tensor(background): + background = torch.tensor( + background, dtype=torch.float32, device=device + ) + + # Background color + delta = np.exp(1e-10 / blend_params.gamma) * 1e-10 + delta = torch.tensor(delta, device=device) + + # Near and far clipping planes. + # TODO: add zfar/znear as input params. + zfar = 100.0 + znear = 1.0 + + # Mask for padded pixels. + mask = fragments.pix_to_face >= 0 + + # Sigmoid probability map based on the distance of the pixel to the face. + prob_map = torch.sigmoid(-fragments.dists / blend_params.sigma) * mask + + # The cumulative product ensures that alpha will be 1 if at least 1 face + # fully covers the pixel as for that face prob will be 1.0 + # TODO: investigate why torch.cumprod backwards is very slow for large + # values of K. + # Temporarily replace this with exp(sum(log))) using the fact that + # a*b = exp(log(a*b)) = exp(log(a) + log(b)) + # alpha = 1.0 - torch.cumprod((1.0 - prob), dim=-1)[..., -1] + + alpha = 1.0 - torch.exp(torch.log((1.0 - prob_map)).sum(dim=-1)) + + # Weights for each face. Adjust the exponential by the max z to prevent + # overflow. zbuf shape (N, H, W, K), find max over K. + # TODO: there may still be some instability in the exponent calculation. + z_inv = (zfar - fragments.zbuf) / (zfar - znear) * mask + z_inv_max = torch.max(z_inv, dim=-1).values[..., None] + weights_num = prob_map * torch.exp((z_inv - z_inv_max) / blend_params.gamma) + + # Normalize weights. + # weights_num shape: (N, H, W, K). Sum over K and divide through by the sum. + denom = weights_num.sum(dim=-1)[..., None] + delta + weights = weights_num / denom + + # Sum: weights * textures + background color + weighted_colors = (weights[..., None] * colors).sum(dim=-2) + weighted_background = (delta / denom) * background + pix_colors[..., :3] = weighted_colors + weighted_background + pix_colors[..., 3] = alpha + + # Clamp colors to the range 0-1 and flip y axis. + pix_colors = torch.clamp(pix_colors, min=0, max=1.0) + return torch.flip(pix_colors, [1]) diff --git a/pytorch3d/renderer/cameras.py b/pytorch3d/renderer/cameras.py new file mode 100644 index 00000000..4e13ad55 --- /dev/null +++ b/pytorch3d/renderer/cameras.py @@ -0,0 +1,1049 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import math +import numpy as np +from typing import Tuple +import torch +import torch.nn.functional as F + +from pytorch3d.transforms import Rotate, Transform3d, Translate + +from .utils import TensorProperties, convert_to_tensors_and_broadcast + +# Default values for rotation and translation matrices. +r = np.expand_dims(np.eye(3), axis=0) # (1, 3, 3) +t = np.expand_dims(np.zeros(3), axis=0) # (1, 3) + + +class OpenGLPerspectiveCameras(TensorProperties): + """ + A class which stores a batch of parameters to generate a batch of + projection matrices using the OpenGL convention for a perspective camera. + + The extrinsics of the camera (R and T matrices) can also be set in the + initializer or passed in to `get_full_projection_transform` to get + the full transformation from world -> screen. + + The `transform_points` method calculates the full world -> screen transform + and then applies it to the input points. + + The transforms can also be returned separately as Transform3d objects. + """ + + def __init__( + self, + znear=1.0, + zfar=100.0, + aspect_ratio=1.0, + fov=60.0, + degrees: bool = True, + R=r, + T=t, + device="cpu", + ): + """ + __init__(self, znear, zfar, aspect_ratio, fov, degrees, R, T, device) -> None # noqa + + Args: + znear: near clipping plane of the view frustrum. + zfar: far clipping plane of the view frustrum. + aspect_ratio: ratio of screen_width/screen_height. + fov: field of view angle of the camera. + degrees: bool, set to True if fov is specified in degrees. + R: Rotation matrix of shape (N, 3, 3) + T: Translation matrix of shape (N, 3) + device: torch.device or string + """ + # The initializer formats all inputs to torch tensors and broadcasts + # all the inputs to have the same batch dimension where necessary. + super().__init__( + device=device, + znear=znear, + zfar=zfar, + aspect_ratio=aspect_ratio, + fov=fov, + R=R, + T=T, + ) + + # No need to convert to tensor or broadcast. + self.degrees = degrees + + def get_projection_transform(self, **kwargs) -> Transform3d: + """ + Calculate the OpenGL perpective projection matrix with a symmetric + viewing frustrum. Use column major order. + + Args: + **kwargs: parameters for the projection can be passed in as keyword + arguments to override the default values set in `__init__`. + + Return: + P: a Transform3d object which represents a batch of projection + matrices of shape (N, 3, 3) + + .. code-block:: python + + f1 = -(far + near)/(farβˆ’near) + f2 = -2*far*near/(far-near) + h1 = (top + bottom)/(top - bottom) + w1 = (right + left)/(right - left) + tanhalffov = tan((fov/2)) + s1 = 1/tanhalffov + s2 = 1/(tanhalffov * (aspect_ratio)) + + P = [ + [s1, 0, w1, 0], + [0, s2, h1, 0], + [0, 0, f1, f2], + [0, 0, -1, 0], + ] + """ + znear = kwargs.get("znear", self.znear) # pyre-ignore[16] + zfar = kwargs.get("zfar", self.zfar) # pyre-ignore[16] + fov = kwargs.get("fov", self.fov) # pyre-ignore[16] + aspect_ratio = kwargs.get( + "aspect_ratio", self.aspect_ratio + ) # pyre-ignore[16] + degrees = kwargs.get("degrees", self.degrees) + + P = torch.zeros( + (self._N, 4, 4), device=self.device, dtype=torch.float32 + ) + ones = torch.ones((self._N), dtype=torch.float32, device=self.device) + if degrees: + fov = (np.pi / 180) * fov + + if not torch.is_tensor(fov): + fov = torch.tensor(fov, device=self.device) + tanHalfFov = torch.tan((fov / 2)) + top = tanHalfFov * znear + bottom = -top + right = top * aspect_ratio + left = -right + + # NOTE: In OpenGL the projection matrix changes the handedness of the + # coordinate frame. i.e the NDC space postive z direction is the + # camera space negative z direction. This is because the sign of the z + # in the projection matrix is set to -1.0. + # In pytorch3d we maintain a right handed coordinate system throughout + # so the so the z sign is 1.0. + z_sign = 1.0 + + P[:, 0, 0] = 2.0 * znear / (right - left) + P[:, 1, 1] = 2.0 * znear / (top - bottom) + P[:, 0, 2] = (right + left) / (right - left) + P[:, 1, 2] = (top + bottom) / (top - bottom) + P[:, 3, 2] = z_sign * ones + + # NOTE: This part of the matrix is for z renormalization in OpenGL + # which maps the z to [-1, 1]. This won't work yet as the torch3d + # rasterizer ignores faces which have z < 0. + # P[:, 2, 2] = z_sign * (far + near) / (far - near) + # P[:, 2, 3] = -2.0 * far * near / (far - near) + # P[:, 3, 2] = z_sign * torch.ones((N)) + + # NOTE: This maps the z coordinate from [0, 1] where z = 0 if the point + # is at the near clipping plane and z = 1 when the point is at the far + # clipping plane. This replaces the OpenGL z normalization to [-1, 1] + # until rasterization is changed to clip at z = -1. + P[:, 2, 2] = z_sign * zfar / (zfar - znear) + P[:, 2, 3] = -(zfar * znear) / (zfar - znear) + + # OpenGL uses column vectors so need to transpose the projection matrix + # as torch3d uses row vectors. + transform = Transform3d(device=self.device) + transform._matrix = P.transpose(1, 2).contiguous() + return transform + + def clone(self): + other = OpenGLPerspectiveCameras(device=self.device) + return super().clone(other) + + def get_camera_center(self, **kwargs): + """ + Return the 3D location of the camera optical center + in the world coordinates. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting T here will update the values set in init as this + value may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + C: a batch of 3D locations of shape (N, 3) denoting + the locations of the center of each camera in the batch. + """ + w2v_trans = self.get_world_to_view_transform(**kwargs) + P = w2v_trans.inverse().get_matrix() + # the camera center is the translation component (the first 3 elements + # of the last row) of the inverted world-to-view + # transform (4x4 RT matrix) + C = P[:, 3, :3] + return C + + def get_world_to_view_transform(self, **kwargs) -> Transform3d: + """ + Return the world-to-view transform. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = get_world_to_view_transform( + R=self.R, T=self.T + ) + return world_to_view_transform + + def get_full_projection_transform(self, **kwargs) -> Transform3d: + """ + Return the full world-to-screen transform composing the + world-to-view and view-to-screen transforms. + + Args: + **kwargs: parameters for the projection transforms can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = self.get_world_to_view_transform( + R=self.R, T=self.T + ) + view_to_screen_transform = self.get_projection_transform(**kwargs) + return world_to_view_transform.compose(view_to_screen_transform) + + def transform_points(self, points, **kwargs) -> torch.Tensor: + """ + Transform input points from world to screen space. + + Args: + points: torch tensor of shape (..., 3). + + Returns + new_points: transformed points with the same shape as the input. + """ + world_to_screen_transform = self.get_full_projection_transform(**kwargs) + return world_to_screen_transform.transform_points(points) + + +class OpenGLOrthographicCameras(TensorProperties): + """ + A class which stores a batch of parameters to generate a batch of + transformation matrices using the OpenGL convention for orthographic camera. + """ + + def __init__( + self, + znear=1.0, + zfar=100.0, + top=1.0, + bottom=-1.0, + left=-1.0, + right=1.0, + scale_xyz=((1.0, 1.0, 1.0),), # (1, 3) + R=r, + T=t, + device="cpu", + ): + """ + __init__(self, znear, zfar, top, bottom, left, right, scale_xyz, R, T, device) -> None # noqa + + Args: + znear: near clipping plane of the view frustrum. + zfar: far clipping plane of the view frustrum. + top: position of the top of the screen. + bottom: position of the bottom of the screen. + left: position of the left of the screen. + right: position of the right of the screen. + scale_xyz: scale factors for each axis of shape (N, 3). + R: Rotation matrix of shape (N, 3, 3). + T: Translation of shape (N, 3). + device: torch.device or string. + + Only need to set left, right, top, bottom for viewing frustrums + which are non symmetric about the origin. + """ + # The initializer formats all inputs to torch tensors and broadcasts + # all the inputs to have the same batch dimension where necessary. + super().__init__( + device=device, + znear=znear, + zfar=zfar, + top=top, + bottom=bottom, + left=left, + right=right, + scale_xyz=scale_xyz, + R=R, + T=T, + ) + + def get_projection_transform(self, **kwargs) -> Transform3d: + """ + Calculate the OpenGL orthographic projection matrix. + Use column major order. + + Args: + **kwargs: parameters for the projection can be passed in to + override the default values set in __init__. + Return: + P: a Transform3d object which represents a batch of projection + matrices of shape (N, 3, 3) + + .. code-block:: python + + scale_x = 2/(right - left) + scale_y = 2/(top - bottom) + scale_z = 2/(far-near) + mid_x = (right + left)/(right - left) + mix_y = (top + bottom)/(top - bottom) + mid_z = (far + near)/(farβˆ’near) + + P = [ + [scale_x, 0, 0, -mid_x], + [0, scale_y, 0, -mix_y], + [0, 0, -scale_z, -mid_z], + [0, 0, 0, 1], + ] + """ + znear = kwargs.get("znear", self.znear) # pyre-ignore[16] + zfar = kwargs.get("zfar", self.zfar) # pyre-ignore[16] + left = kwargs.get("left", self.left) # pyre-ignore[16] + right = kwargs.get("right", self.right) # pyre-ignore[16] + top = kwargs.get("top", self.top) # pyre-ignore[16] + bottom = kwargs.get("bottom", self.bottom) # pyre-ignore[16] + scale_xyz = kwargs.get("scale_xyz", self.scale_xyz) # pyre-ignore[16] + + P = torch.zeros( + (self._N, 4, 4), dtype=torch.float32, device=self.device + ) + ones = torch.ones((self._N), dtype=torch.float32, device=self.device) + # NOTE: OpenGL flips handedness of coordinate system between camera + # space and NDC space so z sign is -ve. In PyTorch3d we maintain a + # right handed coordinate system throughout. + z_sign = +1.0 + + P[:, 0, 0] = (2.0 / (right - left)) * scale_xyz[:, 0] + P[:, 1, 1] = (2.0 / (top - bottom)) * scale_xyz[:, 1] + P[:, 0, 3] = -(right + left) / (right - left) + P[:, 1, 3] = -(top + bottom) / (top - bottom) + P[:, 3, 3] = ones + + # NOTE: This maps the z coordinate to the range [0, 1] and replaces the + # the OpenGL z normalization to [-1, 1] + P[:, 2, 2] = z_sign * (1.0 / (zfar - znear)) * scale_xyz[:, 2] + P[:, 2, 3] = -znear / (zfar - znear) + + # NOTE: This part of the matrix is for z renormalization in OpenGL. + # The z is mapped to the range [-1, 1] but this won't work yet in + # pytorch3d as the rasterizer ignores faces which have z < 0. + # P[:, 2, 2] = z_sign * (2.0 / (far - near)) * scale[:, 2] + # P[:, 2, 3] = -(far + near) / (far - near) + + transform = Transform3d(device=self.device) + transform._matrix = P.transpose(1, 2).contiguous() + return transform + + def clone(self): + other = OpenGLOrthographicCameras(device=self.device) + return super().clone(other) + + def get_camera_center(self, **kwargs): + """ + Return the 3D location of the camera optical center + in the world coordinates. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting T here will update the values set in init as this + value may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + + Returns: + C: a batch of 3D locations of shape (N, 3) denoting + the locations of the center of each camera in the batch. + """ + w2v_trans = self.get_world_to_view_transform(**kwargs) + P = w2v_trans.inverse().get_matrix() + # The camera center is the translation component (the first 3 elements + # of the last row) of the inverted world-to-view + # transform (4x4 RT matrix). + C = P[:, 3, :3] + return C + + def get_world_to_view_transform(self, **kwargs) -> Transform3d: + """ + Return the world-to-view transform. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = get_world_to_view_transform( + R=self.R, T=self.T + ) + return world_to_view_transform + + def get_full_projection_transform(self, **kwargs) -> Transform3d: + """ + Return the full world-to-screen transform composing the + world-to-view and view-to-screen transforms. + + Args: + **kwargs: parameters for the projection transforms can be passed in + as keyword arguments to override the default values + set in `__init__`. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = self.get_world_to_view_transform( + R=self.R, T=self.T + ) + view_to_screen_transform = self.get_projection_transform(**kwargs) + return world_to_view_transform.compose(view_to_screen_transform) + + def transform_points(self, points, **kwargs) -> torch.Tensor: + """ + Transform input points from world to screen space. + + Args: + points: torch tensor of shape (..., 3). + + Returns + new_points: transformed points with the same shape as the input. + """ + world_to_screen_transform = self.get_full_projection_transform(**kwargs) + return world_to_screen_transform.transform_points(points) + + +class SfMPerspectiveCameras(TensorProperties): + """ + A class which stores a batch of parameters to generate a batch of + transformation matrices using the multi-view geometry convention for + perspective camera. + """ + + def __init__( + self, + focal_length=1.0, + principal_point=((0.0, 0.0),), + R=r, + T=t, + device="cpu", + ): + """ + __init__(self, focal_length, principal_point, R, T, device) -> None + + Args: + focal_length: Focal length of the camera in world units. + A tensor of shape (N, 1) or (N, 2) for + square and non-square pixels respectively. + principal_point: xy coordinates of the center of + the principal point of the camera in pixels. + A tensor of shape (N, 2). + R: Rotation matrix of shape (N, 3, 3) + T: Translation matrix of shape (N, 3) + device: torch.device or string + """ + # The initializer formats all inputs to torch tensors and broadcasts + # all the inputs to have the same batch dimension where necessary. + super().__init__( + device=device, + focal_length=focal_length, + principal_point=principal_point, + R=R, + T=T, + ) + + def get_projection_transform(self, **kwargs) -> Transform3d: + """ + Calculate the projection matrix using the + multi-view geometry convention. + + Args: + **kwargs: parameters for the projection can be passed in as keyword + arguments to override the default values set in __init__. + + Returns: + P: a batch of projection matrices of shape (N, 4, 4) + + .. code-block:: python + + fx = focal_length[:,0] + fy = focal_length[:,1] + px = principal_point[:,0] + py = principal_point[:,1] + + P = [ + [fx, 0, 0, px], + [0, fy, 0, py], + [0, 0, 0, 1], + [0, 0, 1, 0], + ] + """ + principal_point = kwargs.get( + "principal_point", self.principal_point + ) # pyre-ignore[16] + focal_length = kwargs.get( + "focal_length", self.focal_length + ) # pyre-ignore[16] + + P = _get_sfm_calibration_matrix( + self._N, self.device, focal_length, principal_point, False + ) + + transform = Transform3d(device=self.device) + transform._matrix = P.transpose(1, 2).contiguous() + return transform + + def clone(self): + other = SfMPerspectiveCameras(device=self.device) + return super().clone(other) + + def get_camera_center(self, **kwargs): + """ + Return the 3D location of the camera optical center + in the world coordinates. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting T here will update the values set in init as this + value may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + C: a batch of 3D locations of shape (N, 3) denoting + the locations of the center of each camera in the batch. + """ + w2v_trans = self.get_world_to_view_transform(**kwargs) + P = w2v_trans.inverse().get_matrix() + # the camera center is the translation component (the first 3 elements + # of the last row) of the inverted world-to-view + # transform (4x4 RT matrix) + C = P[:, 3, :3] + return C + + def get_world_to_view_transform(self, **kwargs) -> Transform3d: + """ + Return the world-to-view transform. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = get_world_to_view_transform( + R=self.R, T=self.T + ) + return world_to_view_transform + + def get_full_projection_transform(self, **kwargs) -> Transform3d: + """ + Return the full world-to-screen transform composing the + world-to-view and view-to-screen transforms. + + Args: + **kwargs: parameters for the projection transforms can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = self.get_world_to_view_transform( + R=self.R, T=self.T + ) + view_to_screen_transform = self.get_projection_transform(**kwargs) + return world_to_view_transform.compose(view_to_screen_transform) + + def transform_points(self, points, **kwargs) -> torch.Tensor: + """ + Transform input points from world to screen space. + + Args: + points: torch tensor of shape (..., 3). + + Returns + new_points: transformed points with the same shape as the input. + """ + world_to_screen_transform = self.get_full_projection_transform(**kwargs) + return world_to_screen_transform.transform_points(points) + + +class SfMOrthographicCameras(TensorProperties): + """ + A class which stores a batch of parameters to generate a batch of + transformation matrices using the multi-view geometry convention for + orthographic camera. + """ + + def __init__( + self, + focal_length=1.0, + principal_point=((0.0, 0.0),), + R=r, + T=t, + device="cpu", + ): + """ + __init__(self, focal_length, principal_point, R, T, device) -> None + + Args: + focal_length: Focal length of the camera in world units. + A tensor of shape (N, 1) or (N, 2) for + square and non-square pixels respectively. + principal_point: xy coordinates of the center of + the principal point of the camera in pixels. + A tensor of shape (N, 2). + R: Rotation matrix of shape (N, 3, 3) + T: Translation matrix of shape (N, 3) + device: torch.device or string + """ + # The initializer formats all inputs to torch tensors and broadcasts + # all the inputs to have the same batch dimension where necessary. + super().__init__( + device=device, + focal_length=focal_length, + principal_point=principal_point, + R=R, + T=T, + ) + + def get_projection_transform(self, **kwargs) -> Transform3d: + """ + Calculate the projection matrix using + the multi-view geometry convention. + + Args: + **kwargs: parameters for the projection can be passed in as keyword + arguments to override the default values set in __init__. + + Return: + P: a batch of projection matrices of shape (N, 4, 4) + + .. code-block:: python + + fx = focal_length[:,0] + fy = focal_length[:,1] + px = principal_point[:,0] + py = principal_point[:,1] + + P = [ + [fx, 0, 0, px], + [0, fy, 0, py], + [0, 0, 1, 0], + [0, 0, 0, 1], + ] + """ + principal_point = kwargs.get( + "principal_point", self.principal_point + ) # pyre-ignore[16] + focal_length = kwargs.get( + "focal_length", self.focal_length + ) # pyre-ignore[16] + + P = _get_sfm_calibration_matrix( + self._N, self.device, focal_length, principal_point, True + ) + + transform = Transform3d(device=self.device) + transform._matrix = P.transpose(1, 2).contiguous() + return transform + + def clone(self): + other = SfMOrthographicCameras(device=self.device) + return super().clone(other) + + def get_camera_center(self, **kwargs): + """ + Return the 3D location of the camera optical center + in the world coordinates. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting T here will update the values set in init as this + value may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + C: a batch of 3D locations of shape (N, 3) denoting + the locations of the center of each camera in the batch. + """ + w2v_trans = self.get_world_to_view_transform(**kwargs) + P = w2v_trans.inverse().get_matrix() + # the camera center is the translation component (the first 3 elements + # of the last row) of the inverted world-to-view + # transform (4x4 RT matrix) + C = P[:, 3, :3] + return C + + def get_world_to_view_transform(self, **kwargs) -> Transform3d: + """ + Return the world-to-view transform. + + Args: + **kwargs: parameters for the camera extrinsics can be passed in + as keyword arguments to override the default values + set in __init__. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + + Returns: + T: a Transform3d object which represents a batch of transforms + of shape (N, 3, 3) + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = get_world_to_view_transform( + R=self.R, T=self.T + ) + return world_to_view_transform + + def get_full_projection_transform(self, **kwargs) -> Transform3d: + """ + Return the full world-to-screen transform composing the + world-to-view and view-to-screen transforms. + + Args: + **kwargs: parameters for the projection transforms can be passed in + as keyword arguments to override the default values + set in `__init__`. + + Setting R and T here will update the values set in init as these + values may be needed later on in the rendering pipeline e.g. for + lighting calculations. + """ + self.R = kwargs.get("R", self.R) # pyre-ignore[16] + self.T = kwargs.get("T", self.T) # pyre-ignore[16] + world_to_view_transform = self.get_world_to_view_transform( + R=self.R, T=self.T + ) + view_to_screen_transform = self.get_projection_transform(**kwargs) + return world_to_view_transform.compose(view_to_screen_transform) + + def transform_points(self, points, **kwargs) -> torch.Tensor: + """ + Transform input points from world to screen space. + + Args: + points: torch tensor of shape (..., 3). + + Returns + new_points: transformed points with the same shape as the input. + """ + world_to_screen_transform = self.get_full_projection_transform(**kwargs) + return world_to_screen_transform.transform_points(points) + + +# SfMCameras helper +def _get_sfm_calibration_matrix( + N, device, focal_length, principal_point, orthographic: bool +) -> torch.Tensor: + """ + Returns a calibration matrix of a perspective/orthograpic camera. + + Args: + N: Number of cameras. + focal_length: Focal length of the camera in world units. + principal_point: xy coordinates of the center of + the principal point of the camera in pixels. + + The calibration matrix `K` is set up as follows: + + .. code-block:: python + + fx = focal_length[:,0] + fy = focal_length[:,1] + px = principal_point[:,0] + py = principal_point[:,1] + + for orthographic==True: + K = [ + [fx, 0, 0, px], + [0, fy, 0, py], + [0, 0, 1, 0], + [0, 0, 0, 1], + ] + else: + K = [ + [fx, 0, 0, px], + [0, fy, 0, py], + [0, 0, 0, 1], + [0, 0, 1, 0], + ] + + Returns: + A calibration matrix `K` of the SfM-conventioned camera + of shape (N, 4, 4). + """ + + if not torch.is_tensor(focal_length): + focal_length = torch.tensor(focal_length, device=device) + + if len(focal_length.shape) in (0, 1) or focal_length.shape[1] == 1: + fx = fy = focal_length + else: + fx, fy = focal_length.unbind(1) + + if not torch.is_tensor(principal_point): + principal_point = torch.tensor(principal_point, device=device) + + px, py = principal_point.unbind(1) + + K = fx.new_zeros(N, 4, 4) + K[:, 0, 0] = fx + K[:, 1, 1] = fy + K[:, 0, 3] = px + K[:, 1, 3] = py + if orthographic: + K[:, 2, 2] = 1.0 + K[:, 3, 3] = 1.0 + else: + K[:, 3, 2] = 1.0 + K[:, 2, 3] = 1.0 + + return K + + +################################################ +# Helper functions for world to view transforms +################################################ + + +def get_world_to_view_transform(R=r, T=t) -> Transform3d: + """ + This function returns a Transform3d representing the transformation + matrix to go from world space to view space by applying a rotation and + a translation. + + Pytorch3d uses the same convention as Hartley & Zisserman. + I.e., for camera extrinsic parameters R (rotation) and T (translation), + we map a 3D point `X_world` in world coordinates to + a point `X_cam` in camera coordinates with: + `X_cam = X_world R + T` + + Args: + R: (N, 3, 3) matrix representing the rotation. + T: (N, 3) matrix representing the translation. + + Returns: + a Transform3d object which represents the composed RT transformation. + + """ + # TODO: also support the case where RT is specified as one matrix + # of shape (N, 4, 4). + + if T.shape[0] != R.shape[0]: + msg = "Expected R, T to have the same batch dimension; got %r, %r" + raise ValueError(msg % (R.shape[0], T.shape[0])) + if T.dim() != 2 or T.shape[1:] != (3,): + msg = "Expected T to have shape (N, 3); got %r" + raise ValueError(msg % repr(T.shape)) + if R.dim() != 3 or R.shape[1:] != (3, 3): + msg = "Expected R to have shape (N, 3, 3); got %r" + raise ValueError(msg % R.shape) + + # Create a Transform3d object + T = Translate(T, device=T.device) + R = Rotate(R, device=R.device) + return R.compose(T) + + +def camera_position_from_spherical_angles( + distance, elevation, azimuth, degrees: bool = True, device: str = "cpu" +) -> torch.Tensor: + """ + Calculate the location of the camera based on the distance away from + the target point, the elevation and azimuth angles. + + Args: + distance: distance of the camera from the object. + elevation, azimuth: angles. + The inputs distance, elevation and azimuth can be one of the following + - Python scalar + - Torch scalar + - Torch tensor of shape (N) or (1) + degrees: bool, whether the angles are specified in degrees or radians. + device: str or torch.device, device for new tensors to be placed on. + + The vectors are broadcast against each other so they all have shape (N, 1). + + Returns: + camera_position: (N, 3) xyz location of the camera. + """ + broadcasted_args = convert_to_tensors_and_broadcast( + distance, elevation, azimuth, device=device + ) + dist, elev, azim = broadcasted_args + if degrees: + elev = math.pi / 180.0 * elev + azim = math.pi / 180.0 * azim + x = dist * torch.cos(elev) * torch.sin(azim) + y = dist * torch.sin(elev) + z = -dist * torch.cos(elev) * torch.cos(azim) + camera_position = torch.stack([x, y, z], dim=1) + if camera_position.dim() == 0: + camera_position = camera_position.view(1, -1) # add batch dim. + return camera_position.view(-1, 3) + + +def look_at_rotation( + camera_position, at=((0, 0, 0),), up=((0, 1, 0),), device: str = "cpu" +) -> torch.Tensor: + """ + This function takes a vector 'camera_position' which specifies the location + of the camera in world coordinates and two vectors `at` and `up` which + indicate the position of the object and the up directions of the world + coordinate system respectively. The object is assumed to be centered at + the origin. + + The output is a rotation matrix representing the transformation + from world coordinates -> view coordinates. + + Args: + camera_position: position of the camera in world coordinates + at: position of the object in world coordinates + up: vector specifying the up direction in the world coordinate frame. + + The inputs camera_position, at and up can each be a + - 3 element tuple/list + - torch tensor of shape (1, 3) + - torch tensor of shape (N, 3) + + The vectors are broadcast against each other so they all have shape (N, 3). + + Returns: + R: (N, 3, 3) batched rotation matrices + """ + # Format input and broadcast + broadcasted_args = convert_to_tensors_and_broadcast( + camera_position, at, up, device=device + ) + camera_position, at, up = broadcasted_args + for t, n in zip([camera_position, at, up], ["camera_position", "at", "up"]): + if t.shape[-1] != 3: + msg = "Expected arg %s to have shape (N, 3); got %r" + raise ValueError(msg % (n, t.shape)) + z_axis = F.normalize(at - camera_position, eps=1e-5) + x_axis = F.normalize(torch.cross(up, z_axis), eps=1e-5) + y_axis = F.normalize(torch.cross(z_axis, x_axis), eps=1e-5) + R = torch.cat( + (x_axis[:, None, :], y_axis[:, None, :], z_axis[:, None, :]), dim=1 + ) + return R.transpose(1, 2) + + +def look_at_view_transform( + dist, + elev, + azim, + degrees: bool = True, + at=((0, 0, 0),), # (1, 3) + up=((0, 1, 0),), # (1, 3) + device="cpu", +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + This function returns a rotation and translation matrix + to apply the 'Look At' transformation from world -> view coordinates [0]. + + Args: + dist: distance of the camera from the object + elev: angle in degres or radians. This is the angle between the + vector from the object to the camera, and the horizonal plane. + azim: angle in degrees or radians. The vector from the object to + the camera is projected onto a horizontal plane y = z = 0. + azim is the angle between the projected vector and a + reference vector at (1, 0, 0) on the reference plane. + dist, elem and azim can be of shape (1), (N). + degrees: boolean flag to indicate if the elevation and azimuth + angles are specified in degrees or raidans. + up: the direction of the x axis in the world coordinate system. + at: the position of the object(s) in world coordinates. + up and at can be of shape (1, 3) or (N, 3). + + Returns: + 2-element tuple containing + + - **R**: the rotation to apply to the points to align with the camera. + - **T**: the translation to apply to the points to align with the camera. + + References: + [0] https://www.scratchapixel.com + """ + broadcasted_args = convert_to_tensors_and_broadcast( + dist, elev, azim, at, up, device=device + ) + dist, elev, azim, at, up = broadcasted_args + C = camera_position_from_spherical_angles(dist, elev, azim, device=device) + R = look_at_rotation(C, at, up, device=device) + T = -torch.bmm(R.transpose(1, 2), C[:, :, None])[:, :, 0] + return R, T diff --git a/pytorch3d/renderer/lighting.py b/pytorch3d/renderer/lighting.py new file mode 100644 index 00000000..09ec50fd --- /dev/null +++ b/pytorch3d/renderer/lighting.py @@ -0,0 +1,284 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn.functional as F + +from .utils import TensorProperties, convert_to_tensors_and_broadcast + + +def diffuse(normals, color, direction) -> torch.Tensor: + """ + Calculate the diffuse component of light reflection using Lambert's + cosine law. + + Args: + normals: (N, ..., 3) xyz normal vectors. Normals and points are + expected to have the same shape. + color: (1, 3) or (N, 3) RGB color of the diffuse component of the light. + direction: (x,y,z) direction of the light + + Returns: + colors: (N, ..., 3), same shape as the input points. + + The normals and light direction should be in the same coordinate frame + i.e. if the points have been transformed from world -> view space then + the normals and direction should also be in view space. + + NOTE: to use with the packed vertices (i.e. no batch dimension) reformat the + inputs in the following way. + + .. code-block:: python + + Args: + normals: (P, 3) + color: (N, 3)[batch_idx, :] -> (P, 3) + direction: (N, 3)[batch_idx, :] -> (P, 3) + + Returns: + colors: (P, 3) + + where batch_idx is of shape (P). For meshes, batch_idx can be: + meshes.verts_packed_to_mesh_idx() or meshes.faces_packed_to_mesh_idx() + depending on whether points refers to the vertex coordinates or + average/interpolated face coordinates. + """ + # TODO: handle multiple directional lights per batch element. + # TODO: handle attentuation. + + # Ensure color and location have same batch dimension as normals + normals, color, direction = convert_to_tensors_and_broadcast( + normals, color, direction, device=normals.device + ) + + # Reshape direction and color so they have all the arbitrary intermediate + # dimensions as normals. Assume first dim = batch dim and last dim = 3. + points_dims = normals.shape[1:-1] + expand_dims = (-1,) + (1,) * len(points_dims) + (3,) + if direction.shape != normals.shape: + direction = direction.view(expand_dims) + if color.shape != normals.shape: + color = color.view(expand_dims) + + # Renormalize the normals in case they have been interpolated. + normals = F.normalize(normals, p=2, dim=-1, eps=1e-6) + direction = F.normalize(direction, p=2, dim=-1, eps=1e-6) + angle = F.relu(torch.sum(normals * direction, dim=-1)) + return color * angle[..., None] + + +def specular( + points, normals, direction, color, camera_position, shininess +) -> torch.Tensor: + """ + Calculate the specular component of light reflection. + + Args: + points: (N, ..., 3) xyz coordinates of the points. + normals: (N, ..., 3) xyz normal vectors for each point. + color: (N, 3) RGB color of the specular component of the light. + direction: (N, 3) vector direction of the light. + camera_position: (N, 3) The xyz position of the camera. + shininess: (N) The specular exponent of the material. + + Returns: + colors: (N, ..., 3), same shape as the input points. + + The points, normals, camera_position, and direction should be in the same + coordinate frame i.e. if the points have been transformed from + world -> view space then the normals, camera_position, and light direction + should also be in view space. + + To use with a batch of packed points reindex in the following way. + .. code-block:: python:: + + Args: + points: (P, 3) + normals: (P, 3) + color: (N, 3)[batch_idx] -> (P, 3) + direction: (N, 3)[batch_idx] -> (P, 3) + camera_position: (N, 3)[batch_idx] -> (P, 3) + shininess: (N)[batch_idx] -> (P) + Returns: + colors: (P, 3) + + where batch_idx is of shape (P). For meshes batch_idx can be: + meshes.verts_packed_to_mesh_idx() or meshes.faces_packed_to_mesh_idx(). + """ + # TODO: handle multiple directional lights + # TODO: attentuate based on inverse squared distance to the light source + + if points.shape != normals.shape: + msg = "Expected points and normals to have the same shape: got %r, %r" + raise ValueError(msg % (points.shape, normals.shape)) + + # Ensure all inputs have same batch dimension as points + matched_tensors = convert_to_tensors_and_broadcast( + points, + color, + direction, + camera_position, + shininess, + device=points.device, + ) + _, color, direction, camera_position, shininess = matched_tensors + + # Reshape direction and color so they have all the arbitrary intermediate + # dimensions as points. Assume first dim = batch dim and last dim = 3. + points_dims = points.shape[1:-1] + expand_dims = (-1,) + (1,) * len(points_dims) + if direction.shape != normals.shape: + direction = direction.view(expand_dims + (3,)) + if color.shape != normals.shape: + color = color.view(expand_dims + (3,)) + if camera_position.shape != normals.shape: + camera_position = camera_position.view(expand_dims + (3,)) + if shininess.shape != normals.shape: + shininess = shininess.view(expand_dims) + + # Renormalize the normals in case they have been interpolated. + normals = F.normalize(normals, p=2, dim=-1, eps=1e-6) + direction = F.normalize(direction, p=2, dim=-1, eps=1e-6) + cos_angle = torch.sum(normals * direction, dim=-1) + # No specular highlights if angle is less than 0. + mask = (cos_angle > 0).to(torch.float32) + + # Calculate the specular reflection. + view_direction = camera_position - points + view_direction = F.normalize(view_direction, p=2, dim=-1, eps=1e-6) + reflect_direction = -direction + 2 * (cos_angle[..., None] * normals) + + # Cosine of the angle between the reflected light ray and the viewer + alpha = F.relu(torch.sum(view_direction * reflect_direction, dim=-1)) * mask + return color * torch.pow(alpha, shininess)[..., None] + + +class DirectionalLights(TensorProperties): + def __init__( + self, + ambient_color=((0.5, 0.5, 0.5),), + diffuse_color=((0.3, 0.3, 0.3),), + specular_color=((0.2, 0.2, 0.2),), + direction=((0, 1, 0),), + device: str = "cpu", + ): + """ + Args: + ambient_color: RGB color of the ambient component. + diffuse_color: RGB color of the diffuse component. + specular_color: RGB color of the specular component. + direction: (x, y, z) direction vector of the light. + device: torch.device on which the tensors should be located + + The inputs can each be + - 3 element tuple/list or list of lists + - torch tensor of shape (1, 3) + - torch tensor of shape (N, 3) + The inputs are broadcast against each other so they all have batch + dimension N. + """ + super().__init__( + device=device, + ambient_color=ambient_color, + diffuse_color=diffuse_color, + specular_color=specular_color, + direction=direction, + ) + _validate_light_properties(self) + if self.direction.shape[-1] != 3: + msg = "Expected direction to have shape (N, 3); got %r" + raise ValueError(msg % repr(self.direction.shape)) + + def clone(self): + other = DirectionalLights(device=self.device) + return super().clone(other) + + def diffuse(self, normals, points=None) -> torch.Tensor: + # NOTE: Points is not used but is kept in the args so that the API is + # the same for directional and point lights. The call sites should not + # need to know the light type. + return diffuse( + normals=normals, color=self.diffuse_color, direction=self.direction + ) + + def specular( + self, normals, points, camera_position, shininess + ) -> torch.Tensor: + return specular( + points=points, + normals=normals, + color=self.specular_color, + direction=self.direction, + camera_position=camera_position, + shininess=shininess, + ) + + +class PointLights(TensorProperties): + def __init__( + self, + ambient_color=((0.5, 0.5, 0.5),), + diffuse_color=((0.3, 0.3, 0.3),), + specular_color=((0.2, 0.2, 0.2),), + location=((0, 1, 0),), + device: str = "cpu", + ): + """ + Args: + ambient_color: RGB color of the ambient component + diffuse_color: RGB color of the diffuse component + specular_color: RGB color of the specular component + location: xyz position of the light. + device: torch.device on which the tensors should be located + + The inputs can each be + - 3 element tuple/list or list of lists + - torch tensor of shape (1, 3) + - torch tensor of shape (N, 3) + The inputs are broadcast against each other so they all have batch + dimension N. + """ + super().__init__( + device=device, + ambient_color=ambient_color, + diffuse_color=diffuse_color, + specular_color=specular_color, + location=location, + ) + _validate_light_properties(self) + if self.location.shape[-1] != 3: + msg = "Expected location to have shape (N, 3); got %r" + raise ValueError(msg % repr(self.location.shape)) + + def clone(self): + other = PointLights(device=self.device) + return super().clone(other) + + def diffuse(self, normals, points) -> torch.Tensor: + direction = self.location - points + return diffuse( + normals=normals, color=self.diffuse_color, direction=direction + ) + + def specular( + self, normals, points, camera_position, shininess + ) -> torch.Tensor: + direction = self.location - points + return specular( + points=points, + normals=normals, + color=self.specular_color, + direction=direction, + camera_position=camera_position, + shininess=shininess, + ) + + +def _validate_light_properties(obj): + props = ("ambient_color", "diffuse_color", "specular_color") + for n in props: + t = getattr(obj, n) + if t.shape[-1] != 3: + msg = "Expected %s to have shape (N, 3); got %r" + raise ValueError(msg % (n, t.shape)) diff --git a/pytorch3d/renderer/materials.py b/pytorch3d/renderer/materials.py new file mode 100644 index 00000000..788c937c --- /dev/null +++ b/pytorch3d/renderer/materials.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch + +from .utils import TensorProperties + + +class Materials(TensorProperties): + """ + A class for storing a batch of material properties. Currently only one + material per batch element is supported. + """ + + def __init__( + self, + ambient_color=((1, 1, 1),), + diffuse_color=((1, 1, 1),), + specular_color=((1, 1, 1),), + shininess=64, + device="cpu", + ): + """ + Args: + ambient_color: RGB ambient reflectivity of the material + diffuse_color: RGB diffuse reflectivity of the material + specular_color: RGB specular reflectivity of the material + shininess: The specular exponent for the material. This defines + the focus of the specular highlight with a high value + resulting in a concentrated highlight. Shininess values + can range from 0-1000. + device: torch.device or string + + ambient_color, diffuse_color and specular_color can be of shape + (1, 3) or (N, 3). shininess can be of shape (1) or (N). + + The colors and shininess are broadcast against each other so need to + have either the same batch dimension or batch dimension = 1. + """ + super().__init__( + device=device, + diffuse_color=diffuse_color, + ambient_color=ambient_color, + specular_color=specular_color, + shininess=shininess, + ) + for n in ["ambient_color", "diffuse_color", "specular_color"]: + t = getattr(self, n) + if t.shape[-1] != 3: + msg = "Expected %s to have shape (N, 3); got %r" + raise ValueError(msg % (n, t.shape)) + if self.shininess.shape != torch.Size([self._N]): + msg = "shininess should have shape (N); got %r" + raise ValueError(msg % repr(self.shininess.shape)) + + def clone(self): + other = Materials(device=self.device) + return super().clone(other) diff --git a/pytorch3d/renderer/mesh/__init__.py b/pytorch3d/renderer/mesh/__init__.py new file mode 100644 index 00000000..e8f62c72 --- /dev/null +++ b/pytorch3d/renderer/mesh/__init__.py @@ -0,0 +1,19 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .rasterize_meshes import rasterize_meshes +from .rasterizer import MeshRasterizer, RasterizationSettings +from .renderer import MeshRenderer +from .shader import ( + GouradShader, + PhongShader, + SilhouetteShader, + TexturedPhongShader, +) +from .shading import gourad_shading, phong_shading +from .texturing import ( # isort: skip + interpolate_face_attributes, + interpolate_texture_map, + interpolate_vertex_colors, +) + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/renderer/mesh/rasterize_meshes.py b/pytorch3d/renderer/mesh/rasterize_meshes.py new file mode 100644 index 00000000..99f3852d --- /dev/null +++ b/pytorch3d/renderer/mesh/rasterize_meshes.py @@ -0,0 +1,477 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +from typing import Optional +import torch + +from pytorch3d import _C + +# TODO make the epsilon user configurable +kEpsilon = 1e-30 + + +def rasterize_meshes( + meshes, + image_size: int = 256, + blur_radius: float = 0.0, + faces_per_pixel: int = 8, + bin_size: Optional[int] = None, + max_faces_per_bin: Optional[int] = None, + perspective_correct: bool = False, +): + """ + Rasterize a batch of meshes given the shape of the desired output image. + Each mesh is rasterized onto a separate image of shape + (image_size, image_size). + + Args: + meshes: A Meshes object representing a batch of meshes, batch size N. + image_size: Size in pixels of the output raster image for each mesh + in the batch. Assumes square images. + blur_radius: Float distance in the range [0, 2] used to expand the face + bounding boxes for rasterization. Setting blur radius + results in blurred edges around the shape instead of a + hard boundary. Set to 0 for no blur. + faces_per_pixel (Optional): Number of faces to save per pixel, returning + the nearest faces_per_pixel points along the z-axis. + bin_size: Size of bins to use for coarse-to-fine rasterization. Setting + bin_size=0 uses naive rasterization; setting bin_size=None attempts to + set it heuristically based on the shape of the input. This should not + affect the output, but can affect the speed of the forward pass. + faces_per_bin: Only applicable when using coarse-to-fine rasterization + (bin_size > 0); this is the maxiumum number of faces allowed within each + bin. If more than this many faces actually fall into a bin, an error + will be raised. This should not affect the output values, but can affect + the memory usage in the forward pass. + perspective_correct: Whether to apply perspective correction when computing + barycentric coordinates for pixels. + + Returns: + 4-element tuple containing + + - **pix_to_face**: LongTensor of shape + (N, image_size, image_size, faces_per_pixel) + giving the indices of the nearest faces at each pixel, + sorted in ascending z-order. + Concretely ``pix_to_face[n, y, x, k] = f`` means that + ``faces_verts[f]`` is the kth closest face (in the z-direction) + to pixel (y, x). Pixels that are hit by fewer than + faces_per_pixel are padded with -1. + - **zbuf**: FloatTensor of shape (N, image_size, image_size, faces_per_pixel) + giving the NDC z-coordinates of the nearest faces at each pixel, + sorted in ascending z-order. + Concretely, if ``pix_to_face[n, y, x, k] = f`` then + ``zbuf[n, y, x, k] = face_verts[f, 2]``. Pixels hit by fewer than + faces_per_pixel are padded with -1. + - **barycentric**: FloatTensor of shape + (N, image_size, image_size, faces_per_pixel, 3) + giving the barycentric coordinates in NDC units of the + nearest faces at each pixel, sorted in ascending z-order. + Concretely, if ``pix_to_face[n, y, x, k] = f`` then + ``[w0, w1, w2] = barycentric[n, y, x, k]`` gives + the barycentric coords for pixel (y, x) relative to the face + defined by ``face_verts[f]``. Pixels hit by fewer than + faces_per_pixel are padded with -1. + - **pix_dists**: FloatTensor of shape + (N, image_size, image_size, faces_per_pixel) + giving the signed Euclidean distance (in NDC units) in the + x/y plane of each point closest to the pixel. Concretely if + ``pix_to_face[n, y, x, k] = f`` then ``pix_dists[n, y, x, k]`` is the + squared distance between the pixel (y, x) and the face given + by vertices ``face_verts[f]``. Pixels hit with fewer than + ``faces_per_pixel`` are padded with -1. + """ + verts_packed = meshes.verts_packed() + faces_packed = meshes.faces_packed() + face_verts = verts_packed[faces_packed] + mesh_to_face_first_idx = meshes.mesh_to_faces_packed_first_idx() + num_faces_per_mesh = meshes.num_faces_per_mesh() + + # TODO: Choose naive vs coarse-to-fine based on mesh size and image size. + if bin_size is None: + if not verts_packed.is_cuda: + # Binned CPU rasterization is not supported. + bin_size = 0 + else: + # TODO better heuristics for bin size. + if image_size <= 64: + bin_size = 8 + elif image_size <= 256: + bin_size = 16 + elif image_size <= 512: + bin_size = 32 + elif image_size <= 1024: + bin_size = 64 + + if max_faces_per_bin is None: + max_faces_per_bin = int(max(10000, verts_packed.shape[0] / 5)) + + return _RasterizeFaceVerts.apply( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + faces_per_pixel, + bin_size, + max_faces_per_bin, + perspective_correct, + ) + + +class _RasterizeFaceVerts(torch.autograd.Function): + """ + Torch autograd wrapper for forward and backward pass of rasterize_meshes + implemented in C++/CUDA. + + Args: + face_verts: Tensor of shape (F, 3, 3) giving (packed) vertex positions + for faces in all the meshes in the batch. Concretely, + face_verts[f, i] = [x, y, z] gives the coordinates for the + ith vertex of the fth face. These vertices are expected to + be in NDC coordinates in the range [-1, 1]. + mesh_to_face_first_idx: LongTensor of shape (N) giving the index in + faces_verts of the first face in each mesh in + the batch. + num_faces_per_mesh: LongTensor of shape (N) giving the number of faces + for each mesh in the batch. + image_size, blur_radius, faces_per_pixel: same as rasterize_meshes. + perspective_correct: same as rasterize_meshes. + + Returns: + same as rasterize_meshes function. + """ + + @staticmethod + def forward( + ctx, + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size: int = 256, + blur_radius: float = 0.01, + faces_per_pixel: int = 0, + bin_size: int = 0, + max_faces_per_bin: int = 0, + perspective_correct: bool = False, + ): + pix_to_face, zbuf, barycentric_coords, dists = _C.rasterize_meshes( + face_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + faces_per_pixel, + bin_size, + max_faces_per_bin, + perspective_correct, + ) + ctx.save_for_backward(face_verts, pix_to_face) + ctx.perspective_correct = perspective_correct + return pix_to_face, zbuf, barycentric_coords, dists + + @staticmethod + def backward( + ctx, grad_pix_to_face, grad_zbuf, grad_barycentric_coords, grad_dists + ): + grad_face_verts = None + grad_mesh_to_face_first_idx = None + grad_num_faces_per_mesh = None + grad_image_size = None + grad_radius = None + grad_faces_per_pixel = None + grad_bin_size = None + grad_max_faces_per_bin = None + grad_perspective_correct = None + face_verts, pix_to_face = ctx.saved_tensors + grad_face_verts = _C.rasterize_meshes_backward( + face_verts, + pix_to_face, + grad_zbuf, + grad_barycentric_coords, + grad_dists, + ctx.perspective_correct, + ) + grads = ( + grad_face_verts, + grad_mesh_to_face_first_idx, + grad_num_faces_per_mesh, + grad_image_size, + grad_radius, + grad_faces_per_pixel, + grad_bin_size, + grad_max_faces_per_bin, + grad_perspective_correct, + ) + return grads + + +def rasterize_meshes_python( + meshes, + image_size: int = 256, + blur_radius: float = 0.0, + faces_per_pixel: int = 8, + perspective_correct: bool = False, +): + """ + Naive PyTorch implementation of mesh rasterization with the same inputs and + outputs as the rasterize_meshes function. + + This function is not optimized and is implemented as a comparison for the + C++/CUDA implementations. + """ + N = len(meshes) + # Assume only square images. + # TODO(T52813608) extend support for non-square images. + H, W, = image_size, image_size + K = faces_per_pixel + device = meshes.device + + verts_packed = meshes.verts_packed() + faces_packed = meshes.faces_packed() + faces_verts = verts_packed[faces_packed] + mesh_to_face_first_idx = meshes.mesh_to_faces_packed_first_idx() + num_faces_per_mesh = meshes.num_faces_per_mesh() + + # Intialize output tensors. + face_idxs = torch.full( + (N, H, W, K), fill_value=-1, dtype=torch.int64, device=device + ) + zbuf = torch.full( + (N, H, W, K), fill_value=-1, dtype=torch.float32, device=device + ) + bary_coords = torch.full( + (N, H, W, K, 3), fill_value=-1, dtype=torch.float32, device=device + ) + pix_dists = torch.full( + (N, H, W, K), fill_value=-1, dtype=torch.float32, device=device + ) + + # NDC is from [-1, 1]. Get pixel size using specified image size. + pixel_width = 2.0 / W + pixel_height = 2.0 / H + + # Calculate all face bounding boxes. + x_mins = torch.min(faces_verts[:, :, 0], dim=1, keepdim=True).values + x_maxs = torch.max(faces_verts[:, :, 0], dim=1, keepdim=True).values + y_mins = torch.min(faces_verts[:, :, 1], dim=1, keepdim=True).values + y_maxs = torch.max(faces_verts[:, :, 1], dim=1, keepdim=True).values + + # Expand by blur radius. + x_mins = x_mins - np.sqrt(blur_radius) - kEpsilon + x_maxs = x_maxs + np.sqrt(blur_radius) + kEpsilon + y_mins = y_mins - np.sqrt(blur_radius) - kEpsilon + y_maxs = y_maxs + np.sqrt(blur_radius) + kEpsilon + + # Loop through meshes in the batch. + for n in range(N): + face_start_idx = mesh_to_face_first_idx[n] + face_stop_idx = face_start_idx + num_faces_per_mesh[n] + # Y coordinate of the top of the image. + yf = -1.0 + 0.5 * pixel_height + # Iterate through the horizontal lines of the image from top to bottom. + for yi in range(H): + # X coordinate of the left of the image. + xf = -1.0 + 0.5 * pixel_width + # Iterate through pixels on this horizontal line, left to right. + for xi in range(W): + top_k_points = [] + + # Check whether each face in the mesh affects this pixel. + for f in range(face_start_idx, face_stop_idx): + face = faces_verts[f].squeeze() + v0, v1, v2 = face.unbind(0) + + face_area = edge_function(v2, v0, v1) + + # Ignore faces which have zero area. + if face_area == 0.0: + continue + + outside_bbox = ( + xf < x_mins[f] + or xf > x_maxs[f] + or yf < y_mins[f] + or yf > y_maxs[f] + ) + + # Check if pixel is outside of face bbox. + if outside_bbox: + continue + + # Compute barycentric coordinates and pixel z distance. + pxy = torch.tensor( + [xf, yf], dtype=torch.float32, device=device + ) + + bary = barycentric_coordinates(pxy, v0[:2], v1[:2], v2[:2]) + if perspective_correct: + z0, z1, z2 = v0[2], v1[2], v2[2] + l0, l1, l2 = bary[0], bary[1], bary[2] + top0 = l0 * z1 * z2 + top1 = z0 * l1 * z2 + top2 = z0 * z1 * l2 + bot = top0 + top1 + top2 + bary = torch.stack([top0 / bot, top1 / bot, top2 / bot]) + pz = bary[0] * v0[2] + bary[1] * v1[2] + bary[2] * v2[2] + + # Check if point is behind the image. + if pz < 0: + continue + + # Calculate signed 2D distance from point to face. + # Points inside the triangle have negative distance. + dist = point_triangle_distance(pxy, v0[:2], v1[:2], v2[:2]) + inside = all(x > 0.0 for x in bary) + + signed_dist = dist * -1.0 if inside else dist + + # Add an epsilon to prevent errors when comparing distance + # to blur radius. + if not inside and dist >= blur_radius: + continue + + top_k_points.append((pz, f, bary, signed_dist)) + top_k_points.sort() + if len(top_k_points) > K: + top_k_points = top_k_points[:K] + + # Save to output tensors. + for k, (pz, f, bary, dist) in enumerate(top_k_points): + zbuf[n, yi, xi, k] = pz + face_idxs[n, yi, xi, k] = f + bary_coords[n, yi, xi, k, 0] = bary[0] + bary_coords[n, yi, xi, k, 1] = bary[1] + bary_coords[n, yi, xi, k, 2] = bary[2] + pix_dists[n, yi, xi, k] = dist + + # Move to the next horizontal pixel + xf += pixel_width + + # Move to the next vertical pixel + yf += pixel_height + + return face_idxs, zbuf, bary_coords, pix_dists + + +def edge_function(p, v0, v1): + r""" + Determines whether a point p is on the right side of a 2D line segment + given by the end points v0, v1. + + Args: + p: (x, y) Coordinates of a point. + v0, v1: (x, y) Coordinates of the end points of the edge. + + Returns: + area: The signed area of the parallelogram given by the vectors + + .. code-block:: python + + A = p - v0 + B = v1 - v0 + + v1 ________ + /\ / + A / \ / + / \ / + v0 /______\/ + B p + + The area can also be interpreted as the cross product A x B. + If the sign of the area is positive, the point p is on the + right side of the edge. Negative area indicates the point is on + the left side of the edge. i.e. for an edge v1 - v0 + + .. code-block:: python + + v1 + / + / + - / + + / + / + v0 + """ + return (p[0] - v0[0]) * (v1[1] - v0[1]) - (p[1] - v0[1]) * (v1[0] - v0[0]) + + +def barycentric_coordinates(p, v0, v1, v2): + """ + Compute the barycentric coordinates of a point relative to a triangle. + + Args: + p: Coordinates of a point. + v0, v1, v2: Coordinates of the triangle vertices. + + Returns + bary: (w0, w1, w2) barycentric coordinates in the range [0, 1]. + """ + area = edge_function(v2, v0, v1) + kEpsilon # 2 x face area. + w0 = edge_function(p, v1, v2) / area + w1 = edge_function(p, v2, v0) / area + w2 = edge_function(p, v0, v1) / area + return (w0, w1, w2) + + +def point_line_distance(p, v0, v1): + """ + Return minimum distance between line segment (v1 - v0) and point p. + + Args: + p: Coordinates of a point. + v0, v1: Coordinates of the end points of the line segment. + + Returns: + non-square distance to the boundary of the triangle. + + Consider the line extending the segment - this can be parameterized as + ``v0 + t (v1 - v0)``. + + First find the projection of point p onto the line. It falls where + ``t = [(p - v0) . (v1 - v0)] / |v1 - v0|^2`` + where . is the dot product. + + The parameter t is clamped from [0, 1] to handle points outside the + segment (v1 - v0). + + Once the projection of the point on the segment is known, the distance from + p to the projection gives the minimum distance to the segment. + """ + if p.shape != v0.shape != v1.shape: + raise ValueError("All points must have the same number of coordinates") + + v1v0 = v1 - v0 + l2 = v1v0.dot(v1v0) # |v1 - v0|^2 + if l2 == 0.0: + return torch.sqrt((p - v1).dot(p - v1)) # v0 == v1 + + t = (v1v0).dot(p - v0) / l2 + t = torch.clamp(t, min=0.0, max=1.0) + p_proj = v0 + t * v1v0 + delta_p = p_proj - p + return delta_p.dot(delta_p) + + +def point_triangle_distance(p, v0, v1, v2): + """ + Return shortest distance between a point and a triangle. + + Args: + p: Coordinates of a point. + v0, v1, v2: Coordinates of the three triangle vertices. + + Returns: + shortest absolute distance from the point to the triangle. + """ + if p.shape != v0.shape != v1.shape != v2.shape: + raise ValueError("All points must have the same number of coordinates") + + e01_dist = point_line_distance(p, v0, v1) + e02_dist = point_line_distance(p, v0, v2) + e12_dist = point_line_distance(p, v1, v2) + edge_dists_min = torch.min(torch.min(e01_dist, e02_dist), e12_dist) + + return edge_dists_min diff --git a/pytorch3d/renderer/mesh/rasterizer.py b/pytorch3d/renderer/mesh/rasterizer.py new file mode 100644 index 00000000..8c7b30c3 --- /dev/null +++ b/pytorch3d/renderer/mesh/rasterizer.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from dataclasses import dataclass +from typing import NamedTuple, Optional +import torch +import torch.nn as nn + +from ..cameras import get_world_to_view_transform +from .rasterize_meshes import rasterize_meshes + + +# Class to store the outputs of mesh rasterization +class Fragments(NamedTuple): + pix_to_face: torch.Tensor + zbuf: torch.Tensor + bary_coords: torch.Tensor + dists: torch.Tensor + + +# Class to store the mesh rasterization params with defaults +@dataclass +class RasterizationSettings: + image_size: int = 256 + blur_radius: float = 0.0 + faces_per_pixel: int = 1 + bin_size: Optional[int] = None + max_faces_per_bin: Optional[int] = None + perspective_correct: bool = False + + +class MeshRasterizer(nn.Module): + """ + This class implements methods for rasterizing a batch of heterogenous + Meshes. + """ + + def __init__(self, cameras, raster_settings=None): + """ + Args: + cameras: A cameras object which has a `transform_points` method + which returns the transformed points after applying the + world-to-view and view-to-screen + transformations. + raster_settings: the parameters for rasterization. This should be a + named tuple. + + All these initial settings can be overridden by passing keyword + arguments to the forward function. + """ + super().__init__() + if raster_settings is None: + raster_settings = RasterizationSettings() + + self.cameras = cameras + self.raster_settings = raster_settings + + def transform(self, meshes_world, **kwargs) -> torch.Tensor: + """ + Args: + meshes_world: a Meshes object representing a batch of meshes with + vertex coordinates in world space. + + Returns: + meshes_screen: a Meshes object with the vertex positions in screen + space + + NOTE: keeping this as a separate function for readability but it could + be moved into forward. + """ + cameras = kwargs.get("cameras", self.cameras) + verts_world = meshes_world.verts_padded() + verts_world_packed = meshes_world.verts_packed() + verts_screen = cameras.transform_points(verts_world, **kwargs) + + # NOTE: Retaining view space z coordinate for now. + # TODO: Revisit whether or not to transform z coordinate to [-1, 1] or + # [0, 1] range. + view_transform = get_world_to_view_transform(R=cameras.R, T=cameras.T) + verts_view = view_transform.transform_points(verts_world) + verts_screen[..., 2] = verts_view[..., 2] + + # Offset verts of input mesh to reuse cached padded/packed calculations. + pad_to_packed_idx = meshes_world.verts_padded_to_packed_idx() + verts_screen_packed = verts_screen.view(-1, 3)[pad_to_packed_idx, :] + verts_packed_offset = verts_screen_packed - verts_world_packed + return meshes_world.offset_verts(verts_packed_offset) + + def forward(self, meshes_world, **kwargs) -> Fragments: + """ + Args: + meshes_world: a Meshes object representing a batch of meshes with + coordinates in world space. + Returns: + Fragments: Rasterization outputs as a named tuple. + """ + meshes_screen = self.transform(meshes_world, **kwargs) + raster_settings = kwargs.get("raster_settings", self.raster_settings) + # TODO(jcjohns): Should we try to set perspective_correct automatically + # based on the type of the camera? + pix_to_face, zbuf, bary_coords, dists = rasterize_meshes( + meshes_screen, + image_size=raster_settings.image_size, + blur_radius=raster_settings.blur_radius, + faces_per_pixel=raster_settings.faces_per_pixel, + bin_size=raster_settings.bin_size, + max_faces_per_bin=raster_settings.max_faces_per_bin, + perspective_correct=raster_settings.perspective_correct, + ) + return Fragments( + pix_to_face=pix_to_face, + zbuf=zbuf, + bary_coords=bary_coords, + dists=dists, + ) diff --git a/pytorch3d/renderer/mesh/renderer.py b/pytorch3d/renderer/mesh/renderer.py new file mode 100644 index 00000000..aeac515d --- /dev/null +++ b/pytorch3d/renderer/mesh/renderer.py @@ -0,0 +1,39 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn as nn + +# A renderer class should be initialized with a +# function for rasterization and a function for shading. +# The rasterizer should: +# - transform inputs from world -> screen space +# - rasterize inputs +# - return fragments +# The shader can take fragments as input along with any other properties of +# the scene and generate images. + +# E.g. rasterize inputs and then shade +# +# fragments = self.rasterize(meshes) +# images = self.shader(fragments, meshes) +# return images + + +class MeshRenderer(nn.Module): + """ + A class for rendering a batch of heterogeneous meshes. The class should + be initialized with a rasterizer and shader class which each have a forward + function. + """ + + def __init__(self, rasterizer, shader): + super().__init__() + self.rasterizer = rasterizer + self.shader = shader + + def forward(self, meshes_world, **kwargs) -> torch.Tensor: + fragments = self.rasterizer(meshes_world, **kwargs) + images = self.shader(fragments, meshes_world, **kwargs) + return images diff --git a/pytorch3d/renderer/mesh/shader.py b/pytorch3d/renderer/mesh/shader.py new file mode 100644 index 00000000..5a151670 --- /dev/null +++ b/pytorch3d/renderer/mesh/shader.py @@ -0,0 +1,201 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn as nn + +from ..blending import ( + BlendParams, + hard_rgb_blend, + sigmoid_alpha_blend, + softmax_rgb_blend, +) +from ..cameras import OpenGLPerspectiveCameras +from ..lighting import PointLights +from ..materials import Materials +from .shading import gourad_shading, phong_shading +from .texturing import interpolate_texture_map, interpolate_vertex_colors + +# A Shader should take as input fragments from the output of rasterization +# along with scene params and output images. A shader could perform operations +# such as: +# - interpolate vertex attributes for all the fragments +# - sample colors from a texture map +# - apply per pixel lighting +# - blend colors across top K faces per pixel. + + +class PhongShader(nn.Module): + """ + Per pixel lighting. Apply the lighting model using the interpolated coords + and normals for each pixel. + + To use the default values, simply initialize the shader with the desired + device e.g. + + .. code-block:: + + shader = PhongShader(device=torch.device("cuda:0")) + """ + + def __init__(self, device="cpu", cameras=None, lights=None, materials=None): + super().__init__() + self.lights = ( + lights if lights is not None else PointLights(device=device) + ) + self.materials = ( + materials if materials is not None else Materials(device=device) + ) + self.cameras = ( + cameras + if cameras is not None + else OpenGLPerspectiveCameras(device=device) + ) + + def forward(self, fragments, meshes, **kwargs) -> torch.Tensor: + texels = interpolate_vertex_colors(fragments, meshes) + cameras = kwargs.get("cameras", self.cameras) + lights = kwargs.get("lights", self.lights) + materials = kwargs.get("materials", self.materials) + colors = phong_shading( + meshes=meshes, + fragments=fragments, + texels=texels, + lights=lights, + cameras=cameras, + materials=materials, + ) + images = hard_rgb_blend(colors, fragments) + return images + + +class GouradShader(nn.Module): + """ + Per vertex lighting. Apply the lighting model to the vertex colors and then + interpolate using the barycentric coordinates to get colors for each pixel. + + To use the default values, simply initialize the shader with the desired + device e.g. + + .. code-block:: + + shader = GouradShader(device=torch.device("cuda:0")) + """ + + def __init__(self, device="cpu", cameras=None, lights=None, materials=None): + super().__init__() + self.lights = ( + lights if lights is not None else PointLights(device=device) + ) + self.materials = ( + materials if materials is not None else Materials(device=device) + ) + self.cameras = ( + cameras + if cameras is not None + else OpenGLPerspectiveCameras(device=device) + ) + + def forward(self, fragments, meshes, **kwargs) -> torch.Tensor: + cameras = kwargs.get("cameras", self.cameras) + lights = kwargs.get("lights", self.lights) + materials = kwargs.get("materials", self.materials) + pixel_colors = gourad_shading( + meshes=meshes, + fragments=fragments, + lights=lights, + cameras=cameras, + materials=materials, + ) + images = hard_rgb_blend(pixel_colors, fragments) + return images + + +class TexturedPhongShader(nn.Module): + """ + Per pixel lighting applied to a texture map. First interpolate the vertex + uv coordinates and sample from a texture map. Then apply the lighting model + using the interpolated coords and normals for each pixel. + + To use the default values, simply initialize the shader with the desired + device e.g. + + .. code-block:: + + shader = TexturedPhongShader(device=torch.device("cuda:0")) + """ + + def __init__( + self, + device="cpu", + cameras=None, + lights=None, + materials=None, + blend_params=None, + ): + super().__init__() + self.lights = ( + lights if lights is not None else PointLights(device=device) + ) + self.materials = ( + materials if materials is not None else Materials(device=device) + ) + self.cameras = ( + cameras + if cameras is not None + else OpenGLPerspectiveCameras(device=device) + ) + self.blend_params = ( + blend_params if blend_params is not None else BlendParams() + ) + + def forward(self, fragments, meshes, **kwargs) -> torch.Tensor: + texels = interpolate_texture_map(fragments, meshes) + cameras = kwargs.get("cameras", self.cameras) + lights = kwargs.get("lights", self.lights) + materials = kwargs.get("materials", self.materials) + colors = phong_shading( + meshes=meshes, + fragments=fragments, + texels=texels, + lights=lights, + cameras=cameras, + materials=materials, + ) + images = softmax_rgb_blend(colors, fragments, self.blend_params) + return images + + +class SilhouetteShader(nn.Module): + """ + Calculate the silhouette by blending the top K faces for each pixel based + on the 2d euclidean distance of the centre of the pixel to the mesh face. + + Use this shader for generating silhouettes similar to SoftRasterizer [0]. + + .. note:: + + To be consistent with SoftRasterizer, initialize the + RasterizationSettings for the rasterizer with + `blur_radius = np.log(1. / 1e-4 - 1.) * blend_params.sigma` + + [0] Liu et al, 'Soft Rasterizer: A Differentiable Renderer for Image-based + 3D Reasoning', ICCV 2019 + """ + + def __init__(self, blend_params=None): + super().__init__() + self.blend_params = ( + blend_params if blend_params is not None else BlendParams() + ) + + def forward(self, fragments, meshes, **kwargs) -> torch.Tensor: + """" + Only want to render the silhouette so RGB values can be ones. + There is no need for lighting or texturing + """ + colors = torch.ones_like(fragments.bary_coords) + blend_params = kwargs.get("blend_params", self.blend_params) + images = sigmoid_alpha_blend(colors, fragments, blend_params) + return images diff --git a/pytorch3d/renderer/mesh/shading.py b/pytorch3d/renderer/mesh/shading.py new file mode 100644 index 00000000..726bf5eb --- /dev/null +++ b/pytorch3d/renderer/mesh/shading.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from typing import Tuple +import torch + +from .texturing import interpolate_face_attributes + + +def _apply_lighting( + points, normals, lights, cameras, materials +) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + """ + Args: + points: torch tensor of shape (N, P, 3) or (P, 3). + normals: torch tensor of shape (N, P, 3) or (P, 3) + lights: instance of the Lights class. + cameras: instance of the Cameras class. + materials: instance of the Materials class. + + Returns: + ambient_color: same shape as materials.ambient_color + diffuse_color: same shape as the input points + specular_color: same shape as the input points + """ + light_diffuse = lights.diffuse(normals=normals, points=points) + light_specular = lights.specular( + normals=normals, + points=points, + camera_position=cameras.get_camera_center(), + shininess=materials.shininess, + ) + ambient_color = materials.ambient_color * lights.ambient_color + diffuse_color = materials.diffuse_color * light_diffuse + specular_color = materials.specular_color * light_specular + if normals.dim() == 2 and points.dim() == 2: + # If given packed inputs remove batch dim in output. + return ( + ambient_color.squeeze(), + diffuse_color.squeeze(), + specular_color.squeeze(), + ) + return ambient_color, diffuse_color, specular_color + + +def phong_shading( + meshes, fragments, lights, cameras, materials, texels +) -> torch.Tensor: + """ + Apply per pixel shading. First interpolate the vertex normals and + vertex coordinates using the barycentric coordinates to get the position + and normal at each pixel. Then compute the illumination for each pixel. + The pixel color is obtained by multiplying the pixel textures by the ambient + and diffuse illumination and adding the specular component. + + Args: + meshes: Batch of meshes + fragments: Fragments named tuple with the outputs of rasterization + lights: Lights class containing a batch of lights + cameras: Cameras class containing a batch of cameras + materials: Materials class containing a batch of material properties + texels: texture per pixel of shape (N, H, W, K, 3) + + Returns: + colors: (N, H, W, K, 3) + """ + verts = meshes.verts_packed() # (V, 3) + faces = meshes.faces_packed() # (F, 3) + vertex_normals = meshes.verts_normals_packed() # (V, 3) + faces_verts = verts[faces] + faces_normals = vertex_normals[faces] + pixel_coords = interpolate_face_attributes(fragments, faces_verts) + pixel_normals = interpolate_face_attributes(fragments, faces_normals) + ambient, diffuse, specular = _apply_lighting( + pixel_coords, pixel_normals, lights, cameras, materials + ) + colors = (ambient + diffuse) * texels + specular + return colors + + +def gourad_shading( + meshes, fragments, lights, cameras, materials +) -> torch.Tensor: + """ + Apply per vertex shading. First compute the vertex illumination by applying + ambient, diffuse and specular lighting. If vertex color is available, + combine the ambient and diffuse vertex illumination with the vertex color + and add the specular component to determine the vertex shaded color. + Then interpolate the vertex shaded colors using the barycentric coordinates + to get a color per pixel. + + Args: + meshes: Batch of meshes + fragments: Fragments named tuple with the outputs of rasterization + lights: Lights class containing a batch of lights parameters + cameras: Cameras class containing a batch of cameras parameters + materials: Materials class containing a batch of material properties + + Returns: + colors: (N, H, W, K, 3) + """ + faces = meshes.faces_packed() # (F, 3) + verts = meshes.verts_packed() + vertex_normals = meshes.verts_normals_packed() # (V, 3) + vertex_colors = meshes.textures.verts_rgb_packed() + vert_to_mesh_idx = meshes.verts_packed_to_mesh_idx() + + # Format properties of lights and materials so they are compatible + # with the packed representation of the vertices. This transforms + # all tensor properties in the class from shape (N, ...) -> (V, ...) where + # V is the number of packed vertices. If the number of meshes in the + # batch is one then this is not necessary. + if len(meshes) > 1: + lights = lights.clone().gather_props(vert_to_mesh_idx) + cameras = cameras.clone().gather_props(vert_to_mesh_idx) + materials = materials.clone().gather_props(vert_to_mesh_idx) + + # Calculate the illumination at each vertex + ambient, diffuse, specular = _apply_lighting( + verts, vertex_normals, lights, cameras, materials + ) + verts_colors_shaded = vertex_colors * (ambient + diffuse) + specular + face_colors = verts_colors_shaded[faces] + colors = interpolate_face_attributes(fragments, face_colors) + return colors diff --git a/pytorch3d/renderer/mesh/texturing.py b/pytorch3d/renderer/mesh/texturing.py new file mode 100644 index 00000000..b79dbe3e --- /dev/null +++ b/pytorch3d/renderer/mesh/texturing.py @@ -0,0 +1,182 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +import torch.nn.functional as F + +from pytorch3d.structures.textures import Textures + + +def _clip_barycentric_coordinates(bary) -> torch.Tensor: + """ + Args: + bary: barycentric coordinates of shape (...., 3) where `...` represents + an arbitrary number of dimensions + + Returns: + bary: All barycentric coordinate values clipped to the range [0, 1] + and renormalized. The output is the same shape as the input. + """ + if bary.shape[-1] != 3: + msg = "Expected barycentric coords to have last dim = 3; got %r" + raise ValueError(msg % bary.shape) + clipped = bary.clamp(min=0, max=1) + clipped_sum = torch.clamp(clipped.sum(dim=-1, keepdim=True), min=1e-5) + clipped = clipped / clipped_sum + return clipped + + +def interpolate_face_attributes( + fragments, face_attributes: torch.Tensor, bary_clip: bool = False +) -> torch.Tensor: + """ + Interpolate arbitrary face attributes using the barycentric coordinates + for each pixel in the rasterized output. + + Args: + fragments: + The outputs of rasterization. From this we use + + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. + - barycentric_coords: FloatTensor of shape (N, H, W, K, 3) specifying + the barycentric coordianates of each pixel + relative to the faces (in the packed + representation) which overlap the pixel. + face_attributes: packed attributes of shape (total_faces, 3, D), + specifying the value of the attribute for each + vertex in the face. + bary_clip: Bool to indicate if barycentric_coords should be clipped + before being used for interpolation. + + Returns: + pixel_vals: tensor of shape (N, H, W, K, D) giving the interpolated + value of the face attribute for each pixel. + """ + pix_to_face = fragments.pix_to_face + barycentric_coords = fragments.bary_coords + F, FV, D = face_attributes.shape + if FV != 3: + raise ValueError("Faces can only have three vertices; got %r" % FV) + N, H, W, K, _ = barycentric_coords.shape + if pix_to_face.shape != (N, H, W, K): + msg = "pix_to_face must have shape (batch_size, H, W, K); got %r" + raise ValueError(msg % pix_to_face.shape) + if bary_clip: + barycentric_coords = _clip_barycentric_coordinates(barycentric_coords) + + # Replace empty pixels in pix_to_face with 0 in order to interpolate. + mask = pix_to_face == -1 + pix_to_face = pix_to_face.clone() + pix_to_face[mask] = 0 + idx = pix_to_face.view(N * H * W * K, 1, 1).expand(N * H * W * K, 3, D) + pixel_face_vals = face_attributes.gather(0, idx).view(N, H, W, K, 3, D) + pixel_vals = (barycentric_coords[..., None] * pixel_face_vals).sum(dim=-2) + pixel_vals[mask] = 0 # Replace masked values in output. + return pixel_vals + + +def interpolate_texture_map(fragments, meshes) -> torch.Tensor: + """ + Interpolate a 2D texture map using uv vertex texture coordinates for each + face in the mesh. First interpolate the vertex uvs using barycentric coordinates + for each pixel in the rasterized output. Then interpolate the texture map + using the uv coordinate for each pixel. + + Args: + fragments: + The outputs of rasterization. From this we use + + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. + - barycentric_coords: FloatTensor of shape (N, H, W, K, 3) specifying + the barycentric coordianates of each pixel + relative to the faces (in the packed + representation) which overlap the pixel. + meshes: Meshes representing a batch of meshes. It is expected that + meshes has a textures attribute which is an instance of the + Textures class. + + Returns: + texels: tensor of shape (N, H, W, K, C) giving the interpolated + texture for each pixel in the rasterized image. + """ + if not isinstance(meshes.textures, Textures): + msg = "Expected meshes.textures to be an instance of Textures; got %r" + raise ValueError(msg % type(meshes.textures)) + + faces_uvs = meshes.textures.faces_uvs_packed() + verts_uvs = meshes.textures.verts_uvs_packed() + faces_verts_uvs = verts_uvs[faces_uvs] + texture_maps = meshes.textures.maps_padded() + + # pixel_uvs: (N, H, W, K, 2) + pixel_uvs = interpolate_face_attributes(fragments, faces_verts_uvs) + + N, H_out, W_out, K = fragments.pix_to_face.shape + N, H_in, W_in, C = texture_maps.shape # 3 for RGB + + # pixel_uvs: (N, H, W, K, 2) -> (N, K, H, W, 2) -> (NK, H, W, 2) + pixel_uvs = pixel_uvs.permute(0, 3, 1, 2, 4).view(N * K, H_out, W_out, 2) + + # textures.map: + # (N, H, W, C) -> (N, C, H, W) -> (1, N, C, H, W) + # -> expand (K, N, C, H, W) -> reshape (N*K, C, H, W) + texture_maps = ( + texture_maps.permute(0, 3, 1, 2)[None, ...] + .expand(K, -1, -1, -1, -1) + .transpose(0, 1) + .reshape(N * K, C, H_in, W_in) + ) + + # Textures: (N*K, C, H, W), pixel_uvs: (N*K, H, W, 2) + # Now need to format the pixel uvs and the texture map correctly! + # From pytorch docs, grid_sample takes `grid` and `input`: + # grid specifies the sampling pixel locations normalized by + # the input spatial dimensions It should have most + # values in the range of [-1, 1]. Values x = -1, y = -1 + # is the left-top pixel of input, and values x = 1, y = 1 is the + # right-bottom pixel of input. + + pixel_uvs = pixel_uvs * 2.0 - 1.0 + texture_maps = torch.flip( + texture_maps, [2] + ) # flip y axis of the texture map + if texture_maps.device != pixel_uvs.device: + texture_maps = texture_maps.to(pixel_uvs.device) + texels = F.grid_sample(texture_maps, pixel_uvs, align_corners=False) + texels = texels.view(N, K, C, H_out, W_out).permute(0, 3, 4, 1, 2) + return texels + + +def interpolate_vertex_colors(fragments, meshes) -> torch.Tensor: + """ + Detemine the color for each rasterized face. Interpolate the colors for + vertices which form the face using the barycentric coordinates. + Args: + meshes: A Meshes class representing a batch of meshes. + fragments: + The outputs of rasterization. From this we use + + - pix_to_face: LongTensor of shape (N, H, W, K) specifying the indices + of the faces (in the packed representation) which + overlap each pixel in the image. + - barycentric_coords: FloatTensor of shape (N, H, W, K, 3) specifying + the barycentric coordianates of each pixel + relative to the faces (in the packed + representation) which overlap the pixel. + + Returns: + texels: An texture per pixel of shape (N, H, W, K, C). + There will be one C dimensional value for each element in + fragments.pix_to_face. + """ + vertex_textures = meshes.textures.verts_rgb_padded().view(-1, 3) # (V, C) + vertex_textures = vertex_textures[meshes.verts_padded_to_packed_idx(), :] + faces_packed = meshes.faces_packed() + faces_textures = vertex_textures[faces_packed] # (F, 3, C) + texels = interpolate_face_attributes(fragments, faces_textures) + return texels diff --git a/pytorch3d/renderer/utils.py b/pytorch3d/renderer/utils.py new file mode 100644 index 00000000..d2024d34 --- /dev/null +++ b/pytorch3d/renderer/utils.py @@ -0,0 +1,317 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +from typing import Any, Union +import torch + + +class TensorAccessor(object): + """ + A helper class to be used with the __getitem__ method. This can be used for + getting/setting the values for an attribute of a class at one particular + index. This is useful when the attributes of a class are batched tensors + and one element in the batch needs to be modified. + """ + + def __init__(self, class_object, index: Union[int, slice]): + """ + Args: + class_object: this should be an instance of a class which has + attributes which are tensors representing a batch of + values. + index: int/slice, an index indicating the position in the batch. + In __setattr__ and __getattr__ only the value of class + attributes at this index will be accessed. + """ + self.__dict__["class_object"] = class_object + self.__dict__["index"] = index + + def __setattr__(self, name: str, value: Any): + """ + Update the attribute given by `name` to the value given by `value` + at the index specified by `self.index`. + + Args: + name: str, name of the attribute. + value: value to set the attribute to. + """ + v = getattr(self.class_object, name) + if not torch.is_tensor(v): + msg = "Can only set values on attributes which are tensors; got %r" + raise AttributeError(msg % type(v)) + + # Convert the attribute to a tensor if it is not a tensor. + if not torch.is_tensor(value): + value = torch.tensor( + value, + device=v.device, + dtype=v.dtype, + requires_grad=v.requires_grad, + ) + + # Check the shapes match the existing shape and the shape of the index. + if v.dim() > 1 and value.dim() > 1 and value.shape[1:] != v.shape[1:]: + msg = "Expected value to have shape %r; got %r" + raise ValueError(msg % (v.shape, value.shape)) + if ( + v.dim() == 0 + and isinstance(self.index, slice) + and len(value) != len(self.index) + ): + msg = "Expected value to have len %r; got %r" + raise ValueError(msg % (len(self.index), len(value))) + self.class_object.__dict__[name][self.index] = value + + def __getattr__(self, name: str): + """ + Return the value of the attribute given by "name" on self.class_object + at the index specified in self.index. + + Args: + name: string of the attribute name + """ + if hasattr(self.class_object, name): + return self.class_object.__dict__[name][self.index] + else: + msg = "Attribue %s not found on %r" + return AttributeError(msg % (name, self.class_object.__name__)) + + +BROADCAST_TYPES = (float, int, list, tuple, torch.Tensor, np.ndarray) + + +class TensorProperties(object): + """ + A mix-in class for storing tensors as properties with helper methods. + """ + + def __init__(self, dtype=torch.float32, device="cpu", **kwargs): + """ + Args: + dtype: data type to set for the inputs + device: str or torch.device + kwargs: any number of keyword arguments. Any arguments which are + of type (float/int/tuple/tensor/array) are broadcasted and + other keyword arguments are set as attributes. + """ + super().__init__() + self.device = device + self._N = 0 + if kwargs is not None: + + # broadcast all inputs which are float/int/list/tuple/tensor/array + # set as attributes anything else e.g. strings, bools + args_to_broadcast = {} + for k, v in kwargs.items(): + if isinstance(v, (str, bool)): + setattr(self, k, v) + elif isinstance(v, BROADCAST_TYPES): + args_to_broadcast[k] = v + else: + msg = "Arg %s with type %r is not broadcastable" + print(msg % (k, type(v))) + + names = args_to_broadcast.keys() + # convert from type dict.values to tuple + values = tuple(v for v in args_to_broadcast.values()) + + if len(values) > 0: + broadcasted_values = convert_to_tensors_and_broadcast( + *values, device=device + ) + + # Set broadcasted values as attributes on self. + for i, n in enumerate(names): + setattr(self, n, broadcasted_values[i]) + if self._N == 0: + self._N = broadcasted_values[i].shape[0] + + def __len__(self) -> int: + return self._N + + def isempty(self) -> bool: + return self._N == 0 + + def __getitem__(self, index: Union[int, slice]): + """ + + Args: + index: an int or slice used to index all the fields. + + Returns: + if `index` is an index int/slice return a TensorAccessor class + with getattribute/setattribute methods which return/update the value + at the index in the original camera. + """ + if isinstance(index, (int, slice)): + return TensorAccessor(class_object=self, index=index) + + msg = "Expected index of type int or slice; got %r" + raise ValueError(msg % type(index)) + + def to(self, device: str = "cpu"): + """ + In place operation to move class properties which are tensors to a + specified device. If self has a property "device", update this as well. + """ + for k in dir(self): + v = getattr(self, k) + if k == "device": + setattr(self, k, device) + if torch.is_tensor(v) and v.device != device: + setattr(self, k, v.to(device)) + return self + + def clone(self, other): + """ + Update the tensor properties of other with the cloned properties of self. + """ + for k in dir(self): + v = getattr(self, k) + if k == "device": + setattr(self, k, v) + if torch.is_tensor(v): + setattr(other, k, v.clone()) + return other + + def gather_props(self, batch_idx): + """ + This is an in place operation to reformat all tensor class attributes + based on a set of given indices using torch.gather. This is useful when + attributes which are batched tensors e.g. shape (N, 3) need to be + multiplied with another tensor which has a different first dimension + e.g. packed vertices of shape (V, 3). + + Example + + .. code-block:: python + + self.specular_color = (N, 3) tensor of specular colors for each mesh + + A lighting calculation may use + + .. code-block:: python + + verts_packed = meshes.verts_packed() # (V, 3) + + To multiply these two tensors the batch dimension needs to be the same. + To achieve this we can do + + .. code-block:: python + + batch_idx = meshes.verts_packed_to_mesh_idx() # (V) + + This gives index of the mesh for each vertex in verts_packed. + + .. code-block:: python + + self.gather_props(batch_idx) + self.specular_color = (V, 3) tensor with the specular color for + each packed vertex. + + torch.gather requires the index tensor to have the same shape as the + input tensor so this method takes care of the reshaping of the index + tensor to use with class attributes with arbitrary dimensions. + + Args: + batch_idx: shape (B, ...) where `...` represents an arbitrary + number of dimensions + + Returns: + self with all properties reshaped. e.g. a property with shape (N, 3) + is transformed to shape (B, 3). + """ + for k in dir(self): + v = getattr(self, k) + if torch.is_tensor(v): + if v.shape[0] > 1: + # There are different values for each batch element + # so gather these using the batch_idx + idx_dims = batch_idx.shape + tensor_dims = v.shape + if len(idx_dims) > len(tensor_dims): + msg = "batch_idx cannot have more dimensions than %s. " + msg += "got shape %r and %s has shape %r" + raise ValueError(msg % (k, idx_dims, k, tensor_dims)) + if idx_dims != tensor_dims: + # To use torch.gather the index tensor (batch_idx) has + # to have the same shape as the input tensor. + new_dims = len(tensor_dims) - len(idx_dims) + new_shape = idx_dims + (1,) * new_dims + expand_dims = (-1,) + tensor_dims[1:] + batch_idx = batch_idx.view(*new_shape) + batch_idx = batch_idx.expand(*expand_dims) + v = v.gather(0, batch_idx) + setattr(self, k, v) + return self + + +def format_tensor( + input, dtype=torch.float32, device: str = "cpu" +) -> torch.Tensor: + """ + Helper function for converting a scalar value to a tensor. + + Args: + input: Python scalar, Python list/tuple, torch scalar, 1D torch tensor + dtype: data type for the input + device: torch device on which the tensor should be placed. + + Returns: + input_vec: torch tensor with optional added batch dimension. + """ + if not torch.is_tensor(input): + input = torch.tensor(input, dtype=dtype, device=device) + if input.dim() == 0: + input = input.view(1) + if input.device != device: + input = input.to(device=device) + return input + + +def convert_to_tensors_and_broadcast( + *args, dtype=torch.float32, device: str = "cpu" +): + """ + Helper function to handle parsing an arbitrary number of inputs (*args) + which all need to have the same batch dimension. + The output is a list of tensors. + + Args: + *args: an arbitrary number of inputs + Each of the values in `args` can be one of the following + - Python scalar + - Torch scalar + - Torch tensor of shape (N, K_i) or (1, K_i) where K_i are + an arbitrary number of dimensions which can vary for each + value in args. In this case each input is broadcast to a + tensor of shape (N, K_i) + dtype: data type to use when creating new tensors. + device: torch device on which the tensors should be placed. + + Output: + args: A list of tensors of shape (N, K_i) + """ + # Convert all inputs to tensors with a batch dimension + args_1d = [format_tensor(c, dtype, device) for c in args] + + # Find broadcast size + sizes = [c.shape[0] for c in args_1d] + N = max(sizes) + + args_Nd = [] + for c in args_1d: + if c.shape[0] != 1 and c.shape[0] != N: + msg = "Got non-broadcastable sizes %r" % (sizes) + raise ValueError(msg) + + # Expand broadcast dim and keep non broadcast dims the same size + expand_sizes = (N,) + (-1,) * len(c.shape[1:]) + args_Nd.append(c.expand(*expand_sizes)) + + if len(args) == 1: + args_Nd = args_Nd[0] # Return the first element + + return args_Nd diff --git a/pytorch3d/structures/__init__.py b/pytorch3d/structures/__init__.py new file mode 100644 index 00000000..78cb585a --- /dev/null +++ b/pytorch3d/structures/__init__.py @@ -0,0 +1,12 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .meshes import Meshes +from .textures import Textures +from .utils import ( + list_to_packed, + list_to_padded, + packed_to_list, + padded_to_list, +) + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/structures/meshes.py b/pytorch3d/structures/meshes.py new file mode 100644 index 00000000..64cf79f1 --- /dev/null +++ b/pytorch3d/structures/meshes.py @@ -0,0 +1,1367 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import torch + +from pytorch3d import _C + +from . import utils as struct_utils +from .textures import Textures + + +class Meshes(object): + """ + This class provides functions for working with batches of triangulated + meshes with varying numbers of faces and vertices, and converting between + representations. + + Within Meshes, there are three different representations of the faces and + verts data: + + List + - only used for input as a starting point to convert to other representations. + Padded + - has specific batch dimension. + Packed + - no batch dimension. + - has auxillary variables used to index into the padded representation. + + Example: + + Input list of verts V_n = [[V_1], [V_2], ... , [V_N]] + where V_1, ... , V_N are the number of verts in each mesh and N is the + numer of meshes. + + Input list of faces F_n = [[F_1], [F_2], ... , [F_N]] + where F_1, ... , F_N are the number of faces in each mesh. + + # SPHINX IGNORE + List | Padded | Packed + ---------------------------|-------------------------|------------------------ + [[V_1], ... , [V_N]] | size = (N, max(V_n), 3) | size = (sum(V_n), 3) + | | + Example for verts: | | + | | + V_1 = 3, V_2 = 4, V_3 = 5 | size = (3, 5, 3) | size = (12, 3) + | | + List([ | tensor([ | tensor([ + [ | [ | [0.1, 0.3, 0.5], + [0.1, 0.3, 0.5], | [0.1, 0.3, 0.5], | [0.5, 0.2, 0.1], + [0.5, 0.2, 0.1], | [0.5, 0.2, 0.1], | [0.6, 0.8, 0.7], + [0.6, 0.8, 0.7], | [0.6, 0.8, 0.7], | [0.1, 0.3, 0.3], + ], | [0, 0, 0], | [0.6, 0.7, 0.8], + [ | [0, 0, 0], | [0.2, 0.3, 0.4], + [0.1, 0.3, 0.3], | ], | [0.1, 0.5, 0.3], + [0.6, 0.7, 0.8], | [ | [0.7, 0.3, 0.6], + [0.2, 0.3, 0.4], | [0.1, 0.3, 0.3], | [0.2, 0.4, 0.8], + [0.1, 0.5, 0.3], | [0.6, 0.7, 0.8], | [0.9, 0.5, 0.2], + ], | [0.2, 0.3, 0.4], | [0.2, 0.3, 0.4], + [ | [0.1, 0.5, 0.3], | [0.9, 0.3, 0.8], + [0.7, 0.3, 0.6], | [0, 0, 0], | ]) + [0.2, 0.4, 0.8], | ], | + [0.9, 0.5, 0.2], | [ | + [0.2, 0.3, 0.4], | [0.7, 0.3, 0.6], | + [0.9, 0.3, 0.8], | [0.2, 0.4, 0.8], | + ] | [0.9, 0.5, 0.2], | + ]) | [0.2, 0.3, 0.4], | + | [0.9, 0.3, 0.8], | + | ] | + | ]) | + Example for faces: | | + | | + F_1 = 1, F_2 = 2, F_3 = 7 | size = (3, 7, 3) | size = (10, 3) + | | + List([ | tensor([ | tensor([ + [ | [ | [ 0, 1, 2], + [0, 1, 2], | [0, 1, 2], | [ 3, 4, 5], + ], | [-1, -1, -1], | [ 4, 5, 6], + [ | [-1, -1, -1] | [ 8, 9, 7], + [0, 1, 2], | [-1, -1, -1] | [ 7, 8, 10], + [1, 2, 3], | [-1, -1, -1] | [ 9, 10, 8], + ], | [-1, -1, -1], | [11, 10, 9], + [ | [-1, -1, -1], | [11, 7, 8], + [1, 2, 0], | ], | [11, 10, 8], + [0, 1, 3], | [ | [11, 9, 8], + [2, 3, 1], | [0, 1, 2], | ]) + [4, 3, 2], | [1, 2, 3], | + [4, 0, 1], | [-1, -1, -1], | + [4, 3, 1], | [-1, -1, -1], | + [4, 2, 1], | [-1, -1, -1], | + ], | [-1, -1, -1], | + ]) | [-1, -1, -1], | + | ], | + | [ | + | [1, 2, 0], | + | [0, 1, 3], | + | [2, 3, 1], | + | [4, 3, 2], | + | [4, 0, 1], | + | [4, 3, 1], | + | [4, 2, 1], | + | ] | + | ]) | + ----------------------------------------------------------------------------- + + Auxillary variables for packed representation + + Name | Size | Example from above + -------------------------------|---------------------|----------------------- + | | + verts_packed_to_mesh_idx | size = (sum(V_n)) | tensor([ + | | 0, 0, 0, 1, 1, 1, + | | 1, 2, 2, 2, 2, 2 + | | )] + | | size = (12) + | | + mesh_to_verts_packed_first_idx | size = (N) | tensor([0, 3, 7]) + | | size = (3) + | | + num_verts_per_mesh | size = (N) | tensor([3, 4, 5]) + | | size = (3) + | | + faces_packed_to_mesh_idx | size = (sum(F_n)) | tensor([ + | | 0, 1, 1, 2, 2, 2, + | | 2, 2, 2, 2 + | | )] + | | size = (10) + | | + mesh_to_faces_packed_first_idx | size = (N) | tensor([0, 1, 3]) + | | size = (3) + | | + num_faces_per_mesh | size = (N) | tensor([1, 2, 7]) + | | size = (3) + | | + verts_padded_to_packed_idx | size = (sum(V_n)) | tensor([ + | | 0, 1, 2, 5, 6, 7, + | | 8, 10, 11, 12, 13, + | | 14 + | | )] + | | size = (12) + ----------------------------------------------------------------------------- + # SPHINX IGNORE + + From the faces, edges are computed and have packed and padded + representations with auxillary variables. + + E_n = [[E_1], ... , [E_N]] + where E_1, ... , E_N are the number of unique edges in each mesh. + Total number of unique edges = sum(E_n) + + # SPHINX IGNORE + Name | Size | Example from above + ------------------------------|-------------------------|---------------------- + | | + edges_packed | size = (sum(E_n), 2) | tensor([ + | | [0, 1], + | | [0, 2], + | | [1, 2], + | | ... + | | [10, 11], + | | )] + | | size = (18, 2) + | | + num_edges_per_mesh | size = (N) | tensor([3, 5, 10]) + | | size = (3) + | | + edges_packed_to_mesh_idx | size = (sum(E_n)) | tensor([ + | | 0, 0, 0, + | | . . . + | | 2, 2, 2 + | | ]) + | | size = (18) + | | + faces_packed_to_edges_packed | size = (sum(F_n), 3) | tensor([ + | | [2, 1, 0], + | | [5, 4, 3], + | | . . . + | | [12, 14, 16], + | | ]) + | | size = (10, 3) + | | + ---------------------------------------------------------------------------- + # SPHINX IGNORE + """ + + _INTERNAL_TENSORS = [ + "_verts_packed", + "_verts_packed_to_mesh_idx", + "_mesh_to_verts_packed_first_idx", + "_verts_padded", + "_num_verts_per_mesh", + "_faces_packed", + "_faces_packed_to_mesh_idx", + "_mesh_to_faces_packed_first_idx", + "_faces_padded", + "_faces_areas_packed", + "_verts_normals_packed", + "_faces_normals_packed", + "_num_faces_per_mesh", + "_edges_packed", + "_edges_packed_to_mesh_idx", + "_faces_packed_to_edges_packed", + "_num_edges_per_mesh", + "_verts_padded_to_packed_idx", + "_laplacian_packed", + "valid", + "equisized", + ] + + def __init__(self, verts=None, faces=None, textures=None): + """ + Args: + verts: + Can be either + + - List where each element is a tensor of shape (num_verts, 3) + containing the (x, y, z) coordinates of each vertex. + - Padded float tensor with shape (num_meshes, max_num_verts, 3). + Meshes should be padded with fill value of 0 so they all have + the same number of vertices. + faces: + Can be either + + - List where each element is a tensor of shape (num_faces, 3) + containing the indices of the 3 vertices in the corresponding + mesh in verts which form the triangular face. + - Padded long tensor of shape (num_meshes, max_num_faces, 3). + Meshes should be padded with fill value of -1 so they have + the same number of faces. + textures: Optional instance of the Textures class with mesh + texture properties. + + Refer to comments above for descriptions of List and Padded representations. + """ + self.device = None + if textures is not None and not isinstance(textures, Textures): + msg = "Expected textures to be of type Textures; got %r" + raise ValueError(msg % type(textures)) + self.textures = textures + + # Indicates whether the meshes in the list/batch have the same number + # of faces and vertices. + self.equisized = False + + # Boolean indicator for each mesh in the batch + # True if mesh has non zero number of verts and face, False otherwise. + self.valid = None + + self._N = 0 # batch size (number of meshes) + self._V = 0 # (max) number of vertices per mesh + self._F = 0 # (max) number of faces per mesh + + # List of Tensors of verts and faces. + self._verts_list = None + self._faces_list = None + + # Packed representation for verts. + self._verts_packed = None # (sum(V_n), 3) + self._verts_packed_to_mesh_idx = None # sum(V_n) + + # Index to convert verts from flattened padded to packed + self._verts_padded_to_packed_idx = None # N * max_V + + # Index of each mesh's first vert in the packed verts. + # Assumes packing is sequential. + self._mesh_to_verts_packed_first_idx = None # N + + # Packed representation for faces. + self._faces_packed = None # (sum(F_n), 3) + self._faces_packed_to_mesh_idx = None # sum(F_n) + + # Index of each mesh's first face in packed faces. + # Assumes packing is sequential. + self._mesh_to_faces_packed_first_idx = None # N + + # Packed representation of edges sorted by index of the first vertex + # in the edge. Edges can be shared between faces in a mesh. + self._edges_packed = None # (sum(E_n), 2) + + # Map from packed edges to corresponding mesh index. + self._edges_packed_to_mesh_idx = None # sum(E_n) + self._num_edges_per_mesh = None # N + + # Map from packed faces to packed edges. This represents the index of + # the edge opposite the vertex for each vertex in the face. E.g. + # + # v0 + # /\ + # / \ + # e1 / \ e2 + # / \ + # /________\ + # v2 e0 v1 + # + # Face (v0, v1, v2) => Edges (e0, e1, e2) + self._faces_packed_to_edges_packed = None # (sum(F_n), 3) + + # Padded representation of verts. + self._verts_padded = None # (N, max(V_n), 3) + self._num_verts_per_mesh = None # N + + # Padded representation of faces. + self._faces_padded = None # (N, max(F_n), 3) + self._num_faces_per_mesh = None # N + + # Face areas + self._faces_areas_packed = None + + # Normals + self._verts_normals_packed = None + self._faces_normals_packed = None + + # Packed representation of Laplacian Matrix + self._laplacian_packed = None + + # Identify type of verts and faces. + if isinstance(verts, list) and isinstance(faces, list): + self._verts_list = verts + self._faces_list = [ + f[f.gt(-1).all(1)].to(torch.int64) if len(f) > 0 else f + for f in faces + ] + self._N = len(self._verts_list) + self.device = torch.device("cpu") + self.valid = torch.zeros( + (self._N,), dtype=torch.bool, device=self.device + ) + if self._N > 0: + self.device = self._verts_list[0].device + num_verts_per_mesh = torch.tensor( + [len(v) for v in self._verts_list], device=self.device + ) + self._V = num_verts_per_mesh.max() + num_faces_per_mesh = torch.tensor( + [len(f) for f in self._faces_list], device=self.device + ) + self._F = num_faces_per_mesh.max() + self.valid = torch.tensor( + [ + len(v) > 0 and len(f) > 0 + for (v, f) in zip(self._verts_list, self._faces_list) + ], + dtype=torch.bool, + device=self.device, + ) + + if (len(num_verts_per_mesh.unique()) == 1) and ( + len(num_faces_per_mesh.unique()) == 1 + ): + self.equisized = True + + elif torch.is_tensor(verts) and torch.is_tensor(faces): + if verts.size(2) != 3 and faces.size(2) != 3: + raise ValueError( + "Verts and Faces tensors have incorrect dimensions." + ) + self._verts_padded = verts + self._faces_padded = faces.to(torch.int64) + self._N = self._verts_padded.shape[0] + self._V = self._verts_padded.shape[1] + self.device = self._verts_padded.device + self.valid = torch.zeros( + (self._N,), dtype=torch.bool, device=self.device + ) + if self._N > 0: + # Check that padded faces - which have value -1 - are at the + # end of the tensors + faces_not_padded = self._faces_padded.gt(-1).all(2) + num_faces = faces_not_padded.sum(1) + if (faces_not_padded[:, :-1] < faces_not_padded[:, 1:]).any(): + raise ValueError("Padding of faces must be at the end") + + # NOTE that we don't check for the ordering of padded verts + # as long as the faces index correspond to the right vertices. + + self.valid = num_faces > 0 + self._F = num_faces.max() + if len(num_faces.unique()) == 1: + self.equisized = True + + else: + raise ValueError( + "Verts and Faces must be either a list or a tensor with \ + shape (batch_size, N, 3) where N is either the maximum \ + number of verts or faces respectively." + ) + + def __len__(self): + return self._N + + def __getitem__(self, index): + """ + Args: + index: Specifying the index of the mesh to retrieve. + Can be an int, slice, list of ints or a boolean tensor. + + Returns: + Meshes object with selected meshes. The mesh tensors are not cloned. + """ + if isinstance(index, (int, slice)): + verts = self.verts_list()[index] + faces = self.faces_list()[index] + elif isinstance(index, list): + verts = [self.verts_list()[i] for i in index] + faces = [self.faces_list()[i] for i in index] + elif isinstance(index, torch.Tensor): + if index.dim() != 1 or index.dtype.is_floating_point: + raise IndexError(index) + # NOTE consider converting index to cpu for efficiency + if index.dtype == torch.bool: + # advanced indexing on a single dimension + index = index.nonzero() + index = index.squeeze(1) if index.numel() > 0 else index + index = index.tolist() + verts = [self.verts_list()[i] for i in index] + faces = [self.faces_list()[i] for i in index] + else: + raise IndexError(index) + + if torch.is_tensor(verts) and torch.is_tensor(faces): + return Meshes(verts=[verts], faces=[faces]) + elif isinstance(verts, list) and isinstance(faces, list): + return Meshes(verts=verts, faces=faces) + else: + raise ValueError("(verts, faces) not defined correctly") + + def isempty(self) -> bool: + """ + Checks whether any mesh is valid. + + Returns: + bool indicating whether there is any data. + """ + return self._N == 0 or self.valid.eq(False).all() + + def verts_list(self): + """ + Get the list representation of the vertices. + + Returns: + list of tensors of vertices of shape (V_n, 3). + """ + if self._verts_list is None: + assert ( + self._verts_padded is not None + ), "verts_padded is required to compute verts_list." + self._verts_list = [ + v[0] for v in self._verts_padded.split([1] * self._N, 0) + ] + return self._verts_list + + def faces_list(self): + """ + Get the list representation of the faces. + + Returns: + list of tensors of faces of shape (F_n, 3). + """ + if self._faces_list is None: + assert ( + self._faces_padded is not None + ), "faces_padded is required to compute faces_list." + self._faces_list = [] + for i in range(self._N): + valid = self._faces_padded[i].gt(-1).all(1) + self._faces_list.append(self._faces_padded[i, valid, :]) + return self._faces_list + + def verts_packed(self): + """ + Get the packed representation of the vertices. + + Returns: + tensor of vertices of shape (sum(V_n), 3). + """ + self._compute_packed() + return self._verts_packed + + def verts_packed_to_mesh_idx(self): + """ + Return a 1D tensor with the same first dimension as verts_packed. + verts_packed_to_mesh_idx[i] gives the index of the mesh which contains + verts_packed[i]. + + Returns: + 1D tensor of indices. + """ + self._compute_packed() + return self._verts_packed_to_mesh_idx + + def mesh_to_verts_packed_first_idx(self): + """ + Return a 1D tensor x with length equal to the number of meshes such that + the first vertex of the ith mesh is verts_packed[x[i]]. + + Returns: + 1D tensor of indices of first items. + """ + self._compute_packed() + return self._mesh_to_verts_packed_first_idx + + def num_verts_per_mesh(self): + """ + Return a 1D tensor x with length equal to the number of meshes giving + the number of vertices in each mesh. + + Returns: + 1D tensor of sizes. + """ + self._compute_packed() + return self._num_verts_per_mesh + + def faces_packed(self): + """ + Get the packed representation of the faces. + Faces are given by the indices of the three vertices in verts_packed. + + Returns: + tensor of faces of shape (sum(F_n), 3). + """ + self._compute_packed() + return self._faces_packed + + def faces_packed_to_mesh_idx(self): + """ + Return a 1D tensor with the same first dimension as faces_packed. + faces_packed_to_mesh_idx[i] gives the index of the mesh which contains + faces_packed[i]. + + Returns: + 1D tensor of indices. + """ + self._compute_packed() + return self._faces_packed_to_mesh_idx + + def mesh_to_faces_packed_first_idx(self): + """ + Return a 1D tensor x with length equal to the number of meshes such that + the first face of the ith mesh is faces_packed[x[i]]. + + Returns: + 1D tensor of indices of first items. + """ + self._compute_packed() + return self._mesh_to_faces_packed_first_idx + + def verts_padded(self): + """ + Get the padded representation of the vertices. + + Returns: + tensor of vertices of shape (N, max(V_n), 3). + """ + self._compute_padded() + return self._verts_padded + + def faces_padded(self): + """ + Get the padded representation of the faces. + + Returns: + tensor of faces of shape (N, max(F_n), 3). + """ + self._compute_padded() + return self._faces_padded + + def num_faces_per_mesh(self): + """ + Return a 1D tensor x with length equal to the number of meshes giving + the number of faces in each mesh. + + Returns: + 1D tensor of sizes. + """ + self._compute_packed() + return self._num_faces_per_mesh + + def edges_packed(self): + """ + Get the packed representation of the edges. + + Returns: + tensor of edges of shape (sum(E_n), 2). + """ + self._compute_edges_packed() + return self._edges_packed + + def edges_packed_to_mesh_idx(self): + """ + Return a 1D tensor with the same first dimension as edges_packed. + edges_packed_to_mesh_idx[i] gives the index of the mesh which contains + edges_packed[i]. + + Returns: + 1D tensor of indices. + """ + self._compute_edges_packed() + return self._edges_packed_to_mesh_idx + + def faces_packed_to_edges_packed(self): + """ + Get the packed representation of the faces in terms of edges. + Faces are given by the indices of the three edges in + the packed representation of the edges. + + Returns: + tensor of faces of shape (sum(F_n), 3). + """ + self._compute_edges_packed() + return self._faces_packed_to_edges_packed + + def num_edges_per_mesh(self): + """ + Return a 1D tensor x with length equal to the number of meshes giving + the number of edges in each mesh. + + Returns: + 1D tensor of sizes. + """ + self._compute_edges_packed() + return self._num_edges_per_mesh + + def verts_padded_to_packed_idx(self): + """ + Return a 1D tensor x with length equal to the total number of vertices + such that verts_packed()[i] is element x[i] of the flattened padded + representation. + The packed representation can be calculated as follows. + + .. code-block:: python + + p = verts_padded().reshape(-1, 3) + verts_packed = p[x] + + Returns: + 1D tensor of indices. + """ + self._compute_packed() + if self._verts_padded_to_packed_idx is not None: + return self._verts_padded_to_packed_idx + + self._verts_padded_to_packed_idx = torch.cat( + [ + torch.arange(v, dtype=torch.int64, device=self.device) + + i * self._V + for (i, v) in enumerate(self._num_verts_per_mesh) + ], + dim=0, + ) + return self._verts_padded_to_packed_idx + + def verts_normals_packed(self): + """ + Get the packed representation of the vertex normals. + + Returns: + tensor of normals of shape (sum(V_n), 3). + """ + self._compute_vertex_normals() + return self._verts_normals_packed + + def verts_normals_list(self): + """ + Get the list representation of the vertex normals. + + Returns: + list of tensors of normals of shape (V_n, 3). + """ + if self.isempty(): + return [ + torch.empty((0, 3), dtype=torch.float32, device=self.device) + ] * self._N + verts_normals_packed = self.verts_normals_packed() + split_size = self.num_verts_per_mesh().tolist() + return struct_utils.packed_to_list(verts_normals_packed, split_size) + + def verts_normals_padded(self): + """ + Get the padded representation of the vertex normals. + + Returns: + tensor of normals of shape (N, max(V_n), 3). + """ + if self.isempty(): + return torch.zeros( + (self._N, 0, 3), dtype=torch.float32, device=self.device + ) + verts_normals_list = self.verts_normals_list() + return struct_utils.list_to_padded( + verts_normals_list, + (self._V, 3), + pad_value=0.0, + equisized=self.equisized, + ) + + def faces_normals_packed(self): + """ + Get the packed representation of the face normals. + + Returns: + tensor of normals of shape (sum(F_n), 3). + """ + self._compute_face_areas_normals() + return self._faces_normals_packed + + def faces_normals_list(self): + """ + Get the list representation of the face normals. + + Returns: + list of tensors of normals of shape (F_n, 3). + """ + if self.isempty(): + return [ + torch.empty((0, 3), dtype=torch.float32, device=self.device) + ] * self._N + faces_normals_packed = self.faces_normals_packed() + split_size = self.num_faces_per_mesh().tolist() + return struct_utils.packed_to_list(faces_normals_packed, split_size) + + def faces_normals_padded(self): + """ + Get the padded representation of the face normals. + + Returns: + tensor of normals of shape (N, max(F_n), 3). + """ + if self.isempty(): + return torch.zeros( + (self._N, 0, 3), dtype=torch.float32, device=self.device + ) + faces_normals_list = self.faces_normals_list() + return struct_utils.list_to_padded( + faces_normals_list, + (self._F, 3), + pad_value=0.0, + equisized=self.equisized, + ) + + def faces_areas_packed(self): + """ + Get the packed representation of the face areas. + + Returns: + tensor of areas of shape (sum(F_n),). + """ + self._compute_face_areas_normals() + return self._faces_areas_packed + + def laplacian_packed(self): + self._compute_laplacian_packed() + return self._laplacian_packed + + def _compute_face_areas_normals(self, refresh: bool = False): + """ + Compute the area and normal of each face in faces_packed. + The convention of a normal for a face consisting of verts [v0, v1, v2] + is normal = (v1 - v0) x (v2 - v0) + + Args: + refresh: Set to True to force recomputation of face areas. + Default: False. + """ + if not ( + refresh + or any( + v is None + for v in [self._faces_areas_packed, self._faces_normals_packed] + ) + ): + return + faces_packed = self.faces_packed() + verts_packed = self.verts_packed() + if verts_packed.is_cuda and faces_packed.is_cuda: + face_areas, face_normals = _C.face_areas_normals( + verts_packed, faces_packed + ) + else: + vertices_faces = verts_packed[faces_packed] # (F, 3, 3) + # vector pointing from v0 to v1 + v01 = vertices_faces[:, 1] - vertices_faces[:, 0] + # vector pointing from v0 to v2 + v02 = vertices_faces[:, 2] - vertices_faces[:, 0] + normals = torch.cross(v01, v02, dim=1) # (F, 3) + face_areas = normals.norm(dim=-1) / 2 + face_normals = torch.nn.functional.normalize( + normals, p=2, dim=1, eps=1e-6 + ) + self._faces_areas_packed = face_areas + self._faces_normals_packed = face_normals + + def _compute_vertex_normals(self, refresh: bool = False): + """Computes the packed version of vertex normals from the packed verts + and faces. This assumes verts are shared between faces. The normal for + a vertex is computed as the sum of the normals of all the faces it is + part of weighed by the face areas. + + Args: + refresh: Set to True to force recomputation of vertex normals. + Default: False. + """ + if not ( + refresh or any(v is None for v in [self._verts_normals_packed]) + ): + return + + if self.isempty(): + self._verts_normals_packed = torch.zeros( + (self._N, 3), dtype=torch.int64, device=self.device + ) + else: + faces_packed = self.faces_packed() + verts_packed = self.verts_packed() + verts_normals = torch.zeros_like(verts_packed) + vertices_faces = verts_packed[faces_packed] + + # NOTE: this is already applying the area weighting as the magnitude + # of the cross product is 2 x area of the triangle. + verts_normals = verts_normals.index_add( + 0, + faces_packed[:, 1], + torch.cross( + vertices_faces[:, 2] - vertices_faces[:, 1], + vertices_faces[:, 0] - vertices_faces[:, 1], + dim=1, + ), + ) + verts_normals = verts_normals.index_add( + 0, + faces_packed[:, 2], + torch.cross( + vertices_faces[:, 0] - vertices_faces[:, 2], + vertices_faces[:, 1] - vertices_faces[:, 2], + dim=1, + ), + ) + verts_normals = verts_normals.index_add( + 0, + faces_packed[:, 0], + torch.cross( + vertices_faces[:, 1] - vertices_faces[:, 0], + vertices_faces[:, 2] - vertices_faces[:, 0], + dim=1, + ), + ) + + self._verts_normals_packed = torch.nn.functional.normalize( + verts_normals, eps=1e-6, dim=1 + ) + + def _compute_padded(self, refresh: bool = False): + """ + Computes the padded version of meshes from verts_list and faces_list. + """ + if not ( + refresh + or any(v is None for v in [self._verts_padded, self._faces_padded]) + ): + return + + verts_list = self._verts_list + faces_list = self._faces_list + assert ( + faces_list is not None and verts_list is not None + ), "faces_list and verts_list arguments are required" + + if self.isempty(): + self._faces_padded = torch.zeros( + (self._N, 0, 3), dtype=torch.int64, device=self.device + ) + self._verts_padded = torch.zeros( + (self._N, 0, 3), dtype=torch.float32, device=self.device + ) + else: + self._faces_padded = struct_utils.list_to_padded( + faces_list, + (self._F, 3), + pad_value=-1.0, + equisized=self.equisized, + ) + self._verts_padded = struct_utils.list_to_padded( + verts_list, + (self._V, 3), + pad_value=0.0, + equisized=self.equisized, + ) + + # TODO(nikhilar) Improve performance of _compute_packed. + def _compute_packed(self, refresh: bool = False): + """ + Computes the packed version of the meshes from verts_list and faces_list + and sets the values of auxillary tensors. + + Args: + refresh: Set to True to force recomputation of packed representations. + Default: False. + """ + + if not ( + refresh + or any( + v is None + for v in [ + self._verts_packed, + self._verts_packed_to_mesh_idx, + self._mesh_to_verts_packed_first_idx, + self._num_verts_per_mesh, + self._faces_packed, + self._faces_packed_to_mesh_idx, + self._mesh_to_faces_packed_first_idx, + self._num_faces_per_mesh, + ] + ) + ): + return + + # Packed can be calculated from padded or list, so can call the + # accessor function for verts_list and faces_list. + verts_list = self.verts_list() + faces_list = self.faces_list() + if self.isempty(): + self._verts_packed = torch.zeros( + (0, 3), dtype=torch.float32, device=self.device + ) + self._verts_packed_to_mesh_idx = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + self._mesh_to_verts_packed_first_idx = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + self._num_verts_per_mesh = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + + self._faces_packed = -torch.ones( + (0, 3), dtype=torch.int64, device=self.device + ) + self._faces_packed_to_mesh_idx = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + self._mesh_to_faces_packed_first_idx = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + self._num_faces_per_mesh = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + return + + verts_list_to_packed = struct_utils.list_to_packed(verts_list) + self._verts_packed = verts_list_to_packed[0] + self._num_verts_per_mesh = verts_list_to_packed[1] + self._mesh_to_verts_packed_first_idx = verts_list_to_packed[2] + self._verts_packed_to_mesh_idx = verts_list_to_packed[3] + + faces_list_to_packed = struct_utils.list_to_packed(faces_list) + faces_packed = faces_list_to_packed[0] + self._num_faces_per_mesh = faces_list_to_packed[1] + self._mesh_to_faces_packed_first_idx = faces_list_to_packed[2] + self._faces_packed_to_mesh_idx = faces_list_to_packed[3] + + faces_packed_offset = self._mesh_to_verts_packed_first_idx[ + self._faces_packed_to_mesh_idx + ] + self._faces_packed = faces_packed + faces_packed_offset.view(-1, 1) + + def _compute_edges_packed(self, refresh: bool = False): + """ + Computes edges in packed form from the packed version of faces and verts. + """ + if not ( + refresh + or any( + v is None + for v in [ + self._edges_packed, + self._faces_packed_to_mesh_idx, + self._edges_packed_to_mesh_idx, + self._num_edges_per_mesh, + ] + ) + ): + return + + if self.isempty(): + self._edges_packed = -torch.ones( + (0, 2), dtype=torch.int64, device=self.device + ) + self._edges_packed_to_mesh_idx = torch.zeros( + (0,), dtype=torch.int64, device=self.device + ) + return + + faces = self.faces_packed() + F = faces.shape[0] + v0, v1, v2 = faces.chunk(3, dim=1) + e01 = torch.cat([v0, v1], dim=1) # (sum(F_n), 2) + e12 = torch.cat([v1, v2], dim=1) # (sum(F_n), 2) + e20 = torch.cat([v2, v0], dim=1) # (sum(F_n), 2) + + # All edges including duplicates. + edges = torch.cat([e12, e20, e01], dim=0) # (sum(F_n)*3, 2) + edge_to_mesh = torch.cat( + [ + self._faces_packed_to_mesh_idx, + self._faces_packed_to_mesh_idx, + self._faces_packed_to_mesh_idx, + ], + dim=0, + ) # sum(F_n)*3 + + # Sort the edges in increasing vertex order to remove duplicates as + # the same edge may appear in different orientations in different faces. + # i.e. rows in edges after sorting will be of the form (v0, v1) where v1 > v0. + # This sorting does not change the order in dim=0. + edges, _ = edges.sort(dim=1) + + # Remove duplicate edges: convert each edge (v0, v1) into an + # integer hash = V * v0 + v1; this allows us to use the scalar version of + # unique which is much faster than edges.unique(dim=1) which is very slow. + # After finding the unique elements reconstruct the vertex indicies as: + # (v0, v1) = (hash / V, hash % V) + # The inverse maps from unique_edges back to edges: + # unique_edges[inverse_idxs] == edges + # i.e. inverse_idxs[i] == j means that edges[i] == unique_edges[j] + + V = self._verts_packed.shape[0] + edges_hash = V * edges[:, 0] + edges[:, 1] + u, inverse_idxs = torch.unique(edges_hash, return_inverse=True) + + # Find indices of unique elements. + # TODO (nikhilar) remove following 4 lines when torch.unique has support + # for returning unique indices + sorted_hash, sort_idx = torch.sort(edges_hash, dim=0) + unique_mask = torch.ones( + edges_hash.shape[0], dtype=torch.bool, device=self.device + ) + unique_mask[1:] = sorted_hash[1:] != sorted_hash[:-1] + unique_idx = sort_idx[unique_mask] + + self._edges_packed = torch.stack([u / V, u % V], dim=1) + self._edges_packed_to_mesh_idx = edge_to_mesh[unique_idx] + + face_to_edge = torch.arange(3 * F).view(3, F).t() + face_to_edge = inverse_idxs[face_to_edge] + self._faces_packed_to_edges_packed = face_to_edge + + num_edges_per_mesh = torch.zeros( + self._N, dtype=torch.int32, device=self.device + ) + ones = torch.ones(1, dtype=torch.int32, device=self.device).expand( + self._edges_packed_to_mesh_idx.shape + ) + self._num_edges_per_mesh = num_edges_per_mesh.scatter_add( + 0, self._edges_packed_to_mesh_idx, ones + ) + + def _compute_laplacian_packed(self, refresh: bool = False): + """ + Computes the laplacian in packed form. + The definition of the laplacian is + L[i, j] = -1 , if i == j + L[i, j] = 1 / deg(i) , if (i, j) is an edge + L[i, j] = 0 , otherwise + where deg(i) is the degree of the i-th vertex in the graph + + Returns: + Sparse FloatTensor of shape (V, V) where V = sum(V_n) + + """ + if not (refresh or self._laplacian_packed is None): + return + + if self.isempty(): + self._laplacian_packed = torch.zeros( + (0, 0), dtype=torch.float32, device=self.device + ).to_sparse() + return + + verts_packed = self.verts_packed() # (sum(V_n), 3) + edges_packed = self.edges_packed() # (sum(E_n), 3) + V = verts_packed.shape[0] # sum(V_n) + + e0, e1 = edges_packed.unbind(1) + + idx01 = torch.stack([e0, e1], dim=1) # (sum(E_n), 2) + idx10 = torch.stack([e1, e0], dim=1) # (sum(E_n), 2) + idx = torch.cat([idx01, idx10], dim=0).t() # (2, 2*sum(E_n)) + + # First, we construct the adjacency matrix, + # i.e. A[i, j] = 1 if (i,j) is an edge, or + # A[e0, e1] = 1 & A[e1, e0] = 1 + ones = torch.ones(idx.shape[1], dtype=torch.float32, device=self.device) + A = torch.sparse.FloatTensor(idx, ones, (V, V)) + + # the sum of i-th row of A gives the degree of the i-th vertex + deg = torch.sparse.sum(A, dim=1).to_dense() + + # We construct the Laplacian matrix by adding the non diagonal values + # i.e. L[i, j] = 1 ./ deg(i) if (i, j) is an edge + deg0 = deg[e0] + deg0 = torch.where(deg0 > 0.0, 1.0 / deg0, deg0) + deg1 = deg[e1] + deg1 = torch.where(deg1 > 0.0, 1.0 / deg1, deg1) + val = torch.cat([deg0, deg1]) + L = torch.sparse.FloatTensor(idx, val, (V, V)) + + # Then we add the diagonal values L[i, i] = -1. + idx = torch.arange(V, device=self.device) + idx = torch.stack([idx, idx], dim=0) + ones = torch.ones(idx.shape[1], dtype=torch.float32, device=self.device) + L -= torch.sparse.FloatTensor(idx, ones, (V, V)) + + self._laplacian_packed = L + + def clone(self): + """ + Deep copy of Meshes object. All internal tensors are cloned individually. + + Returns: + new Meshes object. + """ + verts_list = self.verts_list() + faces_list = self.faces_list() + new_verts_list = [v.clone() for v in verts_list] + new_faces_list = [f.clone() for f in faces_list] + other = Meshes(verts=new_verts_list, faces=new_faces_list) + for k in self._INTERNAL_TENSORS: + v = getattr(self, k) + if torch.is_tensor(v): + setattr(other, k, v.clone()) + + # Textures is not a tensor but has a clone method + if self.textures is not None: + other.textures = self.textures.clone() + return other + + def to(self, device, copy: bool = False): + """ + Match functionality of torch.Tensor.to() + If copy = True or the self Tensor is on a different device, the + returned tensor is a copy of self with the desired torch.device. + If copy = False and the self Tensor already has the correct torch.device, + then self is returned. + + Args: + device: Device id for the new tensor. + copy: Boolean indicator whether or not to clone self. Default False. + + Returns: + Meshes object. + """ + if not copy and self.device == device: + return self + + other = self.clone() + if self.device != device: + other.device = device + if other._N > 0: + other._verts_list = [v.to(device) for v in other._verts_list] + other._faces_list = [f.to(device) for f in other._faces_list] + for k in self._INTERNAL_TENSORS: + v = getattr(self, k) + if torch.is_tensor(v): + setattr(other, k, v.to(device)) + if self.textures is not None: + other.textures = self.textures.to(device) + return other + + def cpu(self): + return self.to(torch.device("cpu")) + + def cuda(self): + return self.to(torch.device("cuda")) + + def get_mesh_verts_faces(self, index: int): + """ + Get tensors for a single mesh from the list representation. + + Args: + index: Integer in the range [0, N). + + Returns: + verts: Tensor of shape (V, 3). + faces: LongTensor of shape (F, 3). + """ + if not isinstance(index, int): + raise ValueError("Mesh index must be an integer.") + if index < 0 or index > self._N: + raise ValueError( + "Mesh index must be in the range [0, N) where \ + N is the number of meshes in the batch." + ) + verts = self.verts_list() + faces = self.faces_list() + return verts[index], faces[index] + + # TODO(nikhilar) Move function to a utils file. + def split(self, split_sizes: list): + """ + Splits Meshes object of size N into a list of Meshes objects of + size len(split_sizes), where the i-th Meshes object is of size split_sizes[i]. + Similar to torch.split(). + + Args: + split_sizes: List of integer sizes of Meshes objects to be returned. + + Returns: + list[Meshes]. + """ + if not all(isinstance(x, int) for x in split_sizes): + raise ValueError("Value of split_sizes must be a list of integers.") + meshlist = [] + curi = 0 + for i in split_sizes: + meshlist.append(self[curi : curi + i]) + curi += i + return meshlist + + def offset_verts_(self, vert_offsets_packed): + """ + Add an offset to the vertices of this Meshes. In place operation. + + Args: + vert_offsets_packed: A Tensor of the same shape as self.verts_packed + giving offsets to be added to all vertices. + Returns: + self. + """ + verts_packed = self.verts_packed() + if vert_offsets_packed.shape != verts_packed.shape: + raise ValueError("Verts offsets must have dimension (all_v, 2).") + # update verts packed + self._verts_packed = verts_packed + vert_offsets_packed + new_verts_list = list( + self._verts_packed.split(self.num_verts_per_mesh().tolist(), 0) + ) + # update verts list + # Note that since _compute_packed() has been executed, verts_list + # cannot be None even if not provided during construction. + self._verts_list = new_verts_list + + # update verts padded + if self._verts_padded is not None: + for i, verts in enumerate(new_verts_list): + if len(verts) > 0: + self._verts_padded[i, : verts.shape[0], :] = verts + + # update face areas and normals and vertex normals + # only if the original attributes are computed + if any( + v is not None + for v in [self._faces_areas_packed, self._faces_normals_packed] + ): + self._compute_face_areas_normals(refresh=True) + if self._verts_normals_packed is not None: + self._compute_vertex_normals(refresh=True) + + return self + + # TODO(nikhilar) Move out of place operator to a utils file. + def offset_verts(self, vert_offsets_packed): + """ + Out of place offset_verts. + + Args: + vert_offsets_packed: A Tensor of the same shape as self.verts_packed + giving offsets to be added to all vertices. + Returns: + new Meshes object. + """ + new_mesh = self.clone() + return new_mesh.offset_verts_(vert_offsets_packed) + + def scale_verts_(self, scale): + """ + Multiply the vertices of this Meshes object by a scalar value. + In place operation. + + Args: + scale: A scalar, or a Tensor of shape (N,). + + Returns: + self. + """ + if not torch.is_tensor(scale): + scale = torch.full((len(self),), scale, device=self.device) + new_verts_list = [] + verts_list = self.verts_list() + for i, old_verts in enumerate(verts_list): + new_verts_list.append(scale[i] * old_verts) + # update list + self._verts_list = new_verts_list + # update packed + if self._verts_packed is not None: + self._verts_packed = torch.cat(new_verts_list, dim=0) + # update padded + if self._verts_padded is not None: + for i, verts in enumerate(self._verts_list): + if len(verts) > 0: + self._verts_padded[i, : verts.shape[0], :] = verts + + # update face areas and normals and vertex normals + # only if the original attributes are computed + if any( + v is not None + for v in [self._faces_areas_packed, self._faces_normals_packed] + ): + self._compute_face_areas_normals(refresh=True) + if self._verts_normals_packed is not None: + self._compute_vertex_normals(refresh=True) + return self + + def scale_verts(self, scale): + """ + Out of place scale_verts. + + Args: + scale: A scalar, or a Tensor of shape (N,). + + Returns: + new Meshes object. + """ + new_mesh = self.clone() + return new_mesh.scale_verts_(scale) + + # TODO(nikhilar) Move function to utils file. + def get_bounding_boxes(self): + """ + Compute an axis-aligned bounding box for each mesh in this Meshes object. + + Returns: + bboxes: Tensor of shape (N, 3, 2) where bbox[i, j] gives the + min and max values of mesh i along the jth coordinate axis. + """ + all_mins, all_maxes = [], [] + for verts in self.verts_list(): + cur_mins = verts.min(dim=0)[0] # (3,) + cur_maxes = verts.max(dim=0)[0] # (3,) + all_mins.append(cur_mins) + all_maxes.append(cur_maxes) + all_mins = torch.stack(all_mins, dim=0) # (N, 3) + all_maxes = torch.stack(all_maxes, dim=0) # (N, 3) + bboxes = torch.stack([all_mins, all_maxes], dim=2) + return bboxes + + def extend(self, N: int): + """ + Create new Meshes class which contains each input mesh N times + + Args: + N: number of new copies of each mesh. + + Returns: + new Meshes object. + """ + if not isinstance(N, int): + raise ValueError("N must be an integer.") + if N <= 0: + raise ValueError("N must be > 0.") + new_verts_list, new_faces_list = [], [] + for verts, faces in zip(self.verts_list(), self.faces_list()): + new_verts_list.extend(verts.clone() for _ in range(N)) + new_faces_list.extend(faces.clone() for _ in range(N)) + + tex = None + if self.textures is not None: + tex = self.textures.extend(N) + return Meshes(verts=new_verts_list, faces=new_faces_list, textures=tex) diff --git a/pytorch3d/structures/textures.py b/pytorch3d/structures/textures.py new file mode 100644 index 00000000..5173aff7 --- /dev/null +++ b/pytorch3d/structures/textures.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from typing import List, Union +import torch +import torchvision.transforms as T + +from .utils import list_to_packed, padded_to_list + + +""" +This file has functions for interpolating textures after rasterization. +""" + + +def _pad_texture_maps(images: List[torch.Tensor]) -> torch.Tensor: + """ + Pad all texture images so they have the same height and width. + + Args: + images: list of N tensors of shape (H, W) + + Returns: + tex_maps: Tensor of shape (N, max_H, max_W) + """ + tex_maps = [] + max_H = 0 + max_W = 0 + for im in images: + h, w, _3 = im.shape + if h > max_H: + max_H = h + if w > max_W: + max_W = w + tex_maps.append(im) + max_shape = (max_H, max_W) + + # If all texture images are not the same size then resize to the + # largest size. + resize = T.Compose([T.ToPILImage(), T.Resize(size=max_shape), T.ToTensor()]) + + for i, image in enumerate(tex_maps): + if image.shape != max_shape: + # ToPIL takes and returns a C x H x W tensor + image = resize(image.permute(2, 0, 1)).permute(1, 2, 0) + tex_maps[i] = image + tex_maps = torch.stack(tex_maps, dim=0) # (num_tex_maps, max_H, max_W, 3) + return tex_maps + + +def _extend_tensor(input_tensor: torch.Tensor, N: int) -> torch.Tensor: + """ + Extend a tensor `input_tensor` with ndim > 2, `N` times along the batch + dimension. This is done in the following sequence of steps (where `B` is + the batch dimension): + + .. code-block:: python + + input_tensor (B, ...) + -> add leading empty dimension (1, B, ...) + -> expand (N, B, ...) + -> reshape (N * B, ...) + + Args: + input_tensor: torch.Tensor with ndim > 2 representing a batched input. + N: number of times to extend each element of the batch. + """ + if input_tensor.ndim < 2: + raise ValueError("Input tensor must have ndimensions >= 2.") + B = input_tensor.shape[0] + non_batch_dims = tuple(input_tensor.shape[1:]) + constant_dims = (-1,) * input_tensor.ndim # these dims are not expanded. + return ( + input_tensor.clone()[None, ...] + .expand(N, *constant_dims) + .transpose(0, 1) + .reshape(N * B, *non_batch_dims) + ) + + +class Textures(object): + def __init__( + self, + maps: Union[List, torch.Tensor] = None, + faces_uvs: torch.Tensor = None, + verts_uvs: torch.Tensor = None, + verts_rgb: torch.Tensor = None, + ): + """ + Args: + maps: texture map per mesh. This can either be a list of maps + [(H, W, 3)] or a padded tensor of shape (N, H, W, 3). + faces_uvs: (N, F, 3) tensor giving the index into verts_uvs for each + vertex in the face. Padding value is assumed to be -1. + verts_uvs: (N, V, 2) tensor giving the uv coordinate per vertex. + verts_rgb: (N, V, 3) tensor giving the rgb color per vertex. + """ + if faces_uvs is not None and faces_uvs.ndim != 3: + msg = "Expected faces_uvs to be of shape (N, F, 3); got %r" + raise ValueError(msg % repr(faces_uvs.shape)) + if verts_uvs is not None and verts_uvs.ndim != 3: + msg = "Expected verts_uvs to be of shape (N, V, 2); got %r" + raise ValueError(msg % repr(faces_uvs.shape)) + if verts_rgb is not None and verts_rgb.ndim != 3: + msg = "Expected verts_rgb to be of shape (N, V, 3); got %r" + raise ValueError(msg % verts_rgb.shape) + if maps is not None: + if torch.is_tensor(map) and map.ndim != 4: + msg = "Expected maps to be of shape (N, H, W, 3); got %r" + raise ValueError(msg % repr(maps.shape)) + elif isinstance(maps, list): + maps = _pad_texture_maps(maps) + self._faces_uvs_padded = faces_uvs + self._verts_uvs_padded = verts_uvs + self._verts_rgb_padded = verts_rgb + self._maps_padded = maps + self._num_faces_per_mesh = None + + if self._faces_uvs_padded is not None: + self._num_faces_per_mesh = faces_uvs.gt(-1).all(-1).sum(-1).tolist() + + def clone(self): + other = Textures() + for k in dir(self): + v = getattr(self, k) + if torch.is_tensor(v): + setattr(other, k, v.clone()) + return other + + def to(self, device): + for k in dir(self): + v = getattr(self, k) + if torch.is_tensor(v) and v.device != device: + setattr(self, k, v.to(device)) + return self + + def faces_uvs_padded(self) -> torch.Tensor: + return self._faces_uvs_padded + + def faces_uvs_list(self) -> List[torch.Tensor]: + if self._faces_uvs_padded is not None: + return padded_to_list( + self._faces_uvs_padded, split_size=self._num_faces_per_mesh + ) + + def faces_uvs_packed(self) -> torch.Tensor: + return list_to_packed(self.faces_uvs_list())[0] + + def verts_uvs_padded(self) -> torch.Tensor: + return self._verts_uvs_padded + + def verts_uvs_list(self) -> List[torch.Tensor]: + return padded_to_list(self._verts_uvs_padded) + + def verts_uvs_packed(self) -> torch.Tensor: + return list_to_packed(self.verts_uvs_list())[0] + + def verts_rgb_padded(self) -> torch.Tensor: + return self._verts_rgb_padded + + def verts_rgb_list(self) -> List[torch.Tensor]: + return padded_to_list(self._verts_rgb_padded) + + def verts_rgb_packed(self) -> torch.Tensor: + return list_to_packed(self.verts_rgb_list())[0] + + # Currently only the padded maps are used. + def maps_padded(self) -> torch.Tensor: + return self._maps_padded + + def extend(self, N: int) -> "Textures": + """ + Create new Textures class which contains each input texture N times + + Args: + N: number of new copies of each texture. + + Returns: + new Textures object. + """ + if not isinstance(N, int): + raise ValueError("N must be an integer.") + if N <= 0: + raise ValueError("N must be > 0.") + + if all( + v is not None + for v in [ + self._faces_uvs_padded, + self._verts_uvs_padded, + self._maps_padded, + ] + ): + new_verts_uvs = _extend_tensor(self._verts_uvs_padded, N) + new_faces_uvs = _extend_tensor(self._faces_uvs_padded, N) + new_maps = _extend_tensor(self._maps_padded, N) + return Textures( + verts_uvs=new_verts_uvs, faces_uvs=new_faces_uvs, maps=new_maps + ) + elif self._verts_rgb_padded is not None: + new_verts_rgb = _extend_tensor(self._verts_rgb_padded, N) + return Textures(verts_rgb=new_verts_rgb) + else: + msg = "Either vertex colors or texture maps are required." + raise ValueError(msg) diff --git a/pytorch3d/structures/utils.py b/pytorch3d/structures/utils.py new file mode 100644 index 00000000..7f4cceeb --- /dev/null +++ b/pytorch3d/structures/utils.py @@ -0,0 +1,150 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from typing import List, Union +import torch + + +""" +Util functions containing representation transforms for points/verts/faces. +""" + + +def list_to_padded( + x: List[torch.Tensor], + pad_size: Union[list, tuple, None] = None, + pad_value: float = 0.0, + equisized: bool = False, +) -> torch.Tensor: + r""" + Transforms a list of N tensors each of shape (Mi, Ki) into a single tensor + of shape (N, pad_size(0), pad_size(1)), or (N, max(Mi), max(Ki)) + if pad_size is None. + + Args: + x: list of Tensors + pad_size: list(int) specifying the size of the padded tensor + pad_value: float value to be used to fill the padded tensor + equisized: bool indicating whether the items in x are of equal size + (sometimes this is known and if provided saves computation) + + Returns: + x_padded: tensor consisting of padded input tensors + """ + if equisized: + return torch.stack(x, 0) + + if pad_size is None: + pad_dim0 = max(y.shape[0] for y in x if len(y) > 0) + pad_dim1 = max(y.shape[1] for y in x if len(y) > 0) + else: + if len(pad_size) != 2: + raise ValueError( + "Pad size must contain target size for 1st and 2nd dim" + ) + pad_dim0, pad_dim1 = pad_size + + N = len(x) + x_padded = torch.full( + (N, pad_dim0, pad_dim1), pad_value, dtype=x[0].dtype, device=x[0].device + ) + for i, y in enumerate(x): + if len(y) > 0: + if y.ndim != 2: + raise ValueError("Supports only 2-dimensional tensor items") + x_padded[i, : y.shape[0], : y.shape[1]] = y + return x_padded + + +def padded_to_list( + x: torch.Tensor, split_size: Union[list, tuple, None] = None +): + r""" + Transforms a padded tensor of shape (N, M, K) into a list of N tensors + of shape (Mi, Ki) where (Mi, Ki) is specified in split_size(i), or of shape + (M, K) if split_size is None. + Support only for 3-dimensional input tensor. + + Args: + x: tensor + split_size: the shape of the final tensor to be returned (of length N). + """ + if x.ndim != 3: + raise ValueError("Supports only 3-dimensional input tensors") + x_list = list(x.unbind(0)) + if split_size is None: + return x_list + + N = len(split_size) + if x.shape[0] != N: + raise ValueError( + "Split size must be of same length as inputs first dimension" + ) + + for i in range(N): + if isinstance(split_size[i], int): + x_list[i] = x_list[i][: split_size[i]] + elif len(split_size[i]) == 2: + x_list[i] = x_list[i][: split_size[i][0], : split_size[i][1]] + else: + raise ValueError( + "Support only for 2-dimensional unbinded tensor. \ + Split size for more dimensions provided" + ) + return x_list + + +def list_to_packed(x: List[torch.Tensor]): + r""" + Transforms a list of N tensors each of shape (Mi, K, ...) into a single + tensor of shape (sum(Mi), K, ...). + + Args: + x: list of tensors. + + Returns: + 4-element tuple containing + + - **x_packed**: tensor consisting of packed input tensors along the + 1st dimension. + - **num_items**: tensor of shape N containing Mi for each element in x. + - **item_packed_first_idx**: tensor of shape N indicating the index of + the first item belonging to the same element in the original list. + - **item_packed_to_list_idx**: tensor of shape sum(Mi) containing the + index of the element in the list the item belongs to. + """ + N = len(x) + num_items = torch.zeros(N, dtype=torch.int64, device=x[0].device) + item_packed_first_idx = torch.zeros( + N, dtype=torch.int64, device=x[0].device + ) + item_packed_to_list_idx = [] + cur = 0 + for i, y in enumerate(x): + num = len(y) + num_items[i] = num + item_packed_first_idx[i] = cur + item_packed_to_list_idx.append( + torch.full((num,), i, dtype=torch.int64, device=y.device) + ) + cur += num + + x_packed = torch.cat(x, dim=0) + item_packed_to_list_idx = torch.cat(item_packed_to_list_idx, dim=0) + + return x_packed, num_items, item_packed_first_idx, item_packed_to_list_idx + + +def packed_to_list(x: torch.Tensor, split_size: Union[list, int]): + r""" + Transforms a tensor of shape (sum(Mi), K, L, ...) to N set of tensors of + shape (Mi, K, L, ...) where Mi's are defined in split_size + + Args: + x: tensor + split_size: list or int defining the number of items for each split + + Returns: + x_list: A list of Tensors + """ + return x.split(split_size, dim=0) diff --git a/pytorch3d/transforms/__init__.py b/pytorch3d/transforms/__init__.py new file mode 100644 index 00000000..3080a1bc --- /dev/null +++ b/pytorch3d/transforms/__init__.py @@ -0,0 +1,25 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .rotation_conversions import ( + euler_angles_to_matrix, + matrix_to_euler_angles, + matrix_to_quaternion, + quaternion_apply, + quaternion_invert, + quaternion_multiply, + quaternion_raw_multiply, + quaternion_to_matrix, + random_quaternions, + random_rotation, + random_rotations, + standardize_quaternion, +) +from .so3 import ( + so3_exponential_map, + so3_log_map, + so3_relative_angle, + so3_rotation_angle, +) +from .transform3d import Rotate, RotateAxisAngle, Scale, Transform3d, Translate + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/transforms/rotation_conversions.py b/pytorch3d/transforms/rotation_conversions.py new file mode 100644 index 00000000..c8b4b3a6 --- /dev/null +++ b/pytorch3d/transforms/rotation_conversions.py @@ -0,0 +1,374 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import functools +import torch + + +def quaternion_to_matrix(quaternions): + """ + Convert rotations given as quaternions to rotation matrices. + + Args: + quaternions: quaternions with real part first, + as tensor of shape (..., 4). + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + r, i, j, k = torch.unbind(quaternions, -1) + two_s = 2.0 / (quaternions * quaternions).sum(-1) + + o = torch.stack( + ( + 1 - two_s * (j * j + k * k), + two_s * (i * j - k * r), + two_s * (i * k + j * r), + two_s * (i * j + k * r), + 1 - two_s * (i * i + k * k), + two_s * (j * k - i * r), + two_s * (i * k - j * r), + two_s * (j * k + i * r), + 1 - two_s * (i * i + j * j), + ), + -1, + ) + return o.reshape(quaternions.shape[:-1] + (3, 3)) + + +def _copysign(a, b): + """ + Return a tensor where each element has the absolute value taken from the, + corresponding element of a, with sign taken from the corresponding + element of b. This is like the standard copysign floating-point operation, + but is not careful about negative 0 and NaN. + + Args: + a: source tensor. + b: tensor whose signs will be used, of the same shape as a. + + Returns: + Tensor of the same shape as a with the signs of b. + """ + signs_differ = (a < 0) != (b < 0) + return torch.where(signs_differ, -a, a) + + +def matrix_to_quaternion(matrix): + """ + Convert rotations given as rotation matrices to quaternions. + + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + + Returns: + quaternions with real part first, as tensor of shape (..., 4). + """ + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape f{matrix.shape}.") + zero = matrix.new_zeros((1,)) + m00 = matrix[..., 0, 0] + m11 = matrix[..., 1, 1] + m22 = matrix[..., 2, 2] + o0 = 0.5 * torch.sqrt(torch.max(zero, 1 + m00 + m11 + m22)) + x = 0.5 * torch.sqrt(torch.max(zero, 1 + m00 - m11 - m22)) + y = 0.5 * torch.sqrt(torch.max(zero, 1 - m00 + m11 - m22)) + z = 0.5 * torch.sqrt(torch.max(zero, 1 - m00 - m11 + m22)) + o1 = _copysign(x, matrix[..., 2, 1] - matrix[..., 1, 2]) + o2 = _copysign(y, matrix[..., 0, 2] - matrix[..., 2, 0]) + o3 = _copysign(z, matrix[..., 1, 0] - matrix[..., 0, 1]) + return torch.stack((o0, o1, o2, o3), -1) + + +def _primary_matrix(axis: str, angle): + """ + Return the rotation matrices for one of the rotations about an axis + of which Euler angles describe, for each value of the angle given. + + Args: + axis: Axis label "X" or "Y or "Z". + angle: any shape tensor of Euler angles in radians + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + cos = torch.cos(angle) + sin = torch.sin(angle) + one = torch.ones_like(angle) + zero = torch.zeros_like(angle) + if axis == "X": + o = (one, zero, zero, zero, cos, -sin, zero, sin, cos) + if axis == "Y": + o = (cos, zero, sin, zero, one, zero, -sin, zero, cos) + if axis == "Z": + o = (cos, -sin, zero, sin, cos, zero, zero, zero, one) + return torch.stack(o, -1).reshape(angle.shape + (3, 3)) + + +def euler_angles_to_matrix(euler_angles, convention: str): + """ + Convert rotations given as Euler angles in radians to rotation matrices. + + Args: + euler_angles: Euler angles in radians as tensor of shape (..., 3). + convention: Convention string of three uppercase letters from + {"X", "Y", and "Z"}. + + Returns: + Rotation matrices as tensor of shape (..., 3, 3). + """ + if euler_angles.dim() == 0 or euler_angles.shape[-1] != 3: + raise ValueError("Invalid input euler angles.") + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + matrices = map(_primary_matrix, convention, torch.unbind(euler_angles, -1)) + return functools.reduce(torch.matmul, matrices) + + +def _angle_from_tan( + axis: str, other_axis: str, data, horizontal: bool, tait_bryan: bool +): + """ + Extract the first or third Euler angle from the two members of + the matrix which are positive constant times its sine and cosine. + + Args: + axis: Axis label "X" or "Y or "Z" for the angle we are finding. + other_axis: Axis label "X" or "Y or "Z" for the middle axis in the + convention. + data: Rotation matrices as tensor of shape (..., 3, 3). + horizontal: Whether we are looking for the angle for the third axis, + which means the relevant entries are in the same row of the + rotation matrix. If not, they are in the same column. + tait_bryan: Whether the first and third axes in the convention differ. + + Returns: + Euler Angles in radians for each matrix in data as a tensor + of shape (...). + """ + + i1, i2 = {"X": (2, 1), "Y": (0, 2), "Z": (1, 0)}[axis] + if horizontal: + i2, i1 = i1, i2 + even = (axis + other_axis) in ["XY", "YZ", "ZX"] + if horizontal == even: + return torch.atan2(data[..., i1], data[..., i2]) + if tait_bryan: + return torch.atan2(-data[..., i2], data[..., i1]) + return torch.atan2(data[..., i2], -data[..., i1]) + + +def _index_from_letter(letter: str): + if letter == "X": + return 0 + if letter == "Y": + return 1 + if letter == "Z": + return 2 + + +def matrix_to_euler_angles(matrix, convention: str): + """ + Convert rotations given as rotation matrices to Euler angles in radians. + + Args: + matrix: Rotation matrices as tensor of shape (..., 3, 3). + convention: Convention string of three uppercase letters. + + Returns: + Euler angles in radians as tensor of shape (..., 3). + """ + if len(convention) != 3: + raise ValueError("Convention must have 3 letters.") + if convention[1] in (convention[0], convention[2]): + raise ValueError(f"Invalid convention {convention}.") + for letter in convention: + if letter not in ("X", "Y", "Z"): + raise ValueError(f"Invalid letter {letter} in convention string.") + if matrix.size(-1) != 3 or matrix.size(-2) != 3: + raise ValueError(f"Invalid rotation matrix shape f{matrix.shape}.") + i0 = _index_from_letter(convention[0]) + i2 = _index_from_letter(convention[2]) + tait_bryan = i0 != i2 + if tait_bryan: + central_angle = torch.asin( + matrix[..., i0, i2] * (-1.0 if i0 - i2 in [-1, 2] else 1.0) + ) + else: + central_angle = torch.acos(matrix[..., i0, i0]) + + o = ( + _angle_from_tan( + convention[0], convention[1], matrix[..., i2], False, tait_bryan + ), + central_angle, + _angle_from_tan( + convention[2], convention[1], matrix[..., i0, :], True, tait_bryan + ), + ) + return torch.stack(o, -1) + + +def random_quaternions( + n: int, dtype: torch.dtype = None, device=None, requires_grad=False +): + """ + Generate random quaternions representing rotations, + i.e. versors with nonnegative real part. + + Args: + n: Number to return. + dtype: Type to return. + device: Desired device of returned tensor. Default: + uses the current device for the default tensor type. + requires_grad: Whether the resulting tensor should have the gradient + flag set. + + Returns: + Quaternions as tensor of shape (N, 4). + """ + o = torch.randn( + (n, 4), dtype=dtype, device=device, requires_grad=requires_grad + ) + s = (o * o).sum(1) + o = o / _copysign(torch.sqrt(s), o[:, 0])[:, None] + return o + + +def random_rotations( + n: int, dtype: torch.dtype = None, device=None, requires_grad=False +): + """ + Generate random rotations as 3x3 rotation matrices. + + Args: + n: Number to return. + dtype: Type to return. + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type. + requires_grad: Whether the resulting tensor should have the gradient + flag set. + + Returns: + Rotation matrices as tensor of shape (n, 3, 3). + """ + quaternions = random_quaternions( + n, dtype=dtype, device=device, requires_grad=requires_grad + ) + return quaternion_to_matrix(quaternions) + + +def random_rotation( + dtype: torch.dtype = None, device=None, requires_grad=False +): + """ + Generate a single random 3x3 rotation matrix. + + Args: + dtype: Type to return + device: Device of returned tensor. Default: if None, + uses the current device for the default tensor type + requires_grad: Whether the resulting tensor should have the gradient + flag set + + Returns: + Rotation matrix as tensor of shape (3, 3). + """ + return random_rotations(1, dtype, device, requires_grad)[0] + + +def standardize_quaternion(quaternions): + """ + Convert a unit quaternion to a standard form: one in which the real + part is non negative. + + Args: + quaternions: Quaternions with real part first, + as tensor of shape (..., 4). + + Returns: + Standardized quaternions as tensor of shape (..., 4). + """ + return torch.where(quaternions[..., 0:1] < 0, -quaternions, quaternions) + + +def quaternion_raw_multiply(a, b): + """ + Multiply two quaternions. + Usual torch rules for broadcasting apply. + + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + + Returns: + The product of a and b, a tensor of quaternions shape (..., 4). + """ + aw, ax, ay, az = torch.unbind(a, -1) + bw, bx, by, bz = torch.unbind(b, -1) + ow = aw * bw - ax * bx - ay * by - az * bz + ox = aw * bx + ax * bw + ay * bz - az * by + oy = aw * by - ax * bz + ay * bw + az * bx + oz = aw * bz + ax * by - ay * bx + az * bw + return torch.stack((ow, ox, oy, oz), -1) + + +def quaternion_multiply(a, b): + """ + Multiply two quaternions representing rotations, returning the quaternion + representing their composition, i.e. the versorΒ with nonnegative real part. + Usual torch rules for broadcasting apply. + + Args: + a: Quaternions as tensor of shape (..., 4), real part first. + b: Quaternions as tensor of shape (..., 4), real part first. + + Returns: + The product of a and b, a tensor of quaternions of shape (..., 4). + """ + ab = quaternion_raw_multiply(a, b) + return standardize_quaternion(ab) + + +def quaternion_invert(quaternion): + """ + Given a quaternion representing rotation, get the quaternion representing + its inverse. + + Args: + quaternion: Quaternions as tensor of shape (..., 4), with real part + first, which must be versors (unit quaternions). + + Returns: + The inverse, a tensor of quaternions of shape (..., 4). + """ + + return quaternion * quaternion.new_tensor([1, -1, -1, -1]) + + +def quaternion_apply(quaternion, point): + """ + Apply the rotation given by a quaternion to a 3D point. + Usual torch rules for broadcasting apply. + + Args: + quaternion: Tensor of quaternions, real part first, of shape (..., 4). + point: Tensor of 3D points of shape (..., 3). + + Returns: + Tensor of rotated points of shape (..., 3). + """ + if point.size(-1) != 3: + raise ValueError(f"Points are not in 3D, f{point.shape}.") + real_parts = point.new_zeros(point.shape[:-1] + (1,)) + point_as_quaternion = torch.cat((real_parts, point), -1) + out = quaternion_raw_multiply( + quaternion_raw_multiply(quaternion, point_as_quaternion), + quaternion_invert(quaternion), + ) + return out[..., 1:] diff --git a/pytorch3d/transforms/so3.py b/pytorch3d/transforms/so3.py new file mode 100644 index 00000000..6a6dbf9a --- /dev/null +++ b/pytorch3d/transforms/so3.py @@ -0,0 +1,236 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch + +HAT_INV_SKEW_SYMMETRIC_TOL = 1e-5 + + +def so3_relative_angle(R1, R2, cos_angle: bool = False): + """ + Calculates the relative angle (in radians) between pairs of + rotation matrices `R1` and `R2` with `angle = acos(0.5 * Trace(R1 R2^T)-1)` + + .. note:: + This corresponds to a geodesic distance on the 3D manifold of rotation + matrices. + + Args: + R1: Batch of rotation matrices of shape `(minibatch, 3, 3)`. + R2: Batch of rotation matrices of shape `(minibatch, 3, 3)`. + cos_angle: If==True return cosine of the relative angle rather than + the angle itself. This can avoid the unstable + calculation of `acos`. + + Returns: + Corresponding rotation angles of shape `(minibatch,)`. + If `cos_angle==True`, returns the cosine of the angles. + + Raises: + ValueError if `R1` or `R2` is of incorrect shape. + ValueError if `R1` or `R2` has an unexpected trace. + """ + R12 = torch.bmm(R1, R2.permute(0, 2, 1)) + return so3_rotation_angle(R12, cos_angle=cos_angle) + + +def so3_rotation_angle(R, eps: float = 1e-4, cos_angle: bool = False): + """ + Calculates angles (in radians) of a batch of rotation matrices `R` with + `angle = acos(0.5 * (Trace(R)-1))`. The trace of the + input matrices is checked to be in the valid range `[-1-eps,3+eps]`. + The `eps` argument is a small constant that allows for small errors + caused by limited machine precision. + + Args: + R: Batch of rotation matrices of shape `(minibatch, 3, 3)`. + eps: Tolerance for the valid trace check. + cos_angle: If==True return cosine of the rotation angles rather than + the angle itself. This can avoid the unstable + calculation of `acos`. + + Returns: + Corresponding rotation angles of shape `(minibatch,)`. + If `cos_angle==True`, returns the cosine of the angles. + + Raises: + ValueError if `R` is of incorrect shape. + ValueError if `R` has an unexpected trace. + """ + + N, dim1, dim2 = R.shape + if dim1 != 3 or dim2 != 3: + raise ValueError("Input has to be a batch of 3x3 Tensors.") + + rot_trace = R[:, 0, 0] + R[:, 1, 1] + R[:, 2, 2] + + if ((rot_trace < -1.0 - eps) + (rot_trace > 3.0 + eps)).any(): + raise ValueError( + "A matrix has trace outside valid range [-1-eps,3+eps]." + ) + + # clamp to valid range + rot_trace = torch.clamp(rot_trace, -1.0, 3.0) + + # phi ... rotation angle + phi = 0.5 * (rot_trace - 1.0) + + if cos_angle: + return phi + else: + return phi.acos() + + +def so3_exponential_map(log_rot, eps: float = 0.0001): + """ + Convert a batch of logarithmic representations of rotation matrices `log_rot` + to a batch of 3x3 rotation matrices using Rodrigues formula [1]. + + In the logarithmic representation, each rotation matrix is represented as + a 3-dimensional vector (`log_rot`) who's l2-norm and direction correspond + to the magnitude of the rotation angle and the axis of rotation respectively. + + The conversion has a singularity around `log(R) = 0` + which is handled by clamping controlled with the `eps` argument. + + Args: + log_rot: Batch of vectors of shape `(minibatch , 3)`. + eps: A float constant handling the conversion singularity. + + Returns: + Batch of rotation matrices of shape `(minibatch , 3 , 3)`. + + Raises: + ValueError if `log_rot` is of incorrect shape. + + [1] https://en.wikipedia.org/wiki/Rodrigues%27_rotation_formula + """ + + _, dim = log_rot.shape + if dim != 3: + raise ValueError("Input tensor shape has to be Nx3.") + + nrms = (log_rot * log_rot).sum(1) + # phis ... rotation angles + rot_angles = torch.clamp(nrms, eps).sqrt() + rot_angles_inv = 1.0 / rot_angles + fac1 = rot_angles_inv * rot_angles.sin() + fac2 = rot_angles_inv * rot_angles_inv * (1.0 - rot_angles.cos()) + skews = hat(log_rot) + + R = ( + fac1[:, None, None] * skews + + fac2[:, None, None] * torch.bmm(skews, skews) + + torch.eye(3, dtype=log_rot.dtype, device=log_rot.device)[None] + ) + + return R + + +def so3_log_map(R, eps: float = 0.0001): + """ + Convert a batch of 3x3 rotation matrices `R` + to a batch of 3-dimensional matrix logarithms of rotation matrices + The conversion has a singularity around `(R=I)` which is handled + by clamping controlled with the `eps` argument. + + Args: + R: batch of rotation matrices of shape `(minibatch, 3, 3)`. + eps: A float constant handling the conversion singularity. + + Returns: + Batch of logarithms of input rotation matrices + of shape `(minibatch, 3)`. + + Raises: + ValueError if `R` is of incorrect shape. + ValueError if `R` has an unexpected trace. + """ + + N, dim1, dim2 = R.shape + if dim1 != 3 or dim2 != 3: + raise ValueError("Input has to be a batch of 3x3 Tensors.") + + phi = so3_rotation_angle(R) + + phi_valid = torch.clamp(phi.abs(), eps) * phi.sign() + + log_rot_hat = (phi_valid / (2.0 * phi_valid.sin()))[:, None, None] * ( + R - R.permute(0, 2, 1) + ) + log_rot = hat_inv(log_rot_hat) + + return log_rot + + +def hat_inv(h): + """ + Compute the inverse Hat operator [1] of a batch of 3x3 matrices. + + Args: + h: Batch of skew-symmetric matrices of shape `(minibatch, 3, 3)`. + + Returns: + Batch of 3d vectors of shape `(minibatch, 3, 3)`. + + Raises: + ValueError if `h` is of incorrect shape. + ValueError if `h` not skew-symmetric. + + [1] https://en.wikipedia.org/wiki/Hat_operator + """ + + N, dim1, dim2 = h.shape + if dim1 != 3 or dim2 != 3: + raise ValueError("Input has to be a batch of 3x3 Tensors.") + + ss_diff = (h + h.permute(0, 2, 1)).abs().max() + if float(ss_diff) > HAT_INV_SKEW_SYMMETRIC_TOL: + raise ValueError("One of input matrices not skew-symmetric.") + + x = h[:, 2, 1] + y = h[:, 0, 2] + z = h[:, 1, 0] + + v = torch.stack((x, y, z), dim=1) + + return v + + +def hat(v): + """ + Compute the Hat operator [1] of a batch of 3D vectors. + + Args: + v: Batch of vectors of shape `(minibatch , 3)`. + + Returns: + Batch of skew-symmetric matrices of shape + `(minibatch, 3 , 3)` where each matrix is of the form: + `[ 0 -v_z v_y ] + [ v_z 0 -v_x ] + [ -v_y v_x 0 ]` + + Raises: + ValueError if `v` is of incorrect shape. + + [1] https://en.wikipedia.org/wiki/Hat_operator + """ + + N, dim = v.shape + if dim != 3: + raise ValueError("Input vectors have to be 3-dimensional.") + + h = v.new_zeros(N, 3, 3) + + x, y, z = v.unbind(1) + + h[:, 0, 1] = -z + h[:, 0, 2] = y + h[:, 1, 0] = z + h[:, 1, 2] = -x + h[:, 2, 0] = -y + h[:, 2, 1] = x + + return h diff --git a/pytorch3d/transforms/transform3d.py b/pytorch3d/transforms/transform3d.py new file mode 100644 index 00000000..5c59859b --- /dev/null +++ b/pytorch3d/transforms/transform3d.py @@ -0,0 +1,677 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import math +import torch + + +class Transform3d: + """ + A Transform3d object encapsulates a batch of N 3D transformations, and knows + how to transform points and normal vectors. Suppose that t is a Transform3d; + then we can do the following: + + .. code-block:: python + + N = len(t) + points = torch.randn(N, P, 3) + normals = torch.randn(N, P, 3) + points_transformed = t.transform_points(points) # => (N, P, 3) + normals_transformed = t.transform_points(normals) # => (N, P, 3) + + + BROADCASTING + Transform3d objects supports broadcasting. Suppose that t1 and tN are + Transform3D objects with len(t1) == 1 and len(tN) == N respectively. Then we + can broadcast transforms like this: + + .. code-block:: python + + t1.transform_points(torch.randn(P, 3)) # => (P, 3) + t1.transform_points(torch.randn(1, P, 3)) # => (1, P, 3) + t1.transform_points(torch.randn(M, P, 3)) # => (M, P, 3) + tN.transform_points(torch.randn(P, 3)) # => (N, P, 3) + tN.transform_points(torch.randn(1, P, 3)) # => (N, P, 3) + + + COMBINING TRANSFORMS + Transform3d objects can be combined in two ways: composing and stacking. + Composing is function composition. Given Transform3d objects t1, t2, t3, + the following all compute the same thing: + + .. code-block:: python + + y1 = t3.transform_points(t2.transform_points(t2.transform_points(x))) + y2 = t1.compose(t2).compose(t3).transform_points() + y3 = t1.compose(t2, t3).transform_points() + + + Composing transforms should broadcast. + + .. code-block:: python + + if len(t1) == 1 and len(t2) == N, then len(t1.compose(t2)) == N. + + We can also stack a sequence of Transform3d objects, which represents + composition along the batch dimension; then the following should compute the + same thing. + + .. code-block:: python + + N, M = len(tN), len(tM) + xN = torch.randn(N, P, 3) + xM = torch.randn(M, P, 3) + y1 = torch.cat([tN.transform_points(xN), tM.transform_points(xM)], dim=0) + y2 = tN.stack(tM).transform_points(torch.cat([xN, xM], dim=0)) + + BUILDING TRANSFORMS + We provide convenience methods for easily building Transform3d objects + as compositions of basic transforms. + + .. code-block:: python + + # Scale by 0.5, then translate by (1, 2, 3) + t1 = Transform3d().scale(0.5).translate(1, 2, 3) + + # Scale each axis by a different amount, then translate, then scale + t2 = Transform3d().scale(1, 3, 3).translate(2, 3, 1).scale(2.0) + + t3 = t1.compose(t2) + tN = t1.stack(t3, t3) + + + BACKPROP THROUGH TRANSFORMS + When building transforms, we can also parameterize them by Torch tensors; + in this case we can backprop through the construction and application of + Transform objects, so they could be learned via gradient descent or + predicted by a neural network. + + .. code-block:: python + + s1_params = torch.randn(N, requires_grad=True) + t_params = torch.randn(N, 3, requires_grad=True) + s2_params = torch.randn(N, 3, requires_grad=True) + + t = Transform3d().scale(s1_params).translate(t_params).scale(s2_params) + x = torch.randn(N, 3) + y = t.transform_points(x) + loss = compute_loss(y) + loss.backward() + + with torch.no_grad(): + s1_params -= lr * s1_params.grad + t_params -= lr * t_params.grad + s2_params -= lr * s2_params.grad + """ + + def __init__(self, dtype=torch.float32, device="cpu"): + """ + This class assumes a row major ordering for all matrices. + """ + self._matrix = torch.eye(4, dtype=dtype, device=device).view(1, 4, 4) + self._transforms = [] # store transforms to compose + self._lu = None + self.device = device + + def __len__(self): + return self.get_matrix().shape[0] + + def compose(self, *others): + """ + Return a new Transform3d with the tranforms to compose stored as + an internal list. + + Args: + *others: Any number of Transform3d objects + + Returns: + A new Transform3d with the stored transforms + """ + out = Transform3d(device=self.device) + out._matrix = self._matrix.clone() + for other in others: + if not isinstance(other, Transform3d): + msg = "Only possible to compose Transform3d objects; got %s" + raise ValueError(msg % type(other)) + out._transforms = self._transforms + list(others) + return out + + def get_matrix(self): + """ + Return a matrix which is the result of composing this transform + with others stored in self.transforms. Where necessary transforms + are broadcast against each other. + For example, if self.transforms contains transforms t1, t2, and t3, and + given a set of points x, the following should be true: + + .. code-block:: python + + y1 = t1.compose(t2, t3).transform(x) + y2 = t3.transform(t2.transform(t1.transform(x))) + y1.get_matrix() == y2.get_matrix() + + Returns: + A transformation matrix representing the composed inputs. + """ + composed_matrix = self._matrix.clone() + if len(self._transforms) > 0: + for other in self._transforms: + other_matrix = other.get_matrix() + composed_matrix = _broadcast_bmm(composed_matrix, other_matrix) + return composed_matrix + + def _get_matrix_inverse(self): + """ + Return the inverse of self._matrix. + """ + return torch.inverse(self._matrix) + + def inverse(self, invert_composed: bool = False): + """ + Returns a new Transform3D object that represents an inverse of the + current transformation. + + Args: + invert_composed: + - True: First compose the list of stored transformations + and then apply inverse to the result. This is + potentially slower for classes of transformations + with inverses that can be computed efficiently + (e.g. rotations and translations). + - False: Invert the individual stored transformations + independently without composing them. + + Returns: + A new Transform3D object contaning the inverse of the original + transformation. + """ + + tinv = Transform3d(device=self.device) + + if invert_composed: + # first compose then invert + tinv._matrix = torch.inverse(self.get_matrix()) + else: + # self._get_matrix_inverse() implements efficient inverse + # of self._matrix + i_matrix = self._get_matrix_inverse() + + # 2 cases: + if len(self._transforms) > 0: + # a) Either we have a non-empty list of transforms: + # Here we take self._matrix and append its inverse at the + # end of the reverted _transforms list. After composing + # the transformations with get_matrix(), this correctly + # right-multiplies by the inverse of self._matrix + # at the end of the composition. + tinv._transforms = [ + t.inverse() for t in reversed(self._transforms) + ] + last = Transform3d(device=self.device) + last._matrix = i_matrix + tinv._transforms.append(last) + else: + # b) Or there are no stored transformations + # we just set inverted matrix + tinv._matrix = i_matrix + + return tinv + + def stack(self, *others): + transforms = [self] + list(others) + matrix = torch.cat([t._matrix for t in transforms], dim=0) + out = Transform3d() + out._matrix = matrix + return out + + def transform_points(self, points, eps: float = None): + """ + Use this transform to transform a set of 3D points. Assumes row major + ordering of the input points. + + Args: + points: Tensor of shape (P, 3) or (N, P, 3) + eps: If eps!=None, the argument is used to clamp the + last coordinate before peforming the final division. + The clamping corresponds to: + last_coord := (last_coord.sign() + (last_coord==0)) * + torch.clamp(last_coord.abs(), eps), + i.e. the last coordinates that are exactly 0 will + be clamped to +eps. + + Returns: + points_out: points of shape (N, P, 3) or (P, 3) depending + on the dimensions of the transform + """ + points_batch = points.clone() + if points_batch.dim() == 2: + points_batch = points_batch[None] # (P, 3) -> (1, P, 3) + if points_batch.dim() != 3: + msg = "Expected points to have dim = 2 or dim = 3: got shape %r" + raise ValueError(msg % points.shape) + + N, P, _3 = points_batch.shape + ones = torch.ones(N, P, 1, dtype=points.dtype, device=points.device) + points_batch = torch.cat([points_batch, ones], dim=2) + + composed_matrix = self.get_matrix() + points_out = _broadcast_bmm(points_batch, composed_matrix) + denom = points_out[..., 3:] # denominator + if eps is not None: + denom_sign = denom.sign() + (denom == 0.0).type_as(denom) + denom = denom_sign * torch.clamp(denom.abs(), eps) + points_out = points_out[..., :3] / denom + + # When transform is (1, 4, 4) and points is (P, 3) return + # points_out of shape (P, 3) + if points_out.shape[0] == 1 and points.dim() == 2: + points_out = points_out.reshape(points.shape) + + return points_out + + def transform_normals(self, normals): + """ + Use this transform to transform a set of normal vectors. + + Args: + normals: Tensor of shape (P, 3) or (N, P, 3) + + Returns: + normals_out: Tensor of shape (P, 3) or (N, P, 3) depending + on the dimensions of the transform + """ + if normals.dim() not in [2, 3]: + msg = "Expected normals to have dim = 2 or dim = 3: got shape %r" + raise ValueError(msg % normals.shape) + composed_matrix = self.get_matrix() + + # TODO: inverse is bad! Solve a linear system instead + mat = composed_matrix[:, :3, :3] + normals_out = _broadcast_bmm(normals, mat.transpose(1, 2).inverse()) + + # This doesn't pass unit tests. TODO investigate further + # if self._lu is None: + # self._lu = self._matrix[:, :3, :3].transpose(1, 2).lu() + # normals_out = normals.lu_solve(*self._lu) + + # When transform is (1, 4, 4) and normals is (P, 3) return + # normals_out of shape (P, 3) + if normals_out.shape[0] == 1 and normals.dim() == 2: + normals_out = normals_out.reshape(normals.shape) + + return normals_out + + def translate(self, *args, **kwargs): + return self.compose(Translate(device=self.device, *args, **kwargs)) + + def scale(self, *args, **kwargs): + return self.compose(Scale(device=self.device, *args, **kwargs)) + + def rotate_axis_angle(self, *args, **kwargs): + return self.compose( + RotateAxisAngle(device=self.device, *args, **kwargs) + ) + + def clone(self): + """ + Deep copy of Transforms object. All internal tensors are cloned + individually. + + Returns: + new Transforms object. + """ + other = Transform3d(device=self.device) + if self._lu is not None: + other._lu = [l.clone() for l in self._lu] + other._matrix = self._matrix.clone() + other._transforms = [t.clone() for t in self._transforms] + return other + + def to(self, device, copy: bool = False, dtype=None): + """ + Match functionality of torch.Tensor.to() + If copy = True or the self Tensor is on a different device, the + returned tensor is a copy of self with the desired torch.device. + If copy = False and the self Tensor already has the correct torch.device, + then self is returned. + + Args: + device: Device id for the new tensor. + copy: Boolean indicator whether or not to clone self. Default False. + dtype: If not None, casts the internal tensor variables + to a given torch.dtype. + + Returns: + Transform3d object. + """ + if not copy and self.device == device: + return self + other = self.clone() + if self.device != device: + other.device = device + other._matrix = self._matrix.to(device=device, dtype=dtype) + for t in other._transforms: + t.to(device, copy=copy, dtype=dtype) + return other + + def cpu(self): + return self.to(torch.device("cpu")) + + def cuda(self): + return self.to(torch.device("cuda")) + + +class Translate(Transform3d): + def __init__( + self, x, y=None, z=None, dtype=torch.float32, device: str = "cpu" + ): + """ + Create a new Transform3d representing 3D translations. + + Option I: Translate(xyz, dtype=torch.float32, device='cpu') + xyz should be a tensor of shape (N, 3) + + Option II: Translate(x, y, z, dtype=torch.float32, device='cpu') + Here x, y, and z will be broadcast against each other and + concatenated to form the translation. Each can be: + - A python scalar + - A torch scalar + - A 1D torch tensor + """ + super().__init__(device=device) + xyz = _handle_input(x, y, z, dtype, device, "Translate") + N = xyz.shape[0] + + mat = torch.eye(4, dtype=dtype, device=device) + mat = mat.view(1, 4, 4).repeat(N, 1, 1) + mat[:, 3, :3] = xyz + self._matrix = mat + + def _get_matrix_inverse(self): + """ + Return the inverse of self._matrix. + """ + inv_mask = self._matrix.new_ones([1, 4, 4]) + inv_mask[0, 3, :3] = -1.0 + i_matrix = self._matrix * inv_mask + return i_matrix + + +class Scale(Transform3d): + def __init__( + self, x, y=None, z=None, dtype=torch.float32, device: str = "cpu" + ): + """ + A Transform3d representing a scaling operation, with different scale + factors along each coordinate axis. + + Option I: Scale(s, dtype=torch.float32, device='cpu') + s can be one of + - Python scalar or torch scalar: Single uniform scale + - 1D torch tensor of shape (N,): A batch of uniform scale + - 2D torch tensor of shape (N, 3): Scale differently along each axis + + Option II: Scale(x, y, z, dtype=torch.float32, device='cpu') + Each of x, y, and z can be one of + - python scalar + - torch scalar + - 1D torch tensor + """ + super().__init__(device=device) + xyz = _handle_input( + x, y, z, dtype, device, "scale", allow_singleton=True + ) + N = xyz.shape[0] + + # TODO: Can we do this all in one go somehow? + mat = torch.eye(4, dtype=dtype, device=device) + mat = mat.view(1, 4, 4).repeat(N, 1, 1) + mat[:, 0, 0] = xyz[:, 0] + mat[:, 1, 1] = xyz[:, 1] + mat[:, 2, 2] = xyz[:, 2] + self._matrix = mat + + def _get_matrix_inverse(self): + """ + Return the inverse of self._matrix. + """ + xyz = torch.stack([self._matrix[:, i, i] for i in range(4)], dim=1) + ixyz = 1.0 / xyz + imat = torch.diag_embed(ixyz, dim1=1, dim2=2) + return imat + + +class Rotate(Transform3d): + def __init__( + self, + R, + dtype=torch.float32, + device: str = "cpu", + orthogonal_tol: float = 1e-5, + ): + """ + Create a new Transform3d representing 3D rotation using a rotation + matrix as the input. + + Args: + R: a tensor of shape (3, 3) or (N, 3, 3) + orthogonal_tol: tolerance for the test of the orthogonality of R + + """ + super().__init__(device=device) + if R.dim() == 2: + R = R[None] + if R.shape[-2:] != (3, 3): + msg = "R must have shape (3, 3) or (N, 3, 3); got %s" + raise ValueError(msg % repr(R.shape)) + R = R.to(dtype=dtype).to(device=device) + _check_valid_rotation_matrix(R, tol=orthogonal_tol) + N = R.shape[0] + mat = torch.eye(4, dtype=dtype, device=device) + mat = mat.view(1, 4, 4).repeat(N, 1, 1) + mat[:, :3, :3] = R + self._matrix = mat + + def _get_matrix_inverse(self): + """ + Return the inverse of self._matrix. + """ + return self._matrix.permute(0, 2, 1).contiguous() + + +class RotateAxisAngle(Rotate): + def __init__( + self, + angle, + axis: str = "X", + degrees: bool = True, + dtype=torch.float64, + device: str = "cpu", + ): + """ + Create a new Transform3d representing 3D rotation about an axis + by an angle. + + Args: + angle: + - A torch tensor of shape (N, 1) + - A python scalar + - A torch scalar + axis: + string: one of ["X", "Y", "Z"] indicating the axis about which + to rotate. + NOTE: All batch elements are rotated about the same axis. + """ + axis = axis.upper() + if axis not in ["X", "Y", "Z"]: + msg = "Expected axis to be one of ['X', 'Y', 'Z']; got %s" + raise ValueError(msg % axis) + angle = _handle_angle_input(angle, dtype, device, "RotateAxisAngle") + angle = (angle / 180.0 * math.pi) if degrees else angle + N = angle.shape[0] + + cos = torch.cos(angle) + sin = torch.sin(angle) + one = torch.ones_like(angle) + zero = torch.zeros_like(angle) + + if axis == "X": + R_flat = (one, zero, zero, zero, cos, -sin, zero, sin, cos) + if axis == "Y": + R_flat = (cos, zero, sin, zero, one, zero, -sin, zero, cos) + if axis == "Z": + R_flat = (cos, -sin, zero, sin, cos, zero, zero, zero, one) + + R = torch.stack(R_flat, -1).reshape((N, 3, 3)) + super().__init__(device=device, R=R) + + +def _handle_coord(c, dtype, device): + """ + Helper function for _handle_input. + + Args: + c: Python scalar, torch scalar, or 1D torch tensor + + Returns: + c_vec: 1D torch tensor + """ + if not torch.is_tensor(c): + c = torch.tensor(c, dtype=dtype, device=device) + if c.dim() == 0: + c = c.view(1) + return c + + +def _handle_input( + x, y, z, dtype, device, name: str, allow_singleton: bool = False +): + """ + Helper function to handle parsing logic for building transforms. The output + is always a tensor of shape (N, 3), but there are several types of allowed + input. + + Case I: Single Matrix + In this case x is a tensor of shape (N, 3), and y and z are None. Here just + return x. + + Case II: Vectors and Scalars + In this case each of x, y, and z can be one of the following + - Python scalar + - Torch scalar + - Torch tensor of shape (N, 1) or (1, 1) + In this case x, y and z are broadcast to tensors of shape (N, 1) + and concatenated to a tensor of shape (N, 3) + + Case III: Singleton (only if allow_singleton=True) + In this case y and z are None, and x can be one of the following: + - Python scalar + - Torch scalar + - Torch tensor of shape (N, 1) or (1, 1) + Here x will be duplicated 3 times, and we return a tensor of shape (N, 3) + + Returns: + xyz: Tensor of shape (N, 3) + """ + # If x is actually a tensor of shape (N, 3) then just return it + if torch.is_tensor(x) and x.dim() == 2: + if x.shape[1] != 3: + msg = "Expected tensor of shape (N, 3); got %r (in %s)" + raise ValueError(msg % (x.shape, name)) + if y is not None or z is not None: + msg = "Expected y and z to be None (in %s)" % name + raise ValueError(msg) + return x + + if allow_singleton and y is None and z is None: + y = x + z = x + + # Convert all to 1D tensors + xyz = [_handle_coord(c, dtype, device) for c in [x, y, z]] + + # Broadcast and concatenate + sizes = [c.shape[0] for c in xyz] + N = max(sizes) + for c in xyz: + if c.shape[0] != 1 and c.shape[0] != N: + msg = "Got non-broadcastable sizes %r (in %s)" % (sizes, name) + raise ValueError(msg) + xyz = [c.expand(N) for c in xyz] + xyz = torch.stack(xyz, dim=1) + return xyz + + +def _handle_angle_input(x, dtype, device: str, name: str): + """ + Helper function for building a rotation function using angles. + The output is always of shape (N, 1). + + The input can be one of: + - Torch tensor (N, 1) or (N) + - Python scalar + - Torch scalar + """ + # If x is actually a tensor of shape (N, 1) then just return it + if torch.is_tensor(x) and x.dim() == 2: + if x.shape[1] != 1: + msg = "Expected tensor of shape (N, 1); got %r (in %s)" + raise ValueError(msg % (x.shape, name)) + return x + else: + return _handle_coord(x, dtype, device) + + +def _broadcast_bmm(a, b): + """ + Batch multiply two matrices and broadcast if necessary. + + Args: + a: torch tensor of shape (P, K) or (M, P, K) + b: torch tensor of shape (N, K, K) + + Returns: + a and b broadcast multipled. The output batch dimension is max(N, M). + + To broadcast transforms across a batch dimension if M != N then + expect that either M = 1 or N = 1. The tensor with batch dimension 1 is + expanded to have shape N or M. + """ + if a.dim() == 2: + a = a[None] + if len(a) != len(b): + if not ((len(a) == 1) or (len(b) == 1)): + msg = "Expected batch dim for bmm to be equal or 1; got %r, %r" + raise ValueError(msg % (a.shape, b.shape)) + if len(a) == 1: + a = a.expand(len(b), -1, -1) + if len(b) == 1: + b = b.expand(len(a), -1, -1) + return a.bmm(b) + + +def _check_valid_rotation_matrix(R, tol: float = 1e-7): + """ + Determine if R is a valid rotation matrix by checking it satisfies the + following conditions: + + ``RR^T = I and det(R) = 1`` + + Args: + R: an (N, 3, 3) matrix + + Returns: + None + + Prints an warning if R is an invalid rotation matrix. Else return. + """ + N = R.shape[0] + eye = torch.eye(3, dtype=R.dtype, device=R.device) + eye = eye.view(1, 3, 3).expand(N, -1, -1) + orthogonal = torch.allclose(R.bmm(R.transpose(1, 2)), eye, atol=tol) + det_R = torch.det(R) + no_distortion = torch.allclose(det_R, torch.ones_like(det_R)) + if not (orthogonal and no_distortion): + msg = "R is not a valid rotation matrix" + print(msg) + return diff --git a/pytorch3d/utils/__init__.py b/pytorch3d/utils/__init__.py new file mode 100644 index 00000000..c0c156e9 --- /dev/null +++ b/pytorch3d/utils/__init__.py @@ -0,0 +1,5 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from .ico_sphere import ico_sphere + +__all__ = [k for k in globals().keys() if not k.startswith("_")] diff --git a/pytorch3d/utils/ico_sphere.py b/pytorch3d/utils/ico_sphere.py new file mode 100644 index 00000000..c3008fb0 --- /dev/null +++ b/pytorch3d/utils/ico_sphere.py @@ -0,0 +1,81 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch + +from pytorch3d.ops.subdivide_meshes import SubdivideMeshes +from pytorch3d.structures.meshes import Meshes + +# Vertex coordinates for a level 0 ico-sphere. +_ico_verts0 = [ + [-0.5257, 0.8507, 0.0000], + [0.5257, 0.8507, 0.0000], + [-0.5257, -0.8507, 0.0000], + [0.5257, -0.8507, 0.0000], + [0.0000, -0.5257, 0.8507], + [0.0000, 0.5257, 0.8507], + [0.0000, -0.5257, -0.8507], + [0.0000, 0.5257, -0.8507], + [0.8507, 0.0000, -0.5257], + [0.8507, 0.0000, 0.5257], + [-0.8507, 0.0000, -0.5257], + [-0.8507, 0.0000, 0.5257], +] + + +# Faces for level 0 ico-sphere +_ico_faces0 = [ + [0, 11, 5], + [0, 5, 1], + [0, 1, 7], + [0, 7, 10], + [0, 10, 11], + [1, 5, 9], + [5, 11, 4], + [11, 10, 2], + [10, 7, 6], + [7, 1, 8], + [3, 9, 4], + [3, 4, 2], + [3, 2, 6], + [3, 6, 8], + [3, 8, 9], + [4, 9, 5], + [2, 4, 11], + [6, 2, 10], + [8, 6, 7], + [9, 8, 1], +] + + +def ico_sphere(level: int = 0, device=None): + """ + Create verts and faces for a unit ico-sphere, with all faces oriented + consistently. + + Args: + level: integer specifying the number of iterations for subdivision + of the mesh faces. Each additional level will result in four new + faces per face. + device: A torch.device object on which the outputs will be allocated. + + Returns: + Meshes object with verts and faces. + """ + if device is None: + device = torch.device("cpu") + if level < 0: + raise ValueError("level must be >= 0.") + if level == 0: + verts = torch.tensor(_ico_verts0, dtype=torch.float32, device=device) + faces = torch.tensor(_ico_faces0, dtype=torch.int64, device=device) + + else: + mesh = ico_sphere(level - 1, device) + subdivide = SubdivideMeshes() + mesh = subdivide(mesh) + verts = mesh.verts_list()[0] + verts /= verts.norm(p=2, dim=1, keepdim=True) + faces = mesh.faces_list()[0] + return Meshes(verts=[verts], faces=[faces]) diff --git a/setup.cfg b/setup.cfg new file mode 100644 index 00000000..8bbe1356 --- /dev/null +++ b/setup.cfg @@ -0,0 +1,12 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +[isort] +line_length=80 +include_trailing_comma=True +multi_line_output=3 +known_standard_library=numpy,setuptools +known_myself=pytorch3d +known_third_party=fvcore,torch,torchvision,matplotlib,mpl_toolkits,PIL,yaml,jinja2,requests +no_lines_before=STDLIB,THIRDPARTY +sections=FUTURE,STDLIB,THIRDPARTY,myself,FIRSTPARTY,LOCALFOLDER +default_section=FIRSTPARTY diff --git a/setup.py b/setup.py new file mode 100644 index 00000000..ce4af37e --- /dev/null +++ b/setup.py @@ -0,0 +1,74 @@ +#!/usr/bin/env python +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import glob +import os +from setuptools import find_packages, setup +import torch +from torch.utils.cpp_extension import CUDA_HOME, CppExtension, CUDAExtension + + +def get_extensions(): + this_dir = os.path.dirname(os.path.abspath(__file__)) + extensions_dir = os.path.join(this_dir, "pytorch3d", "csrc") + + main_source = os.path.join(extensions_dir, "ext.cpp") + sources = glob.glob(os.path.join(extensions_dir, "**", "*.cpp")) + source_cuda = glob.glob(os.path.join(extensions_dir, "**", "*.cu")) + + sources = [main_source] + sources + + extension = CppExtension + + extra_compile_args = {"cxx": ["-std=c++17"]} + define_macros = [] + + if torch.cuda.is_available() and CUDA_HOME is not None: + extension = CUDAExtension + sources += source_cuda + define_macros += [("WITH_CUDA", None)] + extra_compile_args["nvcc"] = [ + "-DCUDA_HAS_FP16=1", + "-D__CUDA_NO_HALF_OPERATORS__", + "-D__CUDA_NO_HALF_CONVERSIONS__", + "-D__CUDA_NO_HALF2_OPERATORS__", + ] + + # It's better if pytorch can do this by default .. + CC = os.environ.get("CC", None) + if CC is not None: + extra_compile_args["nvcc"].append("-ccbin={}".format(CC)) + + sources = [os.path.join(extensions_dir, s) for s in sources] + + include_dirs = [extensions_dir] + + ext_modules = [ + extension( + "pytorch3d._C", + sources, + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + ] + + return ext_modules + + +setup( + name="pytorch3d", + version="0.1", + author="FAIR", + url="https://github.com/facebookresearch/pytorch3d", + description="PyTorch3d is FAIR's library of reusable components " + "for deep Learning with 3D data.", + packages=find_packages(exclude=("configs", "tests")), + install_requires=["torchvision>=0.4", "fvcore"], + extras_require={ + "all": ["matplotlib", "tqdm>4.29.0", "imageio", "ipywidgets"], + "dev": ["flake8", "isort", "black==19.3b0"], + }, + ext_modules=get_extensions(), + cmdclass={"build_ext": torch.utils.cpp_extension.BuildExtension}, +) diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 00000000..40539064 --- /dev/null +++ b/tests/__init__.py @@ -0,0 +1 @@ +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. diff --git a/tests/bm_chamfer.py b/tests/bm_chamfer.py new file mode 100644 index 00000000..914596a6 --- /dev/null +++ b/tests/bm_chamfer.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import torch +from fvcore.common.benchmark import benchmark + +from test_chamfer import TestChamfer + + +def bm_chamfer() -> None: + kwargs_list_naive = [ + {"batch_size": 1, "P1": 32, "P2": 64, "return_normals": False}, + {"batch_size": 1, "P1": 32, "P2": 64, "return_normals": True}, + {"batch_size": 32, "P1": 32, "P2": 64, "return_normals": False}, + ] + benchmark( + TestChamfer.chamfer_naive_with_init, + "CHAMFER_NAIVE", + kwargs_list_naive, + warmup_iters=1, + ) + + if torch.cuda.is_available(): + kwargs_list = kwargs_list_naive + [ + {"batch_size": 1, "P1": 1000, "P2": 3000, "return_normals": False}, + {"batch_size": 1, "P1": 1000, "P2": 30000, "return_normals": True}, + ] + benchmark( + TestChamfer.chamfer_with_init, + "CHAMFER", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_cubify.py b/tests/bm_cubify.py new file mode 100644 index 00000000..041dabfe --- /dev/null +++ b/tests/bm_cubify.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from fvcore.common.benchmark import benchmark + +from test_cubify import TestCubify + + +def bm_cubify() -> None: + kwargs_list = [ + {"batch_size": 32, "V": 16}, + {"batch_size": 64, "V": 16}, + {"batch_size": 16, "V": 32}, + ] + benchmark( + TestCubify.cubify_with_init, "CUBIFY", kwargs_list, warmup_iters=1 + ) diff --git a/tests/bm_graph_conv.py b/tests/bm_graph_conv.py new file mode 100644 index 00000000..1cc14ada --- /dev/null +++ b/tests/bm_graph_conv.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_graph_conv import TestGraphConv + + +def bm_graph_conv() -> None: + backends = ["cpu"] + if torch.cuda.is_available(): + backends.append("cuda") + + kwargs_list = [] + gconv_dim = [128, 256] + num_meshes = [32, 64] + num_verts = [100] + num_faces = [1000] + directed = [False, True] + test_cases = product( + gconv_dim, num_meshes, num_verts, num_faces, directed, backends + ) + for case in test_cases: + g, n, v, f, d, b = case + kwargs_list.append( + { + "gconv_dim": g, + "num_meshes": n, + "num_verts": v, + "num_faces": f, + "directed": d, + "backend": b, + } + ) + benchmark( + TestGraphConv.graph_conv_forward_backward, + "GRAPH CONV", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_main.py b/tests/bm_main.py new file mode 100644 index 00000000..65c9bfae --- /dev/null +++ b/tests/bm_main.py @@ -0,0 +1,31 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import glob +import importlib +from os.path import basename, dirname, isfile, join, sys + +if __name__ == "__main__": + # pyre-ignore[16] + if len(sys.argv) > 1: + # Parse from flags. + # pyre-ignore[16] + module_names = [n for n in sys.argv if n.startswith("bm_")] + else: + # Get all the benchmark files (starting with "bm_"). + bm_files = glob.glob(join(dirname(__file__), "bm_*.py")) + module_names = [ + basename(f)[:-3] + for f in bm_files + if isfile(f) and not f.endswith("bm_main.py") + ] + + for module_name in module_names: + module = importlib.import_module(module_name) + for attr in dir(module): + # Run all the functions with names "bm_*" in the module. + if attr.startswith("bm_"): + print( + "Running benchmarks for " + module_name + "/" + attr + "..." + ) + getattr(module, attr)() diff --git a/tests/bm_mesh_edge_loss.py b/tests/bm_mesh_edge_loss.py new file mode 100644 index 00000000..73aa5d9e --- /dev/null +++ b/tests/bm_mesh_edge_loss.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +from fvcore.common.benchmark import benchmark + +from test_mesh_edge_loss import TestMeshEdgeLoss + + +def bm_mesh_edge_loss() -> None: + kwargs_list = [] + num_meshes = [1, 16, 32] + max_v = [100, 10000] + max_f = [300, 30000] + test_cases = product(num_meshes, max_v, max_f) + for case in test_cases: + n, v, f = case + kwargs_list.append({"num_meshes": n, "max_v": v, "max_f": f}) + benchmark( + TestMeshEdgeLoss.mesh_edge_loss, + "MESH_EDGE_LOSS", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_mesh_io.py b/tests/bm_mesh_io.py new file mode 100644 index 00000000..de2319a1 --- /dev/null +++ b/tests/bm_mesh_io.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from fvcore.common.benchmark import benchmark + +from test_obj_io import TestMeshObjIO +from test_ply_io import TestMeshPlyIO + + +def bm_save_load() -> None: + kwargs_list = [ + {"V": 100, "F": 300}, + {"V": 1000, "F": 3000}, + {"V": 10000, "F": 30000}, + ] + benchmark( + TestMeshObjIO.load_obj_with_init, + "LOAD_OBJ", + kwargs_list, + warmup_iters=1, + ) + benchmark( + TestMeshObjIO.save_obj_with_init, + "SAVE_OBJ", + kwargs_list, + warmup_iters=1, + ) + benchmark( + TestMeshPlyIO.load_ply_bm, "LOAD_PLY", kwargs_list, warmup_iters=1 + ) + benchmark( + TestMeshPlyIO.save_ply_bm, "SAVE_PLY", kwargs_list, warmup_iters=1 + ) diff --git a/tests/bm_mesh_laplacian_smoothing.py b/tests/bm_mesh_laplacian_smoothing.py new file mode 100644 index 00000000..089982ff --- /dev/null +++ b/tests/bm_mesh_laplacian_smoothing.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_mesh_laplacian_smoothing import TestLaplacianSmoothing + + +def bm_mesh_laplacian_smoothing() -> None: + devices = ["cpu"] + if torch.cuda.is_available(): + devices.append("cuda") + + kwargs_list = [] + num_meshes = [2, 10, 32] + num_verts = [100, 1000] + num_faces = [300, 3000] + test_cases = product(num_meshes, num_verts, num_faces, devices) + for case in test_cases: + n, v, f, d = case + kwargs_list.append( + {"num_meshes": n, "num_verts": v, "num_faces": f, "device": d} + ) + + benchmark( + TestLaplacianSmoothing.laplacian_smoothing_with_init, + "MESH_LAPLACIAN_SMOOTHING", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_mesh_normal_consistency.py b/tests/bm_mesh_normal_consistency.py new file mode 100644 index 00000000..fd69338a --- /dev/null +++ b/tests/bm_mesh_normal_consistency.py @@ -0,0 +1,30 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_mesh_normal_consistency import TestMeshNormalConsistency + + +def bm_mesh_normal_consistency() -> None: + devices = ["cpu"] + if torch.cuda.is_available(): + devices.append("cuda") + + kwargs_list = [] + num_meshes = [16, 32, 64] + levels = [2, 3] + test_cases = product(num_meshes, levels, devices) + for case in test_cases: + n, l, d = case + kwargs_list.append({"num_meshes": n, "level": l, "device": d}) + + benchmark( + TestMeshNormalConsistency.mesh_normal_consistency_with_ico, + "MESH_NORMAL_CONSISTENCY_ICO", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_meshes.py b/tests/bm_meshes.py new file mode 100644 index 00000000..eb55e0e6 --- /dev/null +++ b/tests/bm_meshes.py @@ -0,0 +1,38 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_meshes import TestMeshes + + +def bm_compute_packed_padded_meshes() -> None: + devices = ["cpu"] + if torch.cuda.is_available(): + devices.append("cuda") + + kwargs_list = [] + num_meshes = [32, 128] + max_v = [100, 1000, 10000] + max_f = [300, 3000, 30000] + test_cases = product(num_meshes, max_v, max_f, devices) + for case in test_cases: + n, v, f, d = case + kwargs_list.append( + {"num_meshes": n, "max_v": v, "max_f": f, "device": d} + ) + benchmark( + TestMeshes.compute_packed_with_init, + "COMPUTE_PACKED", + kwargs_list, + warmup_iters=1, + ) + benchmark( + TestMeshes.compute_padded_with_init, + "COMPUTE_PADDED", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_nearest_neighbor_points.py b/tests/bm_nearest_neighbor_points.py new file mode 100644 index 00000000..ca488eee --- /dev/null +++ b/tests/bm_nearest_neighbor_points.py @@ -0,0 +1,36 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_nearest_neighbor_points import TestNearestNeighborPoints + + +def bm_nn_points() -> None: + kwargs_list = [] + + N = [1, 4, 32] + D = [3, 4] + P1 = [1, 128] + P2 = [32, 128] + test_cases = product(N, D, P1, P2) + for case in test_cases: + n, d, p1, p2 = case + kwargs_list.append({"N": n, "D": d, "P1": p1, "P2": p2}) + + benchmark( + TestNearestNeighborPoints.bm_nn_points_python_with_init, + "NN_PYTHON", + kwargs_list, + warmup_iters=1, + ) + + if torch.cuda.is_available(): + benchmark( + TestNearestNeighborPoints.bm_nn_points_cuda_with_init, + "NN_CUDA", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_rasterize_meshes.py b/tests/bm_rasterize_meshes.py new file mode 100644 index 00000000..f8409c9f --- /dev/null +++ b/tests/bm_rasterize_meshes.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_rasterize_meshes import TestRasterizeMeshes + +# ico levels: +# 0: (12 verts, 20 faces) +# 1: (42 verts, 80 faces) +# 3: (642 verts, 1280 faces) +# 4: (2562 verts, 5120 faces) + + +def bm_rasterize_meshes() -> None: + kwargs_list = [ + { + "num_meshes": 1, + "ico_level": 0, + "image_size": 10, # very slow with large image size + "blur_radius": 0.0, + } + ] + benchmark( + TestRasterizeMeshes.rasterize_meshes_python_with_init, + "RASTERIZE_MESHES", + kwargs_list, + warmup_iters=1, + ) + + kwargs_list = [] + num_meshes = [1] + ico_level = [1] + image_size = [64, 128] + blur = [0.0, 1e-8, 1e-4] + test_cases = product(num_meshes, ico_level, image_size, blur) + for case in test_cases: + n, ic, im, b = case + kwargs_list.append( + { + "num_meshes": n, + "ico_level": ic, + "image_size": im, + "blur_radius": b, + } + ) + benchmark( + TestRasterizeMeshes.rasterize_meshes_cpu_with_init, + "RASTERIZE_MESHES", + kwargs_list, + warmup_iters=1, + ) + + if torch.cuda.is_available(): + kwargs_list = [] + num_meshes = [1, 8] + ico_level = [0, 1, 3, 4] + image_size = [64, 128, 512] + blur = [0.0, 1e-8, 1e-4] + bin_size = [0, 8, 32] + test_cases = product(num_meshes, ico_level, image_size, blur, bin_size) + # only keep cases where bin_size == 0 or image_size / bin_size < 16 + test_cases = [ + elem + for elem in test_cases + if (elem[-1] == 0 or elem[-3] / elem[-1] < 16) + ] + for case in test_cases: + n, ic, im, b, bn = case + kwargs_list.append( + { + "num_meshes": n, + "ico_level": ic, + "image_size": im, + "blur_radius": b, + "bin_size": bn, + "max_faces_per_bin": 200, + } + ) + benchmark( + TestRasterizeMeshes.rasterize_meshes_cuda_with_init, + "RASTERIZE_MESHES_CUDA", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_sample_points_from_meshes.py b/tests/bm_sample_points_from_meshes.py new file mode 100644 index 00000000..4939717e --- /dev/null +++ b/tests/bm_sample_points_from_meshes.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_sample_points_from_meshes import TestSamplePoints + + +def bm_sample_points() -> None: + if torch.cuda.is_available(): + device = "cuda:0" + kwargs_list = [] + num_meshes = [2, 10, 32] + num_verts = [100, 1000] + num_faces = [300, 3000] + num_samples = [5000, 10000] + test_cases = product(num_meshes, num_verts, num_faces, num_samples) + for case in test_cases: + n, v, f, s = case + kwargs_list.append( + { + "num_meshes": n, + "num_verts": v, + "num_faces": f, + "num_samples": s, + "device": device, + } + ) + benchmark( + TestSamplePoints.sample_points_with_init, + "SAMPLE_MESH", + kwargs_list, + warmup_iters=1, + ) + + kwargs_list = [] + backend_cuda = ["False"] + if torch.cuda.is_available(): + backend_cuda.append("True") + + num_meshes = [2, 10, 32] + num_verts = [100, 1000] + num_faces = [300, 3000] + + test_cases = product(num_meshes, num_verts, num_faces, backend_cuda) + for case in test_cases: + n, v, f, c = case + kwargs_list.append( + {"num_meshes": n, "num_verts": v, "num_faces": f, "cuda": c} + ) + benchmark( + TestSamplePoints.face_areas_with_init, + "FACE_AREAS", + kwargs_list, + warmup_iters=1, + ) + benchmark( + TestSamplePoints.packed_to_padded_with_init, + "PACKED_TO_PADDED", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_so3.py b/tests/bm_so3.py new file mode 100644 index 00000000..6bee3ca8 --- /dev/null +++ b/tests/bm_so3.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +from fvcore.common.benchmark import benchmark + +from test_so3 import TestSO3 + + +def bm_so3() -> None: + kwargs_list = [ + {"batch_size": 1}, + {"batch_size": 10}, + {"batch_size": 100}, + {"batch_size": 1000}, + ] + benchmark(TestSO3.so3_expmap, "SO3_EXP", kwargs_list, warmup_iters=1) + benchmark(TestSO3.so3_logmap, "SO3_LOG", kwargs_list, warmup_iters=1) diff --git a/tests/bm_subdivide_meshes.py b/tests/bm_subdivide_meshes.py new file mode 100644 index 00000000..f43c8e75 --- /dev/null +++ b/tests/bm_subdivide_meshes.py @@ -0,0 +1,24 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +from fvcore.common.benchmark import benchmark + +from test_subdivide_meshes import TestSubdivideMeshes + + +def bm_subdivide() -> None: + kwargs_list = [] + num_meshes = [1, 16, 32] + same_topo = [True, False] + test_cases = product(num_meshes, same_topo) + for case in test_cases: + n, s = case + kwargs_list.append({"num_meshes": n, "same_topo": s}) + benchmark( + TestSubdivideMeshes.subdivide_meshes_with_init, + "SUBDIVIDE", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/bm_vert_align.py b/tests/bm_vert_align.py new file mode 100644 index 00000000..17b18f75 --- /dev/null +++ b/tests/bm_vert_align.py @@ -0,0 +1,33 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +from itertools import product +import torch +from fvcore.common.benchmark import benchmark + +from test_vert_align import TestVertAlign + + +def bm_vert_align() -> None: + devices = ["cpu"] + if torch.cuda.is_available(): + devices.append("cuda") + + kwargs_list = [] + num_meshes = [2, 10, 32] + num_verts = [100, 1000] + num_faces = [300, 3000] + test_cases = product(num_meshes, num_verts, num_faces, devices) + for case in test_cases: + n, v, f, d = case + kwargs_list.append( + {"num_meshes": n, "num_verts": v, "num_faces": f, "device": d} + ) + + benchmark( + TestVertAlign.vert_align_with_init, + "VERT_ALIGN", + kwargs_list, + warmup_iters=1, + ) diff --git a/tests/common_testing.py b/tests/common_testing.py new file mode 100644 index 00000000..729d56e7 --- /dev/null +++ b/tests/common_testing.py @@ -0,0 +1,56 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +import unittest +import torch + + +class TestCaseMixin(unittest.TestCase): + def assertSeparate(self, tensor1, tensor2) -> None: + """ + Verify that tensor1 and tensor2 have their data in distinct locations. + """ + self.assertNotEqual( + tensor1.storage().data_ptr(), tensor2.storage().data_ptr() + ) + + def assertAllSeparate(self, tensor_list) -> None: + """ + Verify that all tensors in tensor_list have their data in + distinct locations. + """ + ptrs = [i.storage().data_ptr() for i in tensor_list] + self.assertCountEqual(ptrs, set(ptrs)) + + def assertClose( + self, + input, + other, + *, + rtol: float = 1e-05, + atol: float = 1e-08, + equal_nan: bool = False + ) -> None: + """ + Verify that two tensors or arrays are the same shape and close. + Args: + input, other: two tensors or two arrays. + rtol, atol, equal_nan: as for torch.allclose. + Note: + Optional arguments here are all keyword-only, to avoid confusion + with msg arguments on other assert functions. + """ + + self.assertEqual(np.shape(input), np.shape(other)) + + if torch.is_tensor(input): + close = torch.allclose( + input, other, rtol=rtol, atol=atol, equal_nan=equal_nan + ) + else: + close = np.allclose( + input, other, rtol=rtol, atol=atol, equal_nan=equal_nan + ) + self.assertTrue(close) diff --git a/tests/data/missing_files_obj/model.mtl b/tests/data/missing_files_obj/model.mtl new file mode 100644 index 00000000..d6a0f4fb --- /dev/null +++ b/tests/data/missing_files_obj/model.mtl @@ -0,0 +1,9 @@ +newmtl material_1 +map_Kd material_1.png + +# Test colors + +Ka 1.000 1.000 1.000 # white +Kd 1.000 1.000 1.000 # white +Ks 0.000 0.000 0.000 # black +Ns 10.0 diff --git a/tests/data/missing_files_obj/model.obj b/tests/data/missing_files_obj/model.obj new file mode 100644 index 00000000..cf411442 --- /dev/null +++ b/tests/data/missing_files_obj/model.obj @@ -0,0 +1,10 @@ + +mtllib model.mtl + +v 0.1 0.2 0.3 +v 0.2 0.3 0.4 +v 0.3 0.4 0.5 +v 0.4 0.5 0.6 +usemtl material_1 +f 1 2 3 +f 1 2 4 diff --git a/tests/data/missing_files_obj/model2.obj b/tests/data/missing_files_obj/model2.obj new file mode 100644 index 00000000..df393f9f --- /dev/null +++ b/tests/data/missing_files_obj/model2.obj @@ -0,0 +1,10 @@ + +mtllib model2.mtl + +v 0.1 0.2 0.3 +v 0.2 0.3 0.4 +v 0.3 0.4 0.5 +v 0.4 0.5 0.6 +usemtl material_1 +f 1 2 3 +f 1 2 4 diff --git a/tests/data/test_rasterized_sphere.png b/tests/data/test_rasterized_sphere.png new file mode 100644 index 00000000..57480094 Binary files /dev/null and b/tests/data/test_rasterized_sphere.png differ diff --git a/tests/data/test_rasterized_sphere_zoom.png b/tests/data/test_rasterized_sphere_zoom.png new file mode 100644 index 00000000..e774414d Binary files /dev/null and b/tests/data/test_rasterized_sphere_zoom.png differ diff --git a/tests/data/test_silhouette.png b/tests/data/test_silhouette.png new file mode 100644 index 00000000..082107d5 Binary files /dev/null and b/tests/data/test_silhouette.png differ diff --git a/tests/data/test_simple_sphere_dark.png b/tests/data/test_simple_sphere_dark.png new file mode 100644 index 00000000..7e6c6ca9 Binary files /dev/null and b/tests/data/test_simple_sphere_dark.png differ diff --git a/tests/data/test_simple_sphere_dark_elevated_camera.png b/tests/data/test_simple_sphere_dark_elevated_camera.png new file mode 100644 index 00000000..b915b8d9 Binary files /dev/null and b/tests/data/test_simple_sphere_dark_elevated_camera.png differ diff --git a/tests/data/test_simple_sphere_illuminated.png b/tests/data/test_simple_sphere_illuminated.png new file mode 100644 index 00000000..d3aa1a7e Binary files /dev/null and b/tests/data/test_simple_sphere_illuminated.png differ diff --git a/tests/data/test_simple_sphere_illuminated_elevated_camera.png b/tests/data/test_simple_sphere_illuminated_elevated_camera.png new file mode 100644 index 00000000..b86b7965 Binary files /dev/null and b/tests/data/test_simple_sphere_illuminated_elevated_camera.png differ diff --git a/tests/data/test_simple_sphere_light_gourad.png b/tests/data/test_simple_sphere_light_gourad.png new file mode 100644 index 00000000..57737e9f Binary files /dev/null and b/tests/data/test_simple_sphere_light_gourad.png differ diff --git a/tests/data/test_simple_sphere_light_gourad_elevated_camera.png b/tests/data/test_simple_sphere_light_gourad_elevated_camera.png new file mode 100644 index 00000000..58053312 Binary files /dev/null and b/tests/data/test_simple_sphere_light_gourad_elevated_camera.png differ diff --git a/tests/data/test_texture_map.png b/tests/data/test_texture_map.png new file mode 100644 index 00000000..eccbb6a8 Binary files /dev/null and b/tests/data/test_texture_map.png differ diff --git a/tests/test_blending.py b/tests/test_blending.py new file mode 100644 index 00000000..81f7516c --- /dev/null +++ b/tests/test_blending.py @@ -0,0 +1,236 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import numpy as np +import unittest +import torch + +from pytorch3d.renderer.blending import ( + BlendParams, + hard_rgb_blend, + sigmoid_alpha_blend, + softmax_rgb_blend, +) +from pytorch3d.renderer.mesh.rasterizer import Fragments + + +def sigmoid_blend_naive(colors, fragments, blend_params): + """ + Naive for loop based implementation of distance based alpha calculation. + Only for test purposes. + """ + pix_to_face = fragments.pix_to_face + dists = fragments.dists + sigma = blend_params.sigma + + N, H, W, K = pix_to_face.shape + device = pix_to_face.device + pixel_colors = torch.ones((N, H, W, 4), dtype=colors.dtype, device=device) + + for n in range(N): + for h in range(H): + for w in range(W): + alpha = 1.0 + + # Loop over k faces and calculate 2D distance based probability + # map. + for k in range(K): + if pix_to_face[n, h, w, k] >= 0: + prob = torch.sigmoid(-dists[n, h, w, k] / sigma) + alpha *= 1.0 - prob # cumulative product + pixel_colors[n, h, w, :3] = colors[n, h, w, 0, :] + pixel_colors[n, h, w, 3] = 1.0 - alpha + + pixel_colors = torch.clamp(pixel_colors, min=0, max=1.0) + return torch.flip(pixel_colors, [1]) + + +def softmax_blend_naive(colors, fragments, blend_params): + """ + Naive for loop based implementation of softmax blending. + Only for test purposes. + """ + pix_to_face = fragments.pix_to_face + dists = fragments.dists + zbuf = fragments.zbuf + sigma = blend_params.sigma + gamma = blend_params.gamma + + N, H, W, K = pix_to_face.shape + device = pix_to_face.device + pixel_colors = torch.ones((N, H, W, 4), dtype=colors.dtype, device=device) + + # Near and far clipping planes + zfar = 100.0 + znear = 1.0 + + bk_color = blend_params.background_color + if not torch.is_tensor(bk_color): + bk_color = torch.tensor(bk_color, dtype=colors.dtype, device=device) + + # Background color component + delta = np.exp(1e-10 / gamma) * 1e-10 + delta = torch.tensor(delta).to(device=device) + + for n in range(N): + for h in range(H): + for w in range(W): + alpha = 1.0 + weights_k = torch.zeros(K) + zmax = 0.0 + + # Loop over K to find max z. + for k in range(K): + if pix_to_face[n, h, w, k] >= 0: + zinv = (zfar - zbuf[n, h, w, k]) / (zfar - znear) + if zinv > zmax: + zmax = zinv + + # Loop over K faces to calculate 2D distance based probability + # map and zbuf based weights for colors. + for k in range(K): + if pix_to_face[n, h, w, k] >= 0: + zinv = (zfar - zbuf[n, h, w, k]) / (zfar - znear) + prob = torch.sigmoid(-dists[n, h, w, k] / sigma) + alpha *= 1.0 - prob # cumulative product + weights_k[k] = prob * torch.exp((zinv - zmax) / gamma) + + denom = weights_k.sum() + delta + weights = weights_k / denom + cols = (weights[..., None] * colors[n, h, w, :, :]).sum(dim=0) + pixel_colors[n, h, w, :3] = cols + pixel_colors[n, h, w, :3] += (delta / denom) * bk_color + pixel_colors[n, h, w, 3] = 1.0 - alpha + + pixel_colors = torch.clamp(pixel_colors, min=0, max=1.0) + return torch.flip(pixel_colors, [1]) + + +class TestBlending(unittest.TestCase): + def setUp(self) -> None: + torch.manual_seed(42) + + def test_hard_rgb_blend(self): + N, H, W, K = 5, 10, 10, 20 + pix_to_face = torch.ones((N, H, W, K)) + bary_coords = torch.ones((N, H, W, K, 3)) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=bary_coords, + zbuf=pix_to_face, # dummy + dists=pix_to_face, # dummy + ) + colors = bary_coords.clone() + top_k = torch.randn((K, 3)) + colors[..., :, :] = top_k + images = hard_rgb_blend(colors, fragments) + expected_vals = torch.ones((N, H, W, 4)) + pix_cols = torch.ones_like(expected_vals[..., :3]) * top_k[0, :] + expected_vals[..., :3] = pix_cols + self.assertTrue(torch.allclose(images, expected_vals)) + + def test_sigmoid_alpha_blend(self): + """ + Test outputs of sigmoid alpha blend tensorised function match those of + the naive iterative version. Also check gradients match. + """ + + # Create dummy outputs of rasterization simulating a cube in the centre + # of the image with surrounding padded values. + N, S, K = 1, 8, 2 + pix_to_face = -torch.ones((N, S, S, K), dtype=torch.int64) + h = int(S / 2) + pix_to_face_full = torch.randint(size=(N, h, h, K), low=0, high=100) + s = int(S / 4) + e = int(0.75 * S) + pix_to_face[:, s:e, s:e, :] = pix_to_face_full + bary_coords = torch.ones((N, S, S, K, 3)) + + # randomly flip the sign of the distance + # (-) means inside triangle, (+) means outside triangle. + random_sign_flip = torch.rand((N, S, S, K)) + random_sign_flip[random_sign_flip > 0.5] *= -1.0 + dists = torch.randn(size=(N, S, S, K)) + dists1 = dists * random_sign_flip + dists2 = dists1.clone() + dists1.requires_grad = True + dists2.requires_grad = True + colors = torch.randn_like(bary_coords) + fragments1 = Fragments( + pix_to_face=pix_to_face, + bary_coords=bary_coords, # dummy + zbuf=pix_to_face, # dummy + dists=dists1, + ) + fragments2 = Fragments( + pix_to_face=pix_to_face, + bary_coords=bary_coords, # dummy + zbuf=pix_to_face, # dummy + dists=dists2, + ) + blend_params = BlendParams(sigma=2e-1) + images = sigmoid_alpha_blend(colors, fragments1, blend_params) + images_naive = sigmoid_blend_naive(colors, fragments2, blend_params) + self.assertTrue(torch.allclose(images, images_naive)) + + torch.manual_seed(231) + images.sum().backward() + self.assertTrue(hasattr(dists1, "grad")) + images_naive.sum().backward() + self.assertTrue(hasattr(dists2, "grad")) + + self.assertTrue(torch.allclose(dists1.grad, dists2.grad, rtol=1e-5)) + + def test_softmax_rgb_blend(self): + # Create dummy outputs of rasterization simulating a cube in the centre + # of the image with surrounding padded values. + N, S, K = 1, 8, 2 + pix_to_face = -torch.ones((N, S, S, K), dtype=torch.int64) + h = int(S / 2) + pix_to_face_full = torch.randint(size=(N, h, h, K), low=0, high=100) + s = int(S / 4) + e = int(0.75 * S) + pix_to_face[:, s:e, s:e, :] = pix_to_face_full + bary_coords = torch.ones((N, S, S, K, 3)) + + random_sign_flip = torch.rand((N, S, S, K)) + random_sign_flip[random_sign_flip > 0.5] *= -1.0 + zbuf1 = torch.randn(size=(N, S, S, K)) + + # randomly flip the sign of the distance + # (-) means inside triangle, (+) means outside triangle. + dists1 = torch.randn(size=(N, S, S, K)) * random_sign_flip + dists2 = dists1.clone() + zbuf2 = zbuf1.clone() + dists1.requires_grad = True + dists2.requires_grad = True + zbuf1.requires_grad = True + zbuf2.requires_grad = True + colors = torch.randn_like(bary_coords) + fragments1 = Fragments( + pix_to_face=pix_to_face, + bary_coords=bary_coords, # dummy + zbuf=zbuf1, + dists=dists1, + ) + fragments2 = Fragments( + pix_to_face=pix_to_face, + bary_coords=bary_coords, # dummy + zbuf=zbuf2, + dists=dists2, + ) + blend_params = BlendParams(sigma=1e-1) + images = softmax_rgb_blend(colors, fragments1, blend_params) + images_naive = softmax_blend_naive(colors, fragments2, blend_params) + self.assertTrue(torch.allclose(images, images_naive)) + + # Check gradients. + images.sum().backward() + self.assertTrue(hasattr(dists1, "grad")) + self.assertTrue(hasattr(zbuf1, "grad")) + images_naive.sum().backward() + self.assertTrue(hasattr(dists2, "grad")) + self.assertTrue(hasattr(zbuf2, "grad")) + + self.assertTrue(torch.allclose(dists1.grad, dists2.grad, atol=2e-5)) + self.assertTrue(torch.allclose(zbuf1.grad, zbuf2.grad, atol=2e-5)) diff --git a/tests/test_cameras.py b/tests/test_cameras.py new file mode 100644 index 00000000..fd7f33be --- /dev/null +++ b/tests/test_cameras.py @@ -0,0 +1,673 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +# Some of the code below is adapted from Soft Rasterizer (SoftRas) +# +# Copyright (c) 2017 Hiroharu Kato +# Copyright (c) 2018 Nikos Kolotouros +# Copyright (c) 2019 Shichen Liu +# +# 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: +# +# 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. + +import math +import numpy as np +import unittest +import torch + +from pytorch3d.renderer.cameras import ( + OpenGLOrthographicCameras, + OpenGLPerspectiveCameras, + SfMOrthographicCameras, + SfMPerspectiveCameras, + camera_position_from_spherical_angles, + get_world_to_view_transform, + look_at_rotation, +) +from pytorch3d.transforms import Transform3d +from pytorch3d.transforms.so3 import so3_exponential_map + +from common_testing import TestCaseMixin + + +# Naive function adapted from SoftRasterizer for test purposes. +def perspective_project_naive(points, fov=60.0): + """ + Compute perspective projection from a given viewing angle. + Args: + points: (N, V, 3) representing the padded points. + viewing angle: degrees + Returns: + (N, V, 3) tensor of projected points preserving the view space z + coordinate (no z renormalization) + """ + device = points.device + halfFov = torch.tensor( + (fov / 2) / 180 * np.pi, dtype=torch.float32, device=device + ) + scale = torch.tan(halfFov[None]) + scale = scale[:, None] + z = points[:, :, 2] + x = points[:, :, 0] / z / scale + y = points[:, :, 1] / z / scale + points = torch.stack((x, y, z), dim=2) + return points + + +def sfm_perspective_project_naive(points, fx=1.0, fy=1.0, p0x=0.0, p0y=0.0): + """ + Compute perspective projection using focal length and principal point. + + Args: + points: (N, V, 3) representing the padded points. + fx: world units + fy: world units + p0x: pixels + p0y: pixels + Returns: + (N, V, 3) tensor of projected points. + """ + z = points[:, :, 2] + x = (points[:, :, 0] * fx + p0x) / z + y = (points[:, :, 1] * fy + p0y) / z + points = torch.stack((x, y, 1.0 / z), dim=2) + return points + + +# Naive function adapted from SoftRasterizer for test purposes. +def orthographic_project_naive(points, scale_xyz=(1.0, 1.0, 1.0)): + """ + Compute orthographic projection from a given angle + Args: + points: (N, V, 3) representing the padded points. + scaled: (N, 3) scaling factors for each of xyz directions + Returns: + (N, V, 3) tensor of projected points preserving the view space z + coordinate (no z renormalization). + """ + if not torch.is_tensor(scale_xyz): + scale_xyz = torch.tensor(scale_xyz) + scale_xyz = scale_xyz.view(-1, 3) + z = points[:, :, 2] + x = points[:, :, 0] * scale_xyz[:, 0] + y = points[:, :, 1] * scale_xyz[:, 1] + points = torch.stack((x, y, z), dim=2) + return points + + +class TestCameraHelpers(unittest.TestCase): + def setUp(self) -> None: + super().setUp() + torch.manual_seed(42) + np.random.seed(42) + + def test_camera_position_from_angles_python_scalar(self): + dist = 2.7 + elev = 90.0 + azim = 0.0 + expected_position = torch.tensor( + [0.0, 2.7, 0.0], dtype=torch.float32 + ).view(1, 3) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=2e-7)) + + def test_camera_position_from_angles_python_scalar_radians(self): + dist = 2.7 + elev = math.pi / 2 + azim = 0.0 + expected_position = torch.tensor([0.0, 2.7, 0.0], dtype=torch.float32) + expected_position = expected_position.view(1, 3) + position = camera_position_from_spherical_angles( + dist, elev, azim, degrees=False + ) + self.assertTrue(torch.allclose(position, expected_position, atol=2e-7)) + + def test_camera_position_from_angles_torch_scalars(self): + dist = torch.tensor(2.7) + elev = torch.tensor(0.0) + azim = torch.tensor(90.0) + expected_position = torch.tensor( + [2.7, 0.0, 0.0], dtype=torch.float32 + ).view(1, 3) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=2e-7)) + + def test_camera_position_from_angles_mixed_scalars(self): + dist = 2.7 + elev = torch.tensor(0.0) + azim = 90.0 + expected_position = torch.tensor( + [2.7, 0.0, 0.0], dtype=torch.float32 + ).view(1, 3) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=2e-7)) + + def test_camera_position_from_angles_torch_scalar_grads(self): + dist = torch.tensor(2.7, requires_grad=True) + elev = torch.tensor(45.0, requires_grad=True) + azim = torch.tensor(45.0) + position = camera_position_from_spherical_angles(dist, elev, azim) + position.sum().backward() + self.assertTrue(hasattr(elev, "grad")) + self.assertTrue(hasattr(dist, "grad")) + elev_grad = elev.grad.clone() + dist_grad = dist.grad.clone() + elev = math.pi / 180.0 * elev.detach() + azim = math.pi / 180.0 * azim + grad_dist = ( + torch.cos(elev) * torch.sin(azim) + + torch.sin(elev) + - torch.cos(elev) * torch.cos(azim) + ) + grad_elev = ( + -torch.sin(elev) * torch.sin(azim) + + torch.cos(elev) + + torch.sin(elev) * torch.cos(azim) + ) + grad_elev = dist * (math.pi / 180.0) * grad_elev + self.assertTrue(torch.allclose(elev_grad, grad_elev)) + self.assertTrue(torch.allclose(dist_grad, grad_dist)) + + def test_camera_position_from_angles_vectors(self): + dist = torch.tensor([2.0, 2.0]) + elev = torch.tensor([0.0, 90.0]) + azim = torch.tensor([90.0, 0.0]) + expected_position = torch.tensor( + [[2.0, 0.0, 0.0], [0.0, 2.0, 0.0]], dtype=torch.float32 + ) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=2e-7)) + + def test_camera_position_from_angles_vectors_broadcast(self): + dist = torch.tensor([2.0, 3.0, 5.0]) + elev = torch.tensor([0.0]) + azim = torch.tensor([90.0]) + expected_position = torch.tensor( + [[2.0, 0.0, 0.0], [3.0, 0.0, 0.0], [5.0, 0.0, 0.0]], + dtype=torch.float32, + ) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=3e-7)) + + def test_camera_position_from_angles_vectors_mixed_broadcast(self): + dist = torch.tensor([2.0, 3.0, 5.0]) + elev = 0.0 + azim = torch.tensor(90.0) + expected_position = torch.tensor( + [[2.0, 0.0, 0.0], [3.0, 0.0, 0.0], [5.0, 0.0, 0.0]], + dtype=torch.float32, + ) + position = camera_position_from_spherical_angles(dist, elev, azim) + self.assertTrue(torch.allclose(position, expected_position, atol=3e-7)) + + def test_camera_position_from_angles_vectors_mixed_broadcast_grads(self): + dist = torch.tensor([2.0, 3.0, 5.0], requires_grad=True) + elev = torch.tensor(45.0, requires_grad=True) + azim = 45.0 + position = camera_position_from_spherical_angles(dist, elev, azim) + position.sum().backward() + self.assertTrue(hasattr(elev, "grad")) + self.assertTrue(hasattr(dist, "grad")) + elev_grad = elev.grad.clone() + dist_grad = dist.grad.clone() + azim = torch.tensor(azim) + elev = math.pi / 180.0 * elev.detach() + azim = math.pi / 180.0 * azim + grad_dist = ( + torch.cos(elev) * torch.sin(azim) + + torch.sin(elev) + - torch.cos(elev) * torch.cos(azim) + ) + grad_elev = ( + -torch.sin(elev) * torch.sin(azim) + + torch.cos(elev) + + torch.sin(elev) * torch.cos(azim) + ) + grad_elev = (dist * (math.pi / 180.0) * grad_elev).sum() + self.assertTrue(torch.allclose(elev_grad, grad_elev)) + self.assertTrue(torch.allclose(dist_grad, grad_dist)) + + def test_camera_position_from_angles_vectors_bad_broadcast(self): + # Batch dim for broadcast must be N or 1 + dist = torch.tensor([2.0, 3.0, 5.0]) + elev = torch.tensor([0.0, 90.0]) + azim = torch.tensor([90.0]) + with self.assertRaises(ValueError): + camera_position_from_spherical_angles(dist, elev, azim) + + def test_look_at_rotation_python_list(self): + camera_position = [[0.0, 0.0, -1.0]] # camera pointing along negative z + rot_mat = look_at_rotation(camera_position) + self.assertTrue(torch.allclose(rot_mat, torch.eye(3)[None], atol=2e-7)) + + def test_look_at_rotation_input_fail(self): + camera_position = [-1.0] # expected to have xyz positions + with self.assertRaises(ValueError): + look_at_rotation(camera_position) + + def test_look_at_rotation_list_broadcast(self): + # fmt: off + camera_positions = [[0.0, 0.0, -1.0], [0.0, 0.0, 1.0]] + rot_mats_expected = torch.tensor( + [ + [ + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0] + ], + [ + [-1.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, -1.0] # noqa: E241, E201 + ], + ], + dtype=torch.float32 + ) + # fmt: on + rot_mats = look_at_rotation(camera_positions) + self.assertTrue(torch.allclose(rot_mats, rot_mats_expected, atol=2e-7)) + + def test_look_at_rotation_tensor_broadcast(self): + # fmt: off + camera_positions = torch.tensor([ + [0.0, 0.0, -1.0], + [0.0, 0.0, 1.0] # noqa: E241, E201 + ], dtype=torch.float32) + rot_mats_expected = torch.tensor( + [ + [ + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0] + ], + [ + [-1.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, -1.0] # noqa: E241, E201 + ], + ], + dtype=torch.float32 + ) + # fmt: on + rot_mats = look_at_rotation(camera_positions) + self.assertTrue(torch.allclose(rot_mats, rot_mats_expected, atol=2e-7)) + + def test_look_at_rotation_tensor_grad(self): + camera_position = torch.tensor([[0.0, 0.0, -1.0]], requires_grad=True) + rot_mat = look_at_rotation(camera_position) + rot_mat.sum().backward() + self.assertTrue(hasattr(camera_position, "grad")) + self.assertTrue( + torch.allclose( + camera_position.grad, + torch.zeros_like(camera_position), + atol=2e-7, + ) + ) + + def test_view_transform(self): + T = torch.tensor([0.0, 0.0, -1.0], requires_grad=True).view(1, -1) + R = look_at_rotation(T) + RT = get_world_to_view_transform(R=R, T=T) + self.assertTrue(isinstance(RT, Transform3d)) + + def test_view_transform_class_method(self): + T = torch.tensor([0.0, 0.0, -1.0], requires_grad=True).view(1, -1) + R = look_at_rotation(T) + RT = get_world_to_view_transform(R=R, T=T) + for cam_type in ( + OpenGLPerspectiveCameras, + OpenGLOrthographicCameras, + SfMOrthographicCameras, + SfMPerspectiveCameras, + ): + cam = cam_type(R=R, T=T) + RT_class = cam.get_world_to_view_transform() + self.assertTrue( + torch.allclose(RT.get_matrix(), RT_class.get_matrix()) + ) + + self.assertTrue(isinstance(RT, Transform3d)) + + def test_get_camera_center(self, batch_size=10): + T = torch.randn(batch_size, 3) + R = so3_exponential_map(torch.randn(batch_size, 3) * 3.0) + for cam_type in ( + OpenGLPerspectiveCameras, + OpenGLOrthographicCameras, + SfMOrthographicCameras, + SfMPerspectiveCameras, + ): + cam = cam_type(R=R, T=T) + C = cam.get_camera_center() + C_ = -torch.bmm(R, T[:, :, None])[:, :, 0] + self.assertTrue(torch.allclose(C, C_, atol=1e-05)) + + +class TestPerspectiveProjection(TestCaseMixin, unittest.TestCase): + def test_perspective(self): + far = 10.0 + near = 1.0 + cameras = OpenGLPerspectiveCameras(znear=near, zfar=far, fov=60.0) + P = cameras.get_projection_transform() + # vertices are at the far clipping plane so z gets mapped to 1. + vertices = torch.tensor([1, 2, far], dtype=torch.float32) + projected_verts = torch.tensor( + [np.sqrt(3) / far, 2 * np.sqrt(3) / far, 1.0], dtype=torch.float32 + ) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + v2 = perspective_project_naive(vertices, fov=60.0) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(far * v1[..., 2], v2[..., 2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + # vertices are at the near clipping plane so z gets mapped to 0.0. + vertices[..., 2] = near + projected_verts = torch.tensor( + [np.sqrt(3) / near, 2 * np.sqrt(3) / near, 0.0], dtype=torch.float32 + ) + v1 = P.transform_points(vertices) + v2 = perspective_project_naive(vertices, fov=60.0) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_perspective_kwargs(self): + cameras = OpenGLPerspectiveCameras(znear=5.0, zfar=100.0, fov=0.0) + # Override defaults by passing in values to get_projection_transform + far = 10.0 + P = cameras.get_projection_transform(znear=1.0, zfar=far, fov=60.0) + vertices = torch.tensor([1, 2, far], dtype=torch.float32) + projected_verts = torch.tensor( + [np.sqrt(3) / far, 2 * np.sqrt(3) / far, 1.0], dtype=torch.float32 + ) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_perspective_mixed_inputs_broadcast(self): + far = torch.tensor([10.0, 20.0], dtype=torch.float32) + near = 1.0 + fov = torch.tensor(60.0) + cameras = OpenGLPerspectiveCameras(znear=near, zfar=far, fov=fov) + P = cameras.get_projection_transform() + vertices = torch.tensor([1, 2, 10], dtype=torch.float32) + z1 = 1.0 # vertices at far clipping plane so z = 1.0 + z2 = (20.0 / (20.0 - 1.0) * 10.0 + -(20.0) / (20.0 - 1.0)) / 10.0 + projected_verts = torch.tensor( + [ + [np.sqrt(3) / 10.0, 2 * np.sqrt(3) / 10.0, z1], + [np.sqrt(3) / 10.0, 2 * np.sqrt(3) / 10.0, z2], + ], + dtype=torch.float32, + ) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + v2 = perspective_project_naive(vertices, fov=60.0) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_perspective_mixed_inputs_grad(self): + far = torch.tensor([10.0]) + near = 1.0 + fov = torch.tensor(60.0, requires_grad=True) + cameras = OpenGLPerspectiveCameras(znear=near, zfar=far, fov=fov) + P = cameras.get_projection_transform() + vertices = torch.tensor([1, 2, 10], dtype=torch.float32) + vertices_batch = vertices[None, None, :] + v1 = P.transform_points(vertices_batch).squeeze() + v1.sum().backward() + self.assertTrue(hasattr(fov, "grad")) + fov_grad = fov.grad.clone() + half_fov_rad = (math.pi / 180.0) * fov.detach() / 2.0 + grad_cotan = -(1.0 / (torch.sin(half_fov_rad) ** 2.0) * 1 / 2.0) + grad_fov = (math.pi / 180.0) * grad_cotan + grad_fov = (vertices[0] + vertices[1]) * grad_fov / 10.0 + self.assertTrue(torch.allclose(fov_grad, grad_fov)) + + def test_camera_class_init(self): + device = torch.device("cuda:0") + cam = OpenGLPerspectiveCameras(znear=10.0, zfar=(100.0, 200.0)) + + # Check broadcasting + self.assertTrue(cam.znear.shape == (2,)) + self.assertTrue(cam.zfar.shape == (2,)) + + # update znear element 1 + cam[1].znear = 20.0 + self.assertTrue(cam.znear[1] == 20.0) + + # Get item and get value + c0 = cam[0] + self.assertTrue(c0.zfar == 100.0) + + # Test to + new_cam = cam.to(device=device) + self.assertTrue(new_cam.device == device) + + def test_get_full_transform(self): + cam = OpenGLPerspectiveCameras() + T = torch.tensor([0.0, 0.0, 1.0]).view(1, -1) + R = look_at_rotation(T) + P = cam.get_full_projection_transform(R=R, T=T) + self.assertTrue(isinstance(P, Transform3d)) + self.assertTrue(torch.allclose(cam.R, R)) + self.assertTrue(torch.allclose(cam.T, T)) + + def test_transform_points(self): + # Check transform_points methods works with default settings for + # RT and P + far = 10.0 + cam = OpenGLPerspectiveCameras(znear=1.0, zfar=far, fov=60.0) + points = torch.tensor([1, 2, far], dtype=torch.float32) + points = points.view(1, 1, 3).expand(5, 10, -1) + projected_points = torch.tensor( + [np.sqrt(3) / far, 2 * np.sqrt(3) / far, 1.0], dtype=torch.float32 + ) + projected_points = projected_points.view(1, 1, 3).expand(5, 10, -1) + new_points = cam.transform_points(points) + self.assertTrue(torch.allclose(new_points, projected_points)) + + +class TestOpenGLOrthographicProjection(TestCaseMixin, unittest.TestCase): + def test_orthographic(self): + far = 10.0 + near = 1.0 + cameras = OpenGLOrthographicCameras(znear=near, zfar=far) + P = cameras.get_projection_transform() + + vertices = torch.tensor([1, 2, far], dtype=torch.float32) + projected_verts = torch.tensor([1, 2, 1], dtype=torch.float32) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive(vertices) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + vertices[..., 2] = near + projected_verts[2] = 0.0 + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive(vertices) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_orthographic_scaled(self): + vertices = torch.tensor([1, 2, 0.5], dtype=torch.float32) + vertices = vertices[None, None, :] + scale = torch.tensor([[2.0, 0.5, 20]]) + # applying the scale puts the z coordinate at the far clipping plane + # so the z is mapped to 1.0 + projected_verts = torch.tensor([2, 1, 1], dtype=torch.float32) + cameras = OpenGLOrthographicCameras( + znear=1.0, zfar=10.0, scale_xyz=scale + ) + P = cameras.get_projection_transform() + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive(vertices, scale) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1, projected_verts)) + + def test_orthographic_kwargs(self): + cameras = OpenGLOrthographicCameras(znear=5.0, zfar=100.0) + far = 10.0 + P = cameras.get_projection_transform(znear=1.0, zfar=far) + vertices = torch.tensor([1, 2, far], dtype=torch.float32) + projected_verts = torch.tensor([1, 2, 1], dtype=torch.float32) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_orthographic_mixed_inputs_broadcast(self): + far = torch.tensor([10.0, 20.0]) + near = 1.0 + cameras = OpenGLOrthographicCameras(znear=near, zfar=far) + P = cameras.get_projection_transform() + + vertices = torch.tensor([1.0, 2.0, 10.0], dtype=torch.float32) + z2 = 1.0 / (20.0 - 1.0) * 10.0 + -(1.0) / (20.0 - 1.0) + projected_verts = torch.tensor( + [[1.0, 2.0, 1.0], [1.0, 2.0, z2]], dtype=torch.float32 + ) + vertices = vertices[None, None, :] + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive(vertices) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1.squeeze(), projected_verts)) + + def test_orthographic_mixed_inputs_grad(self): + far = torch.tensor([10.0]) + near = 1.0 + scale = torch.tensor([[1.0, 1.0, 1.0]], requires_grad=True) + cameras = OpenGLOrthographicCameras( + znear=near, zfar=far, scale_xyz=scale + ) + P = cameras.get_projection_transform() + vertices = torch.tensor([1.0, 2.0, 10.0], dtype=torch.float32) + vertices_batch = vertices[None, None, :] + v1 = P.transform_points(vertices_batch) + v1.sum().backward() + self.assertTrue(hasattr(scale, "grad")) + scale_grad = scale.grad.clone() + grad_scale = torch.tensor( + [ + [ + vertices[0] * P._matrix[:, 0, 0], + vertices[1] * P._matrix[:, 1, 1], + vertices[2] * P._matrix[:, 2, 2], + ] + ] + ) + self.assertTrue(torch.allclose(scale_grad, grad_scale)) + + +class TestSfMOrthographicProjection(TestCaseMixin, unittest.TestCase): + def test_orthographic(self): + cameras = SfMOrthographicCameras() + P = cameras.get_projection_transform() + + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + projected_verts = vertices.clone() + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive(vertices) + + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1, projected_verts)) + + def test_orthographic_scaled(self): + focal_length_x = 10.0 + focal_length_y = 15.0 + + cameras = SfMOrthographicCameras( + focal_length=((focal_length_x, focal_length_y),) + ) + P = cameras.get_projection_transform() + + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + projected_verts = vertices.clone() + projected_verts[:, :, 0] *= focal_length_x + projected_verts[:, :, 1] *= focal_length_y + v1 = P.transform_points(vertices) + v2 = orthographic_project_naive( + vertices, scale_xyz=(focal_length_x, focal_length_y, 1.0) + ) + v3 = cameras.transform_points(vertices) + self.assertTrue(torch.allclose(v1[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v3[..., :2], v2[..., :2])) + self.assertTrue(torch.allclose(v1, projected_verts)) + + def test_orthographic_kwargs(self): + cameras = SfMOrthographicCameras( + focal_length=5.0, principal_point=((2.5, 2.5),) + ) + P = cameras.get_projection_transform( + focal_length=2.0, principal_point=((2.5, 3.5),) + ) + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + projected_verts = vertices.clone() + projected_verts[:, :, :2] *= 2.0 + projected_verts[:, :, 0] += 2.5 + projected_verts[:, :, 1] += 3.5 + v1 = P.transform_points(vertices) + self.assertTrue(torch.allclose(v1, projected_verts)) + + +class TestSfMPerspectiveProjection(TestCaseMixin, unittest.TestCase): + def test_perspective(self): + cameras = SfMPerspectiveCameras() + P = cameras.get_projection_transform() + + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + v1 = P.transform_points(vertices) + v2 = sfm_perspective_project_naive(vertices) + self.assertTrue(torch.allclose(v1, v2)) + + def test_perspective_scaled(self): + focal_length_x = 10.0 + focal_length_y = 15.0 + p0x = 15.0 + p0y = 30.0 + + cameras = SfMPerspectiveCameras( + focal_length=((focal_length_x, focal_length_y),), + principal_point=((p0x, p0y),), + ) + P = cameras.get_projection_transform() + + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + v1 = P.transform_points(vertices) + v2 = sfm_perspective_project_naive( + vertices, fx=focal_length_x, fy=focal_length_y, p0x=p0x, p0y=p0y + ) + v3 = cameras.transform_points(vertices) + self.assertTrue(torch.allclose(v1, v2)) + self.assertTrue(torch.allclose(v3[..., :2], v2[..., :2])) + + def test_perspective_kwargs(self): + cameras = SfMPerspectiveCameras( + focal_length=5.0, principal_point=((2.5, 2.5),) + ) + P = cameras.get_projection_transform( + focal_length=2.0, principal_point=((2.5, 3.5),) + ) + vertices = torch.randn([3, 4, 3], dtype=torch.float32) + v1 = P.transform_points(vertices) + v2 = sfm_perspective_project_naive( + vertices, fx=2.0, fy=2.0, p0x=2.5, p0y=3.5 + ) + self.assertTrue(torch.allclose(v1, v2)) diff --git a/tests/test_chamfer.py b/tests/test_chamfer.py new file mode 100644 index 00000000..11c31a9c --- /dev/null +++ b/tests/test_chamfer.py @@ -0,0 +1,372 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch +import torch.nn.functional as F + +from pytorch3d.loss import chamfer_distance + + +class TestChamfer(unittest.TestCase): + @staticmethod + def init_pointclouds(batch_size: int = 10, P1: int = 32, P2: int = 64): + """ + Randomly initialize two batches of point clouds of sizes + (N, P1, D) and (N, P2, D) and return random normal vectors for + each batch of size (N, P1, 3) and (N, P2, 3). + """ + device = torch.device("cuda:0") + p1 = torch.rand((batch_size, P1, 3), dtype=torch.float32, device=device) + p1_normals = torch.rand( + (batch_size, P1, 3), dtype=torch.float32, device=device + ) + p1_normals = p1_normals / p1_normals.norm(dim=2, p=2, keepdim=True) + p2 = torch.rand((batch_size, P2, 3), dtype=torch.float32, device=device) + p2_normals = torch.rand( + (batch_size, P2, 3), dtype=torch.float32, device=device + ) + p2_normals = p2_normals / p2_normals.norm(dim=2, p=2, keepdim=True) + weights = torch.rand((batch_size,), dtype=torch.float32, device=device) + + return p1, p2, p1_normals, p2_normals, weights + + @staticmethod + def chamfer_distance_naive(p1, p2, p1_normals=None, p2_normals=None): + """ + Naive iterative implementation of nearest neighbor and chamfer distance. + Returns lists of the unreduced loss and loss_normals. + """ + N, P1, D = p1.shape + P2 = p2.size(1) + device = torch.device("cuda:0") + return_normals = p1_normals is not None and p2_normals is not None + dist = torch.zeros((N, P1, P2), dtype=torch.float32, device=device) + + for n in range(N): + for i1 in range(P1): + for i2 in range(P2): + dist[n, i1, i2] = torch.sum( + (p1[n, i1, :] - p2[n, i2, :]) ** 2 + ) + + loss = [ + torch.min(dist, dim=2)[0], # (N, P1) + torch.min(dist, dim=1)[0], # (N, P2) + ] + + lnorm = [p1.new_zeros(()), p1.new_zeros(())] + + if return_normals: + p1_index = dist.argmin(2).view(N, P1, 1).expand(N, P1, 3) + p2_index = dist.argmin(1).view(N, P2, 1).expand(N, P2, 3) + lnorm1 = 1 - torch.abs( + F.cosine_similarity( + p1_normals, p2_normals.gather(1, p1_index), dim=2, eps=1e-6 + ) + ) + lnorm2 = 1 - torch.abs( + F.cosine_similarity( + p2_normals, p1_normals.gather(1, p2_index), dim=2, eps=1e-6 + ) + ) + lnorm = [lnorm1, lnorm2] # [(N, P1), (N, P2)] + + return loss, lnorm + + def test_chamfer_default_no_normals(self): + """ + Compare chamfer loss with naive implementation using default + input values and no normals. + """ + N, P1, P2 = 7, 10, 18 + p1, p2, _, _, weights = TestChamfer.init_pointclouds(N, P1, P2) + pred_loss, _ = TestChamfer.chamfer_distance_naive(p1, p2) + loss, loss_norm = chamfer_distance(p1, p2, weights=weights) + pred_loss = pred_loss[0].sum(1) / P1 + pred_loss[1].sum(1) / P2 + pred_loss *= weights + pred_loss = pred_loss.sum() / weights.sum() + self.assertTrue(torch.allclose(loss, pred_loss)) + self.assertTrue(loss_norm is None) + + def test_chamfer_point_reduction(self): + """ + Compare output of vectorized chamfer loss with naive implementation + for point_reduction in ["mean", "sum", "none"] and + batch_reduction = "none". + """ + N, P1, P2 = 7, 10, 18 + p1, p2, p1_normals, p2_normals, weights = TestChamfer.init_pointclouds( + N, P1, P2 + ) + + pred_loss, pred_loss_norm = TestChamfer.chamfer_distance_naive( + p1, p2, p1_normals, p2_normals + ) + + # point_reduction = "mean". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="none", + point_reduction="mean", + ) + pred_loss_mean = pred_loss[0].sum(1) / P1 + pred_loss[1].sum(1) / P2 + pred_loss_mean *= weights + self.assertTrue(torch.allclose(loss, pred_loss_mean)) + + pred_loss_norm_mean = ( + pred_loss_norm[0].sum(1) / P1 + pred_loss_norm[1].sum(1) / P2 + ) + pred_loss_norm_mean *= weights + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_mean)) + + # point_reduction = "sum". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="none", + point_reduction="sum", + ) + pred_loss_sum = pred_loss[0].sum(1) + pred_loss[1].sum(1) + pred_loss_sum *= weights + self.assertTrue(torch.allclose(loss, pred_loss_sum)) + + pred_loss_norm_sum = pred_loss_norm[0].sum(1) + pred_loss_norm[1].sum(1) + pred_loss_norm_sum *= weights + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_sum)) + + # Error when point_reduction = "none" and batch_reduction = "none". + with self.assertRaises(ValueError): + chamfer_distance( + p1, + p2, + weights=weights, + batch_reduction="none", + point_reduction="none", + ) + + # Error when batch_reduction is not in ["none", "mean", "sum"]. + with self.assertRaises(ValueError): + chamfer_distance(p1, p2, weights=weights, batch_reduction="max") + + def test_chamfer_batch_reduction(self): + """ + Compare output of vectorized chamfer loss with naive implementation + for batch_reduction in ["mean", "sum"] and point_reduction = "none". + """ + N, P1, P2 = 7, 10, 18 + p1, p2, p1_normals, p2_normals, weights = TestChamfer.init_pointclouds( + N, P1, P2 + ) + + pred_loss, pred_loss_norm = TestChamfer.chamfer_distance_naive( + p1, p2, p1_normals, p2_normals + ) + + # batch_reduction = "sum". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="sum", + point_reduction="none", + ) + pred_loss[0] *= weights.view(N, 1) + pred_loss[1] *= weights.view(N, 1) + pred_loss = pred_loss[0].sum() + pred_loss[1].sum() + self.assertTrue(torch.allclose(loss, pred_loss)) + + pred_loss_norm[0] *= weights.view(N, 1) + pred_loss_norm[1] *= weights.view(N, 1) + pred_loss_norm = pred_loss_norm[0].sum() + pred_loss_norm[1].sum() + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm)) + + # batch_reduction = "mean". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="mean", + point_reduction="none", + ) + + pred_loss /= weights.sum() + self.assertTrue(torch.allclose(loss, pred_loss)) + + pred_loss_norm /= weights.sum() + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm)) + + # Error when point_reduction is not in ["none", "mean", "sum"]. + with self.assertRaises(ValueError): + chamfer_distance(p1, p2, weights=weights, point_reduction="max") + + def test_chamfer_joint_reduction(self): + """ + Compare output of vectorized chamfer loss with naive implementation + for batch_reduction in ["mean", "sum"] and + point_reduction in ["mean", "sum"]. + """ + N, P1, P2 = 7, 10, 18 + p1, p2, p1_normals, p2_normals, weights = TestChamfer.init_pointclouds( + N, P1, P2 + ) + + pred_loss, pred_loss_norm = TestChamfer.chamfer_distance_naive( + p1, p2, p1_normals, p2_normals + ) + + # batch_reduction = "sum", point_reduction = "sum". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="sum", + point_reduction="sum", + ) + pred_loss[0] *= weights.view(N, 1) + pred_loss[1] *= weights.view(N, 1) + pred_loss_sum = pred_loss[0].sum(1) + pred_loss[1].sum(1) # point sum + pred_loss_sum = pred_loss_sum.sum() # batch sum + self.assertTrue(torch.allclose(loss, pred_loss_sum)) + + pred_loss_norm[0] *= weights.view(N, 1) + pred_loss_norm[1] *= weights.view(N, 1) + pred_loss_norm_sum = pred_loss_norm[0].sum(1) + pred_loss_norm[1].sum( + 1 + ) # point sum. + pred_loss_norm_sum = pred_loss_norm_sum.sum() # batch sum + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_sum)) + + # batch_reduction = "mean", point_reduction = "sum". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="mean", + point_reduction="sum", + ) + pred_loss_sum /= weights.sum() + self.assertTrue(torch.allclose(loss, pred_loss_sum)) + + pred_loss_norm_sum /= weights.sum() + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_sum)) + + # batch_reduction = "sum", point_reduction = "mean". + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="sum", + point_reduction="mean", + ) + pred_loss_mean = pred_loss[0].sum(1) / P1 + pred_loss[1].sum(1) / P2 + pred_loss_mean = pred_loss_mean.sum() + self.assertTrue(torch.allclose(loss, pred_loss_mean)) + + pred_loss_norm_mean = ( + pred_loss_norm[0].sum(1) / P1 + pred_loss_norm[1].sum(1) / P2 + ) + pred_loss_norm_mean = pred_loss_norm_mean.sum() + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_mean)) + + # batch_reduction = "mean", point_reduction = "mean". This is the default. + loss, loss_norm = chamfer_distance( + p1, + p2, + p1_normals, + p2_normals, + weights=weights, + batch_reduction="mean", + point_reduction="mean", + ) + pred_loss_mean /= weights.sum() + self.assertTrue(torch.allclose(loss, pred_loss_mean)) + + pred_loss_norm_mean /= weights.sum() + self.assertTrue(torch.allclose(loss_norm, pred_loss_norm_mean)) + + def test_incorrect_weights(self): + N, P1, P2 = 16, 64, 128 + device = torch.device("cuda:0") + p1 = torch.rand( + (N, P1, 3), dtype=torch.float32, device=device, requires_grad=True + ) + p2 = torch.rand( + (N, P2, 3), dtype=torch.float32, device=device, requires_grad=True + ) + + weights = torch.zeros((N,), dtype=torch.float32, device=device) + loss, loss_norm = chamfer_distance( + p1, p2, weights=weights, batch_reduction="mean" + ) + self.assertTrue(torch.allclose(loss.cpu(), torch.zeros((1,)))) + self.assertTrue(loss.requires_grad) + self.assertTrue(torch.allclose(loss_norm.cpu(), torch.zeros((1,)))) + self.assertTrue(loss_norm.requires_grad) + + loss, loss_norm = chamfer_distance( + p1, p2, weights=weights, batch_reduction="none" + ) + self.assertTrue(torch.allclose(loss.cpu(), torch.zeros((N,)))) + self.assertTrue(loss.requires_grad) + self.assertTrue(torch.allclose(loss_norm.cpu(), torch.zeros((N,)))) + self.assertTrue(loss_norm.requires_grad) + + weights = torch.ones((N,), dtype=torch.float32, device=device) * -1 + with self.assertRaises(ValueError): + loss, loss_norm = chamfer_distance(p1, p2, weights=weights) + + weights = torch.zeros((N - 1,), dtype=torch.float32, device=device) + with self.assertRaises(ValueError): + loss, loss_norm = chamfer_distance(p1, p2, weights=weights) + + @staticmethod + def chamfer_with_init( + batch_size: int, P1: int, P2: int, return_normals: bool + ): + p1, p2, p1_normals, p2_normals, weights = TestChamfer.init_pointclouds( + batch_size, P1, P2 + ) + torch.cuda.synchronize() + + def loss(): + loss, loss_normals = chamfer_distance( + p1, p2, p1_normals, p2_normals, weights=weights + ) + torch.cuda.synchronize() + + return loss + + @staticmethod + def chamfer_naive_with_init( + batch_size: int, P1: int, P2: int, return_normals: bool + ): + p1, p2, p1_normals, p2_normals, weights = TestChamfer.init_pointclouds( + batch_size, P1, P2 + ) + torch.cuda.synchronize() + + def loss(): + loss, loss_normals = TestChamfer.chamfer_distance_naive( + p1, p2, p1_normals, p2_normals + ) + torch.cuda.synchronize() + + return loss diff --git a/tests/test_cubify.py b/tests/test_cubify.py new file mode 100644 index 00000000..fc0397a1 --- /dev/null +++ b/tests/test_cubify.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch + +from pytorch3d.ops import cubify + + +class TestCubify(unittest.TestCase): + def test_allempty(self): + N, V = 32, 14 + device = torch.device("cuda:0") + voxels = torch.zeros((N, V, V, V), dtype=torch.float32, device=device) + meshes = cubify(voxels, 0.5, 0) + self.assertTrue(meshes.isempty) + + def test_cubify(self): + N, V = 4, 2 + device = torch.device("cuda:0") + voxels = torch.zeros((N, V, V, V), dtype=torch.float32, device=device) + + # 1st example: (top left corner, znear) is on + voxels[0, 0, 0, 0] = 1.0 + # 2nd example: all are on + voxels[1] = 1.0 + # 3rd example: empty + # 4th example + voxels[3, :, :, 1] = 1.0 + voxels[3, 1, 1, 0] = 1.0 + + # compute cubify + meshes = cubify(voxels, 0.5, 0) + + # 1st-check + verts, faces = meshes.get_mesh_verts_faces(0) + self.assertTrue( + torch.allclose(faces.max(), torch.tensor([verts.size(0) - 1])) + ) + self.assertTrue( + torch.allclose( + verts, + torch.tensor( + [ + [-1.0, -1.0, -1.0], + [-1.0, -1.0, 1.0], + [1.0, -1.0, -1.0], + [1.0, -1.0, 1.0], + [-1.0, 1.0, -1.0], + [-1.0, 1.0, 1.0], + [1.0, 1.0, -1.0], + [1.0, 1.0, 1.0], + ], + dtype=torch.float32, + device=device, + ), + ) + ) + self.assertTrue( + torch.allclose( + faces, + torch.tensor( + [ + [0, 1, 4], + [1, 5, 4], + [4, 5, 6], + [5, 7, 6], + [0, 4, 6], + [0, 6, 2], + [0, 3, 1], + [0, 2, 3], + [6, 7, 3], + [6, 3, 2], + [1, 7, 5], + [1, 3, 7], + ], + dtype=torch.int64, + device=device, + ), + ) + ) + # 2nd-check + verts, faces = meshes.get_mesh_verts_faces(1) + self.assertTrue( + torch.allclose(faces.max(), torch.tensor([verts.size(0) - 1])) + ) + self.assertTrue( + torch.allclose( + verts, + torch.tensor( + [ + [-1.0, -1.0, -1.0], + [-1.0, -1.0, 1.0], + [-1.0, -1.0, 3.0], + [1.0, -1.0, -1.0], + [1.0, -1.0, 1.0], + [1.0, -1.0, 3.0], + [3.0, -1.0, -1.0], + [3.0, -1.0, 1.0], + [3.0, -1.0, 3.0], + [-1.0, 1.0, -1.0], + [-1.0, 1.0, 1.0], + [-1.0, 1.0, 3.0], + [1.0, 1.0, -1.0], + [1.0, 1.0, 3.0], + [3.0, 1.0, -1.0], + [3.0, 1.0, 1.0], + [3.0, 1.0, 3.0], + [-1.0, 3.0, -1.0], + [-1.0, 3.0, 1.0], + [-1.0, 3.0, 3.0], + [1.0, 3.0, -1.0], + [1.0, 3.0, 1.0], + [1.0, 3.0, 3.0], + [3.0, 3.0, -1.0], + [3.0, 3.0, 1.0], + [3.0, 3.0, 3.0], + ], + dtype=torch.float32, + device=device, + ), + ) + ) + self.assertTrue( + torch.allclose( + faces, + torch.tensor( + [ + [0, 1, 9], + [1, 10, 9], + [0, 9, 12], + [0, 12, 3], + [0, 4, 1], + [0, 3, 4], + [1, 2, 10], + [2, 11, 10], + [1, 5, 2], + [1, 4, 5], + [2, 13, 11], + [2, 5, 13], + [3, 12, 14], + [3, 14, 6], + [3, 7, 4], + [3, 6, 7], + [14, 15, 7], + [14, 7, 6], + [4, 8, 5], + [4, 7, 8], + [15, 16, 8], + [15, 8, 7], + [5, 16, 13], + [5, 8, 16], + [9, 10, 17], + [10, 18, 17], + [17, 18, 20], + [18, 21, 20], + [9, 17, 20], + [9, 20, 12], + [10, 11, 18], + [11, 19, 18], + [18, 19, 21], + [19, 22, 21], + [11, 22, 19], + [11, 13, 22], + [20, 21, 23], + [21, 24, 23], + [12, 20, 23], + [12, 23, 14], + [23, 24, 15], + [23, 15, 14], + [21, 22, 24], + [22, 25, 24], + [24, 25, 16], + [24, 16, 15], + [13, 25, 22], + [13, 16, 25], + ], + dtype=torch.int64, + device=device, + ), + ) + ) + + # 3rd-check + verts, faces = meshes.get_mesh_verts_faces(2) + self.assertTrue(verts.size(0) == 0) + self.assertTrue(faces.size(0) == 0) + + # 4th-check + verts, faces = meshes.get_mesh_verts_faces(3) + self.assertTrue( + torch.allclose( + verts, + torch.tensor( + [ + [1.0, -1.0, -1.0], + [1.0, -1.0, 1.0], + [1.0, -1.0, 3.0], + [3.0, -1.0, -1.0], + [3.0, -1.0, 1.0], + [3.0, -1.0, 3.0], + [-1.0, 1.0, 1.0], + [-1.0, 1.0, 3.0], + [1.0, 1.0, -1.0], + [1.0, 1.0, 1.0], + [1.0, 1.0, 3.0], + [3.0, 1.0, -1.0], + [3.0, 1.0, 1.0], + [3.0, 1.0, 3.0], + [-1.0, 3.0, 1.0], + [-1.0, 3.0, 3.0], + [1.0, 3.0, -1.0], + [1.0, 3.0, 1.0], + [1.0, 3.0, 3.0], + [3.0, 3.0, -1.0], + [3.0, 3.0, 1.0], + [3.0, 3.0, 3.0], + ], + dtype=torch.float32, + device=device, + ), + ) + ) + self.assertTrue( + torch.allclose( + faces, + torch.tensor( + [ + [0, 1, 8], + [1, 9, 8], + [0, 8, 11], + [0, 11, 3], + [0, 4, 1], + [0, 3, 4], + [11, 12, 4], + [11, 4, 3], + [1, 2, 9], + [2, 10, 9], + [1, 5, 2], + [1, 4, 5], + [12, 13, 5], + [12, 5, 4], + [2, 13, 10], + [2, 5, 13], + [6, 7, 14], + [7, 15, 14], + [14, 15, 17], + [15, 18, 17], + [6, 14, 17], + [6, 17, 9], + [6, 10, 7], + [6, 9, 10], + [7, 18, 15], + [7, 10, 18], + [8, 9, 16], + [9, 17, 16], + [16, 17, 19], + [17, 20, 19], + [8, 16, 19], + [8, 19, 11], + [19, 20, 12], + [19, 12, 11], + [17, 18, 20], + [18, 21, 20], + [20, 21, 13], + [20, 13, 12], + [10, 21, 18], + [10, 13, 21], + ], + dtype=torch.int64, + device=device, + ), + ) + ) + + @staticmethod + def cubify_with_init(batch_size: int, V: int): + device = torch.device("cuda:0") + voxels = torch.rand( + (batch_size, V, V, V), dtype=torch.float32, device=device + ) + torch.cuda.synchronize() + + def convert(): + cubify(voxels, 0.5) + torch.cuda.synchronize() + + return convert diff --git a/tests/test_graph_conv.py b/tests/test_graph_conv.py new file mode 100644 index 00000000..3e487828 --- /dev/null +++ b/tests/test_graph_conv.py @@ -0,0 +1,196 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch +import torch.nn as nn + +from pytorch3d import _C +from pytorch3d.ops.graph_conv import ( + GraphConv, + gather_scatter, + gather_scatter_python, +) +from pytorch3d.structures.meshes import Meshes +from pytorch3d.utils import ico_sphere + + +class TestGraphConv(unittest.TestCase): + def test_undirected(self): + dtype = torch.float32 + device = torch.device("cuda:0") + verts = torch.tensor( + [[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=dtype, device=device + ) + edges = torch.tensor([[0, 1], [0, 2]], device=device) + w0 = torch.tensor([[1, 1, 1]], dtype=dtype, device=device) + w1 = torch.tensor([[-1, -1, -1]], dtype=dtype, device=device) + + expected_y = torch.tensor( + [ + [1 + 2 + 3 - 4 - 5 - 6 - 7 - 8 - 9], + [4 + 5 + 6 - 1 - 2 - 3], + [7 + 8 + 9 - 1 - 2 - 3], + ], + dtype=dtype, + device=device, + ) + + conv = GraphConv(3, 1, directed=False).to(device) + conv.w0.weight.data.copy_(w0) + conv.w0.bias.data.zero_() + conv.w1.weight.data.copy_(w1) + conv.w1.bias.data.zero_() + + y = conv(verts, edges) + self.assertTrue(torch.allclose(y, expected_y)) + + def test_no_edges(self): + dtype = torch.float32 + verts = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=dtype) + edges = torch.zeros(0, 2, dtype=torch.int64) + w0 = torch.tensor([[1, -1, -2]], dtype=dtype) + expected_y = torch.tensor( + [[1 - 2 - 2 * 3], [4 - 5 - 2 * 6], [7 - 8 - 2 * 9]], dtype=dtype + ) + conv = GraphConv(3, 1).to(dtype) + conv.w0.weight.data.copy_(w0) + conv.w0.bias.data.zero_() + + y = conv(verts, edges) + self.assertTrue(torch.allclose(y, expected_y)) + + def test_no_verts_and_edges(self): + dtype = torch.float32 + verts = torch.tensor([], dtype=dtype, requires_grad=True) + edges = torch.tensor([], dtype=dtype) + w0 = torch.tensor([[1, -1, -2]], dtype=dtype) + conv = GraphConv(3, 1).to(dtype) + conv.w0.weight.data.copy_(w0) + conv.w0.bias.data.zero_() + + y = conv(verts, edges) + self.assertTrue(torch.allclose(y, torch.tensor([]))) + self.assertTrue(y.requires_grad) + + def test_directed(self): + dtype = torch.float32 + verts = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=dtype) + edges = torch.tensor([[0, 1], [0, 2]]) + w0 = torch.tensor([[1, 1, 1]], dtype=dtype) + w1 = torch.tensor([[-1, -1, -1]], dtype=dtype) + + expected_y = torch.tensor( + [[1 + 2 + 3 - 4 - 5 - 6 - 7 - 8 - 9], [4 + 5 + 6], [7 + 8 + 9]], + dtype=dtype, + ) + + conv = GraphConv(3, 1, directed=True).to(dtype) + conv.w0.weight.data.copy_(w0) + conv.w0.bias.data.zero_() + conv.w1.weight.data.copy_(w1) + conv.w1.bias.data.zero_() + + y = conv(verts, edges) + self.assertTrue(torch.allclose(y, expected_y)) + + def test_backward(self): + device = torch.device("cuda:0") + mesh = ico_sphere() + verts = mesh.verts_packed() + edges = mesh.edges_packed() + verts_cuda = verts.clone().to(device) + edges_cuda = edges.clone().to(device) + verts.requires_grad = True + verts_cuda.requires_grad = True + + neighbor_sums_cuda = gather_scatter(verts_cuda, edges_cuda, False) + neighbor_sums = gather_scatter_python(verts, edges, False) + neighbor_sums_cuda.sum().backward() + neighbor_sums.sum().backward() + + self.assertTrue(torch.allclose(verts.grad.cpu(), verts_cuda.grad.cpu())) + + def test_repr(self): + conv = GraphConv(32, 64, directed=True) + self.assertEqual(repr(conv), "GraphConv(32 -> 64, directed=True)") + + def test_cpu_cuda_tensor_error(self): + device = torch.device("cuda:0") + verts = torch.tensor( + [[1, 2, 3], [4, 5, 6], [7, 8, 9]], + dtype=torch.float32, + device=device, + ) + edges = torch.tensor([[0, 1], [0, 2]]) + conv = GraphConv(3, 1, directed=True).to(torch.float32) + with self.assertRaises(Exception) as err: + conv(verts, edges) + self.assertTrue( + "tensors must be on the same device." in str(err.exception) + ) + + def test_gather_scatter(self): + """ + Check gather_scatter cuda and python versions give the same results. + Check that gather_scatter cuda version throws an error if cpu tensors + are given as input. + """ + device = torch.device("cuda:0") + mesh = ico_sphere() + verts = mesh.verts_packed() + edges = mesh.edges_packed() + w0 = nn.Linear(3, 1) + input = w0(verts) + + # output + output_cpu = gather_scatter_python(input, edges, False) + output_cuda = _C.gather_scatter( + input.to(device=device), edges.to(device=device), False, False + ) + self.assertTrue(torch.allclose(output_cuda.cpu(), output_cpu)) + with self.assertRaises(Exception) as err: + _C.gather_scatter(input.cpu(), edges.cpu(), False, False) + self.assertTrue("Not implemented on the CPU" in str(err.exception)) + + # directed + output_cpu = gather_scatter_python(input, edges, True) + output_cuda = _C.gather_scatter( + input.to(device=device), edges.to(device=device), True, False + ) + self.assertTrue(torch.allclose(output_cuda.cpu(), output_cpu)) + + @staticmethod + def graph_conv_forward_backward( + gconv_dim, + num_meshes, + num_verts, + num_faces, + directed: bool, + backend: str = "cuda", + ): + device = torch.device("cuda") if backend == "cuda" else "cpu" + verts_list = torch.tensor( + num_verts * [[0.11, 0.22, 0.33]], device=device + ).view(-1, 3) + faces_list = torch.tensor(num_faces * [[1, 2, 3]], device=device).view( + -1, 3 + ) + meshes = Meshes(num_meshes * [verts_list], num_meshes * [faces_list]) + gconv = GraphConv(gconv_dim, gconv_dim, directed=directed) + gconv.to(device) + edges = meshes.edges_packed() + total_verts = meshes.verts_packed().shape[0] + + # Features. + x = torch.randn( + total_verts, gconv_dim, device=device, requires_grad=True + ) + torch.cuda.synchronize() + + def run_graph_conv(): + y1 = gconv(x, edges) + y1.sum().backward() + torch.cuda.synchronize() + + return run_graph_conv diff --git a/tests/test_lighting.py b/tests/test_lighting.py new file mode 100644 index 00000000..f401ce06 --- /dev/null +++ b/tests/test_lighting.py @@ -0,0 +1,561 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import numpy as np +import unittest +import torch + +from pytorch3d.renderer.lighting import DirectionalLights, PointLights +from pytorch3d.transforms import RotateAxisAngle + +from common_testing import TestCaseMixin + + +class TestLights(TestCaseMixin, unittest.TestCase): + def test_init_lights(self): + """ + Initialize Lights class with the default values. + """ + device = torch.device("cuda:0") + light = DirectionalLights(device=device) + keys = ["ambient_color", "diffuse_color", "specular_color", "direction"] + for k in keys: + prop = getattr(light, k) + self.assertTrue(torch.is_tensor(prop)) + self.assertTrue(prop.device == device) + self.assertTrue(prop.shape == (1, 3)) + + light = PointLights(device=device) + keys = ["ambient_color", "diffuse_color", "specular_color", "location"] + for k in keys: + prop = getattr(light, k) + self.assertTrue(torch.is_tensor(prop)) + self.assertTrue(prop.device == device) + self.assertTrue(prop.shape == (1, 3)) + + def test_lights_clone_to(self): + device = torch.device("cuda:0") + cpu = torch.device("cpu") + light = DirectionalLights() + new_light = light.clone().to(device) + keys = ["ambient_color", "diffuse_color", "specular_color", "direction"] + for k in keys: + prop = getattr(light, k) + new_prop = getattr(new_light, k) + self.assertTrue(prop.device == cpu) + self.assertTrue(new_prop.device == device) + self.assertSeparate(new_prop, prop) + + light = PointLights() + new_light = light.clone().to(device) + keys = ["ambient_color", "diffuse_color", "specular_color", "location"] + for k in keys: + prop = getattr(light, k) + new_prop = getattr(new_light, k) + self.assertTrue(prop.device == cpu) + self.assertTrue(new_prop.device == device) + self.assertSeparate(new_prop, prop) + + def test_lights_accessor(self): + d_light = DirectionalLights( + ambient_color=((0.0, 0.0, 0.0), (1.0, 1.0, 1.0)) + ) + p_light = PointLights(ambient_color=((0.0, 0.0, 0.0), (1.0, 1.0, 1.0))) + for light in [d_light, p_light]: + # Update element + color = (0.5, 0.5, 0.5) + light[1].ambient_color = color + self.assertTrue( + torch.allclose(light.ambient_color[1], torch.tensor(color)) + ) + # Get item and get value + l0 = light[0] + self.assertTrue( + torch.allclose(l0.ambient_color, torch.tensor((0.0, 0.0, 0.0))) + ) + + def test_initialize_lights_broadcast(self): + light = DirectionalLights( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(1, 3), + specular_color=torch.randn(1, 3), + ) + keys = ["ambient_color", "diffuse_color", "specular_color", "direction"] + for k in keys: + prop = getattr(light, k) + self.assertTrue(prop.shape == (10, 3)) + + light = PointLights( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(1, 3), + specular_color=torch.randn(1, 3), + ) + keys = ["ambient_color", "diffuse_color", "specular_color", "location"] + for k in keys: + prop = getattr(light, k) + self.assertTrue(prop.shape == (10, 3)) + + def test_initialize_lights_broadcast_fail(self): + """ + Batch dims have to be the same or 1. + """ + with self.assertRaises(ValueError): + DirectionalLights( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(15, 3), + ) + + with self.assertRaises(ValueError): + PointLights( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(15, 3), + ) + + def test_initialize_lights_dimensions_fail(self): + """ + Color should have shape (N, 3) or (1, 3) + """ + with self.assertRaises(ValueError): + DirectionalLights(ambient_color=torch.randn(10, 4)) + + with self.assertRaises(ValueError): + DirectionalLights(direction=torch.randn(10, 4)) + + with self.assertRaises(ValueError): + PointLights(ambient_color=torch.randn(10, 4)) + + with self.assertRaises(ValueError): + PointLights(location=torch.randn(10, 4)) + + +class TestDiffuseLighting(unittest.TestCase): + def test_diffuse_directional_lights(self): + """ + Test with a single point where: + 1) the normal and light direction are 45 degrees apart. + 2) the normal and light direction are 90 degrees apart. The output + should be zero for this case + """ + color = torch.tensor([1, 1, 1], dtype=torch.float32) + direction = torch.tensor( + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=torch.float32 + ) + normals = torch.tensor([0, 0, 1], dtype=torch.float32) + normals = normals[None, None, :] + expected_output = torch.tensor( + [1 / np.sqrt(2), 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + ) + expected_output = expected_output.view(-1, 1, 3) + light = DirectionalLights(diffuse_color=color, direction=direction) + output_light = light.diffuse(normals=normals) + self.assertTrue(torch.allclose(output_light, expected_output)) + + # Change light direction to be 90 degrees apart from normal direction. + direction = torch.tensor([0, 1, 0], dtype=torch.float32) + light.direction = direction + expected_output = torch.zeros_like(expected_output) + output_light = light.diffuse(normals=normals) + self.assertTrue(torch.allclose(output_light, expected_output)) + + def test_diffuse_point_lights(self): + """ + Test with a single point at the origin. Test two cases: + 1) the point light is at (1, 0, 1) hence the light direction is 45 + degrees apart from the normal direction + 1) the point light is at (0, 1, 0) hence the light direction is 90 + degrees apart from the normal direction. The output + should be zero for this case + """ + color = torch.tensor([1, 1, 1], dtype=torch.float32) + location = torch.tensor( + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32) + normals = torch.tensor([0, 0, 1], dtype=torch.float32) + expected_output = torch.tensor( + [1 / np.sqrt(2), 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + ) + expected_output = expected_output.view(-1, 1, 3) + light = PointLights( + diffuse_color=color[None, :], location=location[None, :] + ) + output_light = light.diffuse( + points=points[None, None, :], normals=normals[None, None, :] + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + # Change light direction to be 90 degrees apart from normal direction. + location = torch.tensor([0, 1, 0], dtype=torch.float32) + expected_output = torch.zeros_like(expected_output) + light = PointLights( + diffuse_color=color[None, :], location=location[None, :] + ) + output_light = light.diffuse( + points=points[None, None, :], normals=normals[None, None, :] + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + def test_diffuse_batched(self): + """ + Test with a batch where each batch element has one point + where the normal and light direction are 45 degrees apart. + """ + batch_size = 10 + color = torch.tensor([1, 1, 1], dtype=torch.float32) + direction = torch.tensor( + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=torch.float32 + ) + normals = torch.tensor([0, 0, 1], dtype=torch.float32) + expected_out = torch.tensor( + [1 / np.sqrt(2), 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + ) + + # Reshape + direction = direction.view(-1, 3).expand(batch_size, -1) + normals = normals.view(-1, 1, 3).expand(batch_size, -1, -1) + color = color.view(-1, 3).expand(batch_size, -1) + expected_out = expected_out.view(-1, 1, 3).expand(batch_size, 1, 3) + + lights = DirectionalLights(diffuse_color=color, direction=direction) + output_light = lights.diffuse(normals=normals) + self.assertTrue(torch.allclose(output_light, expected_out)) + + def test_diffuse_batched_broadcast_inputs(self): + """ + Test with a batch where each batch element has one point + where the normal and light direction are 45 degrees apart. + The color and direction are the same for each batch element. + """ + batch_size = 10 + color = torch.tensor([1, 1, 1], dtype=torch.float32) + direction = torch.tensor( + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], dtype=torch.float32 + ) + normals = torch.tensor([0, 0, 1], dtype=torch.float32) + expected_out = torch.tensor( + [1 / np.sqrt(2), 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + ) + + # Reshape + normals = normals.view(-1, 1, 3).expand(batch_size, -1, -1) + expected_out = expected_out.view(-1, 1, 3).expand(batch_size, 1, 3) + + # Don't expand the direction or color. Broadcasting should happen + # in the diffuse function. + direction = direction.view(1, 3) + color = color.view(1, 3) + + lights = DirectionalLights(diffuse_color=color, direction=direction) + output_light = lights.diffuse(normals=normals) + self.assertTrue(torch.allclose(output_light, expected_out)) + + def test_diffuse_batched_arbitrary_input_dims(self): + """ + Test with a batch of inputs where shape of the input is mimicking the + shape in a shading function i.e. an interpolated normal per pixel for + top K faces per pixel. + """ + N, H, W, K = 16, 256, 256, 100 + device = torch.device("cuda:0") + color = torch.tensor([1, 1, 1], dtype=torch.float32, device=device) + direction = torch.tensor( + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + device=device, + ) + normals = torch.tensor([0, 0, 1], dtype=torch.float32, device=device) + normals = normals.view(1, 1, 1, 1, 3).expand(N, H, W, K, -1) + direction = direction.view(1, 3) + color = color.view(1, 3) + expected_output = torch.tensor( + [1 / np.sqrt(2), 1 / np.sqrt(2), 1 / np.sqrt(2)], + dtype=torch.float32, + device=device, + ) + expected_output = expected_output.view(1, 1, 1, 1, 3) + expected_output = expected_output.expand(N, H, W, K, -1) + + lights = DirectionalLights(diffuse_color=color, direction=direction) + output_light = lights.diffuse(normals=normals) + self.assertTrue(torch.allclose(output_light, expected_output)) + + def test_diffuse_batched_packed(self): + """ + Test with a batch of 2 meshes each of which has faces on a single plane. + The normal and light direction are 45 degrees apart for the first mesh + and 90 degrees apart for the second mesh. + + The points and normals are in the packed format i.e. no batch dimension. + """ + verts_packed = torch.rand((10, 3)) # points aren't used + faces_per_mesh = [6, 4] + mesh_to_vert_idx = [0] * faces_per_mesh[0] + [1] * faces_per_mesh[1] + mesh_to_vert_idx = torch.tensor(mesh_to_vert_idx, dtype=torch.int64) + color = torch.tensor([[1, 1, 1], [1, 1, 1]], dtype=torch.float32) + direction = torch.tensor( + [ + [0, 1 / np.sqrt(2), 1 / np.sqrt(2)], + [0, 1, 0], # 90 degrees to normal so zero diffuse light + ], + dtype=torch.float32, + ) + normals = torch.tensor([[0, 0, 1], [0, 0, 1]], dtype=torch.float32) + expected_output = torch.zeros_like(verts_packed, dtype=torch.float32) + expected_output[:6, :] += 1 / np.sqrt(2) + expected_output[6:, :] = 0.0 + lights = DirectionalLights( + diffuse_color=color[mesh_to_vert_idx, :], + direction=direction[mesh_to_vert_idx, :], + ) + output_light = lights.diffuse(normals=normals[mesh_to_vert_idx, :]) + self.assertTrue(torch.allclose(output_light, expected_output)) + + +class TestSpecularLighting(unittest.TestCase): + def test_specular_directional_lights(self): + """ + Specular highlights depend on the camera position as well as the light + position/direction. + Test with a single point where: + 1) the normal and light direction are -45 degrees apart and the normal + and camera position are +45 degrees apart. The reflected light ray + will be perfectly aligned with the camera so the output is 1.0. + 2) the normal and light direction are -45 degrees apart and the + camera position is behind the point. The output should be zero for + this case. + """ + color = torch.tensor([1, 0, 1], dtype=torch.float32) + direction = torch.tensor( + [-1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32) + normals = torch.tensor([0, 1, 0], dtype=torch.float32) + expected_output = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32) + expected_output = expected_output.view(-1, 1, 3) + lights = DirectionalLights(specular_color=color, direction=direction) + output_light = lights.specular( + points=points[None, None, :], + normals=normals[None, None, :], + camera_position=camera_position[None, :], + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + # Change camera position to be behind the point. + camera_position = torch.tensor( + [+1 / np.sqrt(2), -1 / np.sqrt(2), 0], dtype=torch.float32 + ) + expected_output = torch.zeros_like(expected_output) + output_light = lights.specular( + points=points[None, None, :], + normals=normals[None, None, :], + camera_position=camera_position[None, :], + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + def test_specular_point_lights(self): + """ + Replace directional lights with point lights and check the output + is the same. + + Test an additional case where the angle between the light reflection + direction and the view direction is 30 degrees. + """ + color = torch.tensor([1, 0, 1], dtype=torch.float32) + location = torch.tensor([-1, 1, 0], dtype=torch.float32) + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32) + normals = torch.tensor([0, 1, 0], dtype=torch.float32) + expected_output = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32) + expected_output = expected_output.view(-1, 1, 3) + lights = PointLights( + specular_color=color[None, :], location=location[None, :] + ) + output_light = lights.specular( + points=points[None, None, :], + normals=normals[None, None, :], + camera_position=camera_position[None, :], + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + # Change camera position to be behind the point + camera_position = torch.tensor( + [+1 / np.sqrt(2), -1 / np.sqrt(2), 0], dtype=torch.float32 + ) + expected_output = torch.zeros_like(expected_output) + output_light = lights.specular( + points=points[None, None, :], + normals=normals[None, None, :], + camera_position=camera_position[None, :], + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + # Change camera direction to be 30 degrees from the reflection direction + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + rotate_30 = RotateAxisAngle(-30, axis="z") + camera_position = rotate_30.transform_points(camera_position[None, :]) + expected_output = torch.tensor( + [np.cos(30.0 * np.pi / 180), 0.0, np.cos(30.0 * np.pi / 180)], + dtype=torch.float32, + ) + expected_output = expected_output.view(-1, 1, 3) + output_light = lights.specular( + points=points[None, None, :], + normals=normals[None, None, :], + camera_position=camera_position[None, :], + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_output ** 10)) + + def test_specular_batched(self): + batch_size = 10 + color = torch.tensor([1, 0, 1], dtype=torch.float32) + direction = torch.tensor( + [-1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32) + normals = torch.tensor([0, 1, 0], dtype=torch.float32) + expected_out = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32) + + # Reshape + direction = direction.view(1, 3).expand(batch_size, -1) + camera_position = camera_position.view(1, 3).expand(batch_size, -1) + normals = normals.view(1, 1, 3).expand(batch_size, -1, -1) + points = points.view(1, 1, 3).expand(batch_size, -1, -1) + color = color.view(1, 3).expand(batch_size, -1) + expected_out = expected_out.view(1, 1, 3).expand(batch_size, 1, 3) + + lights = DirectionalLights(specular_color=color, direction=direction) + output_light = lights.specular( + points=points, + normals=normals, + camera_position=camera_position, + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_out)) + + def test_specular_batched_broadcast_inputs(self): + batch_size = 10 + color = torch.tensor([1, 0, 1], dtype=torch.float32) + direction = torch.tensor( + [-1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32) + normals = torch.tensor([0, 1, 0], dtype=torch.float32) + expected_out = torch.tensor([1.0, 0.0, 1.0], dtype=torch.float32) + + # Reshape + normals = normals.view(1, 1, 3).expand(batch_size, -1, -1) + points = points.view(1, 1, 3).expand(batch_size, -1, -1) + expected_out = expected_out.view(1, 1, 3).expand(batch_size, 1, 3) + + # Don't expand the direction, color or camera_position. + # These should be broadcasted in the specular function + direction = direction.view(1, 3) + camera_position = camera_position.view(1, 3) + color = color.view(1, 3) + + lights = DirectionalLights(specular_color=color, direction=direction) + output_light = lights.specular( + points=points, + normals=normals, + camera_position=camera_position, + shininess=torch.tensor(10), + ) + self.assertTrue(torch.allclose(output_light, expected_out)) + + def test_specular_batched_arbitrary_input_dims(self): + """ + Test with a batch of inputs where shape of the input is mimicking the + shape expected after rasterization i.e. a normal per pixel for + top K faces per pixel. + """ + device = torch.device("cuda:0") + N, H, W, K = 16, 256, 256, 100 + color = torch.tensor([1, 0, 1], dtype=torch.float32, device=device) + direction = torch.tensor( + [-1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + camera_position = torch.tensor( + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], dtype=torch.float32 + ) + points = torch.tensor([0, 0, 0], dtype=torch.float32, device=device) + normals = torch.tensor([0, 1, 0], dtype=torch.float32, device=device) + points = points.view(1, 1, 1, 1, 3).expand(N, H, W, K, 3) + normals = normals.view(1, 1, 1, 1, 3).expand(N, H, W, K, 3) + + direction = direction.view(1, 3) + color = color.view(1, 3) + camera_position = camera_position.view(1, 3) + + expected_output = torch.tensor( + [1.0, 0.0, 1.0], dtype=torch.float32, device=device + ) + expected_output = expected_output.view(-1, 1, 1, 1, 3) + expected_output = expected_output.expand(N, H, W, K, -1) + + lights = DirectionalLights(specular_color=color, direction=direction) + output_light = lights.specular( + points=points, + normals=normals, + camera_position=camera_position, + shininess=10.0, + ) + self.assertTrue(torch.allclose(output_light, expected_output)) + + def test_specular_batched_packed(self): + """ + Test with a batch of 2 meshes each of which has faces on a single plane. + The points and normals are in the packed format i.e. no batch dimension. + """ + faces_per_mesh = [6, 4] + mesh_to_vert_idx = [0] * faces_per_mesh[0] + [1] * faces_per_mesh[1] + mesh_to_vert_idx = torch.tensor(mesh_to_vert_idx, dtype=torch.int64) + color = torch.tensor([[1, 1, 1], [1, 0, 1]], dtype=torch.float32) + direction = torch.tensor( + [[-1 / np.sqrt(2), 1 / np.sqrt(2), 0], [-1, 1, 0]], + dtype=torch.float32, + ) + camera_position = torch.tensor( + [ + [+1 / np.sqrt(2), 1 / np.sqrt(2), 0], + [+1 / np.sqrt(2), -1 / np.sqrt(2), 0], + ], + dtype=torch.float32, + ) + points = torch.tensor([[0, 0, 0]], dtype=torch.float32) + normals = torch.tensor([[0, 1, 0], [0, 1, 0]], dtype=torch.float32) + expected_output = torch.zeros((10, 3), dtype=torch.float32) + expected_output[:6, :] += 1.0 + + lights = DirectionalLights( + specular_color=color[mesh_to_vert_idx, :], + direction=direction[mesh_to_vert_idx, :], + ) + output_light = lights.specular( + points=points.view(-1, 3).expand(10, -1), + normals=normals.view(-1, 3)[mesh_to_vert_idx, :], + camera_position=camera_position[mesh_to_vert_idx, :], + shininess=10.0, + ) + self.assertTrue(torch.allclose(output_light, expected_output)) diff --git a/tests/test_materials.py b/tests/test_materials.py new file mode 100644 index 00000000..21a2a38b --- /dev/null +++ b/tests/test_materials.py @@ -0,0 +1,97 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch + +from pytorch3d.renderer.materials import Materials + +from common_testing import TestCaseMixin + + +class TestMaterials(TestCaseMixin, unittest.TestCase): + def test_init(self): + """ + Initialize Materials class with the default values. + """ + device = torch.device("cuda:0") + mat = Materials(device=device) + self.assertTrue(torch.is_tensor(mat.ambient_color)) + self.assertTrue(torch.is_tensor(mat.diffuse_color)) + self.assertTrue(torch.is_tensor(mat.specular_color)) + self.assertTrue(torch.is_tensor(mat.shininess)) + self.assertTrue(mat.ambient_color.device == device) + self.assertTrue(mat.diffuse_color.device == device) + self.assertTrue(mat.specular_color.device == device) + self.assertTrue(mat.shininess.device == device) + self.assertTrue(mat.ambient_color.shape == (1, 3)) + self.assertTrue(mat.diffuse_color.shape == (1, 3)) + self.assertTrue(mat.specular_color.shape == (1, 3)) + self.assertTrue(mat.shininess.shape == (1,)) + + def test_materials_clone_to(self): + device = torch.device("cuda:0") + cpu = torch.device("cpu") + mat = Materials() + new_mat = mat.clone().to(device) + self.assertTrue(mat.ambient_color.device == cpu) + self.assertTrue(mat.diffuse_color.device == cpu) + self.assertTrue(mat.specular_color.device == cpu) + self.assertTrue(mat.shininess.device == cpu) + self.assertTrue(new_mat.ambient_color.device == device) + self.assertTrue(new_mat.diffuse_color.device == device) + self.assertTrue(new_mat.specular_color.device == device) + self.assertTrue(new_mat.shininess.device == device) + self.assertSeparate(new_mat.ambient_color, mat.ambient_color) + self.assertSeparate(new_mat.diffuse_color, mat.diffuse_color) + self.assertSeparate(new_mat.specular_color, mat.specular_color) + self.assertSeparate(new_mat.shininess, mat.shininess) + + def test_initialize_materials_broadcast(self): + materials = Materials( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(1, 3), + specular_color=torch.randn(1, 3), + shininess=torch.randn(1), + ) + self.assertTrue(materials.ambient_color.shape == (10, 3)) + self.assertTrue(materials.diffuse_color.shape == (10, 3)) + self.assertTrue(materials.specular_color.shape == (10, 3)) + self.assertTrue(materials.shininess.shape == (10,)) + + def test_initialize_materials_broadcast_fail(self): + """ + Batch dims have to be the same or 1. + """ + with self.assertRaises(ValueError): + Materials( + ambient_color=torch.randn(10, 3), + diffuse_color=torch.randn(15, 3), + ) + + def test_initialize_materials_dimensions_fail(self): + """ + Color should have shape (N, 3) or (1, 3), Shininess should have shape + (1), (1, 1), (N) or (N, 1) + """ + with self.assertRaises(ValueError): + Materials(ambient_color=torch.randn(10, 4)) + + with self.assertRaises(ValueError): + Materials(shininess=torch.randn(10, 2)) + + def test_initialize_materials_mixed_inputs(self): + mat = Materials( + ambient_color=torch.randn(1, 3), diffuse_color=((1, 1, 1),) + ) + self.assertTrue(mat.ambient_color.shape == (1, 3)) + self.assertTrue(mat.diffuse_color.shape == (1, 3)) + + def test_initialize_materials_mixed_inputs_broadcast(self): + mat = Materials( + ambient_color=torch.randn(10, 3), diffuse_color=((1, 1, 1),) + ) + self.assertTrue(mat.ambient_color.shape == (10, 3)) + self.assertTrue(mat.diffuse_color.shape == (10, 3)) + self.assertTrue(mat.specular_color.shape == (10, 3)) + self.assertTrue(mat.shininess.shape == (10,)) diff --git a/tests/test_mesh_edge_loss.py b/tests/test_mesh_edge_loss.py new file mode 100644 index 00000000..cf44224a --- /dev/null +++ b/tests/test_mesh_edge_loss.py @@ -0,0 +1,113 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch + +from pytorch3d.loss import mesh_edge_loss +from pytorch3d.structures import Meshes + +from test_sample_points_from_meshes import TestSamplePoints + + +class TestMeshEdgeLoss(unittest.TestCase): + def test_empty_meshes(self): + device = torch.device("cuda:0") + target_length = 0 + N = 10 + V = 32 + verts_list = [] + faces_list = [] + for _ in range(N): + vn = torch.randint(3, high=V, size=(1,))[0].item() + verts = torch.rand((vn, 3), dtype=torch.float32, device=device) + faces = torch.tensor([], dtype=torch.int64, device=device) + verts_list.append(verts) + faces_list.append(faces) + mesh = Meshes(verts=verts_list, faces=faces_list) + loss = mesh_edge_loss(mesh, target_length=target_length) + + self.assertTrue( + torch.allclose( + loss, torch.tensor([0.0], dtype=torch.float32, device=device) + ) + ) + self.assertTrue(loss.requires_grad) + + @staticmethod + def mesh_edge_loss_naive(meshes, target_length: float = 0.0): + """ + Naive iterative implementation of mesh loss calculation. + """ + edges_packed = meshes.edges_packed() + verts_packed = meshes.verts_packed() + edge_to_mesh = meshes.edges_packed_to_mesh_idx() + N = len(meshes) + device = meshes.device + valid = meshes.valid + predlosses = torch.zeros((N,), dtype=torch.float32, device=device) + + for b in range(N): + if valid[b] == 0: + continue + mesh_edges = edges_packed[edge_to_mesh == b] + verts_edges = verts_packed[mesh_edges] + num_edges = mesh_edges.size(0) + for e in range(num_edges): + v0, v1 = verts_edges[e, 0], verts_edges[e, 1] + predlosses[b] += ( + (v0 - v1).norm(dim=0, p=2) - target_length + ) ** 2.0 + + if num_edges > 0: + predlosses[b] = predlosses[b] / num_edges + + return predlosses.mean() + + def test_mesh_edge_loss_output(self): + """ + Check outputs of tensorized and iterative implementations are the same. + """ + device = torch.device("cuda:0") + target_length = 0.5 + num_meshes = 10 + num_verts = 32 + num_faces = 64 + + verts_list = [] + faces_list = [] + valid = torch.randint(2, size=(num_meshes,)) + + for n in range(num_meshes): + if valid[n]: + vn = torch.randint(3, high=num_verts, size=(1,))[0].item() + fn = torch.randint(vn, high=num_faces, size=(1,))[0].item() + verts = torch.rand((vn, 3), dtype=torch.float32, device=device) + faces = torch.randint( + vn, size=(fn, 3), dtype=torch.int64, device=device + ) + else: + verts = torch.tensor([], dtype=torch.float32, device=device) + faces = torch.tensor([], dtype=torch.int64, device=device) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts=verts_list, faces=faces_list) + loss = mesh_edge_loss(meshes, target_length=target_length) + + predloss = TestMeshEdgeLoss.mesh_edge_loss_naive(meshes, target_length) + self.assertTrue(torch.allclose(loss, predloss)) + + @staticmethod + def mesh_edge_loss( + num_meshes: int = 10, max_v: int = 100, max_f: int = 300 + ): + meshes = TestSamplePoints.init_meshes( + num_meshes, max_v, max_f, device="cuda:0" + ) + torch.cuda.synchronize() + + def compute_loss(): + mesh_edge_loss(meshes, target_length=0.0) + torch.cuda.synchronize() + + return compute_loss diff --git a/tests/test_mesh_laplacian_smoothing.py b/tests/test_mesh_laplacian_smoothing.py new file mode 100644 index 00000000..34badc27 --- /dev/null +++ b/tests/test_mesh_laplacian_smoothing.py @@ -0,0 +1,209 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +import unittest +import torch + +from pytorch3d.loss.mesh_laplacian_smoothing import mesh_laplacian_smoothing +from pytorch3d.structures.meshes import Meshes + + +class TestLaplacianSmoothing(unittest.TestCase): + @staticmethod + def laplacian_smoothing_naive_uniform(meshes): + """ + Naive implementation of laplacian smoothing with uniform weights. + """ + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + faces_packed = meshes.faces_packed() # (sum(F_n), 3) + V = verts_packed.shape[0] + + L = torch.zeros((V, V), dtype=torch.float32, device=meshes.device) + + # filling L with the face pairs should be the same as edge pairs + for f in faces_packed: + L[f[0], f[1]] = 1 + L[f[0], f[2]] = 1 + L[f[1], f[2]] = 1 + # symetric + L[f[1], f[0]] = 1 + L[f[2], f[0]] = 1 + L[f[2], f[1]] = 1 + + norm_w = L.sum(dim=1, keepdims=True) + idx = norm_w > 0 + norm_w[idx] = 1.0 / norm_w[idx] + + loss = (L.mm(verts_packed) * norm_w - verts_packed).norm(dim=1) + + weights = torch.zeros(V, dtype=torch.float32, device=meshes.device) + for v in range(V): + weights[v] = meshes.num_verts_per_mesh()[ + meshes.verts_packed_to_mesh_idx()[v] + ] + weights = 1.0 / weights + loss = loss * weights + + return loss.sum() / len(meshes) + + @staticmethod + def laplacian_smoothing_naive_cot(meshes, method: str = "cot"): + """ + Naive implementation of laplacian smoothing wit cotangent weights. + """ + verts_packed = meshes.verts_packed() # (sum(V_n), 3) + faces_packed = meshes.faces_packed() # (sum(F_n), 3) + V = verts_packed.shape[0] + + L = torch.zeros((V, V), dtype=torch.float32, device=meshes.device) + inv_areas = torch.zeros( + (V, 1), dtype=torch.float32, device=meshes.device + ) + + for f in faces_packed: + v0 = verts_packed[f[0], :] + v1 = verts_packed[f[1], :] + v2 = verts_packed[f[2], :] + A = (v1 - v2).norm() + B = (v0 - v2).norm() + C = (v0 - v1).norm() + s = 0.5 * (A + B + C) + + face_area = ( + (s * (s - A) * (s - B) * (s - C)).clamp_(min=1e-12).sqrt() + ) + inv_areas[f[0]] += face_area + inv_areas[f[1]] += face_area + inv_areas[f[2]] += face_area + + A2, B2, C2 = A * A, B * B, C * C + cota = (B2 + C2 - A2) / face_area / 4.0 + cotb = (A2 + C2 - B2) / face_area / 4.0 + cotc = (A2 + B2 - C2) / face_area / 4.0 + + L[f[1], f[2]] += cota + L[f[2], f[0]] += cotb + L[f[0], f[1]] += cotc + # symetric + L[f[2], f[1]] += cota + L[f[0], f[2]] += cotb + L[f[1], f[0]] += cotc + + idx = inv_areas > 0 + inv_areas[idx] = 1.0 / inv_areas[idx] + + norm_w = L.sum(dim=1, keepdims=True) + idx = norm_w > 0 + norm_w[idx] = 1.0 / norm_w[idx] + + if method == "cotcurv": + loss = (L.mm(verts_packed) - verts_packed) * inv_areas * 0.25 + loss = loss.norm(dim=1) + else: + loss = L.mm(verts_packed) * norm_w - verts_packed + loss = loss.norm(dim=1) + + weights = torch.zeros(V, dtype=torch.float32, device=meshes.device) + for v in range(V): + weights[v] = meshes.num_verts_per_mesh()[ + meshes.verts_packed_to_mesh_idx()[v] + ] + weights = 1.0 / weights + loss = loss * weights + + return loss.sum() / len(meshes) + + @staticmethod + def init_meshes( + num_meshes: int = 10, num_verts: int = 1000, num_faces: int = 3000 + ): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = ( + torch.rand((num_verts, 3), dtype=torch.float32, device=device) + * 2.0 + - 1.0 + ) # verts in the space of [-1, 1] + faces = torch.stack( + [ + torch.randperm(num_verts, device=device)[:3] + for _ in range(num_faces) + ], + dim=0, + ) + # avoids duplicate vertices in a face + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + + return meshes + + def test_laplacian_smoothing_uniform(self): + """ + Test Laplacian Smoothing with uniform weights. + """ + meshes = TestLaplacianSmoothing.init_meshes(10, 100, 300) + + # feats in list + out = mesh_laplacian_smoothing(meshes, method="uniform") + naive_out = TestLaplacianSmoothing.laplacian_smoothing_naive_uniform( + meshes + ) + + self.assertTrue(torch.allclose(out, naive_out)) + + def test_laplacian_smoothing_cot(self): + """ + Test Laplacian Smoothing with uniform weights. + """ + meshes = TestLaplacianSmoothing.init_meshes(10, 100, 300) + + # feats in list + out = mesh_laplacian_smoothing(meshes, method="cot") + naive_out = TestLaplacianSmoothing.laplacian_smoothing_naive_cot( + meshes, method="cot" + ) + + self.assertTrue(torch.allclose(out, naive_out)) + + def test_laplacian_smoothing_cotcurv(self): + """ + Test Laplacian Smoothing with uniform weights. + """ + meshes = TestLaplacianSmoothing.init_meshes(10, 100, 300) + + # feats in list + out = mesh_laplacian_smoothing(meshes, method="cotcurv") + naive_out = TestLaplacianSmoothing.laplacian_smoothing_naive_cot( + meshes, method="cotcurv" + ) + + self.assertTrue(torch.allclose(out, naive_out)) + + @staticmethod + def laplacian_smoothing_with_init( + num_meshes: int, num_verts: int, num_faces: int, device: str = "cpu" + ): + device = torch.device(device) + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = torch.rand( + (num_verts, 3), dtype=torch.float32, device=device + ) + faces = torch.randint( + num_verts, size=(num_faces, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + torch.cuda.synchronize() + + def smooth(): + mesh_laplacian_smoothing(meshes, method="cotcurv") + torch.cuda.synchronize() + + return smooth diff --git a/tests/test_mesh_normal_consistency.py b/tests/test_mesh_normal_consistency.py new file mode 100644 index 00000000..c4c1a26f --- /dev/null +++ b/tests/test_mesh_normal_consistency.py @@ -0,0 +1,244 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +import unittest +import torch + +from pytorch3d.loss.mesh_normal_consistency import mesh_normal_consistency +from pytorch3d.structures.meshes import Meshes +from pytorch3d.utils.ico_sphere import ico_sphere + + +class TestMeshNormalConsistency(unittest.TestCase): + @staticmethod + def init_faces(num_verts: int = 1000): + faces = [] + for f0 in range(num_verts): + for f1 in range(f0 + 1, num_verts): + f2 = torch.arange(f1 + 1, num_verts) + n = f2.shape[0] + if n == 0: + continue + faces.append( + torch.stack( + [ + torch.full((n,), f0, dtype=torch.int64), + torch.full((n,), f1, dtype=torch.int64), + f2, + ], + dim=1, + ) + ) + faces = torch.cat(faces, 0) + return faces + + @staticmethod + def init_meshes( + num_meshes: int = 10, num_verts: int = 1000, num_faces: int = 3000 + ): + device = torch.device("cuda:0") + valid_faces = TestMeshNormalConsistency.init_faces(num_verts).to(device) + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = ( + torch.rand((num_verts, 3), dtype=torch.float32, device=device) + * 2.0 + - 1.0 + ) # verts in the space of [-1, 1] + """ + faces = torch.stack( + [ + torch.randperm(num_verts, device=device)[:3] + for _ in range(num_faces) + ], + dim=0, + ) + # avoids duplicate vertices in a face + """ + idx = torch.randperm(valid_faces.shape[0], device=device)[ + : min(valid_faces.shape[0], num_faces) + ] + faces = valid_faces[idx] + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + return meshes + + @staticmethod + def mesh_normal_consistency_naive(meshes): + """ + Naive iterative implementation of mesh normal consistency. + """ + N = len(meshes) + verts_packed = meshes.verts_packed() + faces_packed = meshes.faces_packed() + edges_packed = meshes.edges_packed() + face_to_edge = meshes.faces_packed_to_edges_packed() + edges_packed_to_mesh_idx = meshes.edges_packed_to_mesh_idx() + + E = edges_packed.shape[0] + loss = [] + mesh_idx = [] + + for e in range(E): + face_idx = face_to_edge.eq(e).any(1).nonzero() # indexed to faces + v0 = verts_packed[edges_packed[e, 0]] + v1 = verts_packed[edges_packed[e, 1]] + normals = [] + for f in face_idx: + v2 = -1 + for j in range(3): + if ( + faces_packed[f, j] != edges_packed[e, 0] + and faces_packed[f, j] != edges_packed[e, 1] + ): + v2 = faces_packed[f, j] + assert v2 > -1 + v2 = verts_packed[v2] + normals.append((v1 - v0).view(-1).cross((v2 - v0).view(-1))) + for i in range(len(normals) - 1): + for j in range(1, len(normals)): + if i != j: + mesh_idx.append(edges_packed_to_mesh_idx[e]) + loss.append( + ( + 1 + - torch.cosine_similarity( + normals[i].view(1, 3), + -normals[j].view(1, 3), + ) + ) + ) + + mesh_idx = torch.tensor(mesh_idx, device=meshes.device) + num = mesh_idx.bincount(minlength=N) + weights = 1.0 / num[mesh_idx].float() + + loss = torch.cat(loss) * weights + return loss.sum() / N + + def test_mesh_normal_consistency_simple(self): + r""" + Mesh 1: + v3 + /\ + / \ + e4 / f1 \ e3 + / \ + v2 /___e2___\ v1 + \ / + \ / + e1 \ f0 / e0 + \ / + \/ + v0 + """ + device = torch.device("cuda:0") + # mesh1 shown above + verts1 = torch.rand((4, 3), dtype=torch.float32, device=device) + faces1 = torch.tensor( + [[0, 1, 2], [2, 1, 3]], dtype=torch.int64, device=device + ) + + # mesh2 is a cuboid with 8 verts, 12 faces and 18 edges + verts2 = torch.tensor( + [ + [0, 0, 0], + [0, 0, 1], + [0, 1, 0], + [0, 1, 1], + [1, 0, 0], + [1, 0, 1], + [1, 1, 0], + [1, 1, 1], + ], + dtype=torch.float32, + device=device, + ) + faces2 = torch.tensor( + [ + [0, 1, 2], + [1, 3, 2], # left face: 0, 1 + [2, 3, 6], + [3, 7, 6], # bottom face: 2, 3 + [0, 2, 6], + [0, 6, 4], # front face: 4, 5 + [0, 5, 1], + [0, 4, 5], # up face: 6, 7 + [6, 7, 5], + [6, 5, 4], # right face: 8, 9 + [1, 7, 3], + [1, 5, 7], # back face: 10, 11 + ], + dtype=torch.int64, + device=device, + ) + + # mesh3 is like mesh1 but with another face added to e2 + verts3 = torch.rand((5, 3), dtype=torch.float32, device=device) + faces3 = torch.tensor( + [[0, 1, 2], [2, 1, 3], [2, 1, 4]], dtype=torch.int64, device=device + ) + + meshes = Meshes( + verts=[verts1, verts2, verts3], faces=[faces1, faces2, faces3] + ) + + # mesh1: normal consistency computation + n0 = (verts1[1] - verts1[2]).cross(verts1[3] - verts1[2]) + n1 = (verts1[1] - verts1[2]).cross(verts1[0] - verts1[2]) + loss1 = 1.0 - torch.cosine_similarity(n0.view(1, 3), -n1.view(1, 3)) + + # mesh2: normal consistency computation + # In the cube mesh, 6 edges are shared with coplanar faces (loss=0), + # 12 edges are shared by perpendicular faces (loss=1) + loss2 = 12.0 / 18 + + # mesh3 + n0 = (verts3[1] - verts3[2]).cross(verts3[3] - verts3[2]) + n1 = (verts3[1] - verts3[2]).cross(verts3[0] - verts3[2]) + n2 = (verts3[1] - verts3[2]).cross(verts3[4] - verts3[2]) + loss3 = ( + 3.0 + - torch.cosine_similarity(n0.view(1, 3), -n1.view(1, 3)) + - torch.cosine_similarity(n0.view(1, 3), -n2.view(1, 3)) + - torch.cosine_similarity(n1.view(1, 3), -n2.view(1, 3)) + ) + loss3 /= 3.0 + + loss = (loss1 + loss2 + loss3) / 3.0 + + out = mesh_normal_consistency(meshes) + + self.assertTrue(torch.allclose(out, loss)) + + def test_mesh_normal_consistency(self): + """ + Test Mesh Normal Consistency for random meshes. + """ + meshes = TestMeshNormalConsistency.init_meshes(5, 100, 300) + + out1 = mesh_normal_consistency(meshes) + out2 = TestMeshNormalConsistency.mesh_normal_consistency_naive(meshes) + + self.assertTrue(torch.allclose(out1, out2)) + + @staticmethod + def mesh_normal_consistency_with_ico( + num_meshes: int, level: int = 3, device: str = "cpu" + ): + device = torch.device(device) + mesh = ico_sphere(level, device) + verts, faces = mesh.get_mesh_verts_faces(0) + verts_list = [verts.clone() for _ in range(num_meshes)] + faces_list = [faces.clone() for _ in range(num_meshes)] + meshes = Meshes(verts_list, faces_list) + torch.cuda.synchronize() + + def loss(): + mesh_normal_consistency(meshes) + torch.cuda.synchronize() + + return loss diff --git a/tests/test_meshes.py b/tests/test_meshes.py new file mode 100644 index 00000000..2e5ec8f0 --- /dev/null +++ b/tests/test_meshes.py @@ -0,0 +1,1112 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import numpy as np +import unittest +import torch + +from pytorch3d.structures.meshes import Meshes + +from common_testing import TestCaseMixin + + +class TestMeshes(TestCaseMixin, unittest.TestCase): + def setUp(self) -> None: + np.random.seed(42) + torch.manual_seed(42) + + @staticmethod + def init_mesh( + num_meshes: int = 10, + max_v: int = 100, + max_f: int = 300, + lists_to_tensors: bool = False, + device: str = "cpu", + ): + """ + Function to generate a Meshes object of N meshes with + random numbers of vertices and faces. + + Args: + num_meshes: Number of meshes to generate. + max_v: Max number of vertices per mesh. + max_f: Max number of faces per mesh. + lists_to_tensors: Determines whether the generated meshes should be + constructed from lists (=False) or + a tensor (=True) of faces/verts. + + Returns: + Meshes object. + """ + device = torch.device(device) + + verts_list = [] + faces_list = [] + + # Randomly generate numbers of faces and vertices in each mesh. + if lists_to_tensors: + # If we define faces/verts with tensors, f/v has to be the + # same for each mesh in the batch. + f = torch.randint(max_f, size=(1,), dtype=torch.int32) + v = torch.randint(3, high=max_v, size=(1,), dtype=torch.int32) + f = f.repeat(num_meshes) + v = v.repeat(num_meshes) + else: + # For lists of faces and vertices, we can sample different v/f + # per mesh. + f = torch.randint(max_f, size=(num_meshes,), dtype=torch.int32) + v = torch.randint( + 3, high=max_v, size=(num_meshes,), dtype=torch.int32 + ) + + # Generate the actual vertices and faces. + for i in range(num_meshes): + verts = torch.rand((v[i], 3), dtype=torch.float32, device=device) + faces = torch.randint( + v[i], size=(f[i], 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + + if lists_to_tensors: + verts_list = torch.stack(verts_list) + faces_list = torch.stack(faces_list) + + return Meshes(verts=verts_list, faces=faces_list) + + @staticmethod + def init_simple_mesh(device: str = "cpu"): + """ + Returns a Meshes data structure of simple mesh examples. + + Returns: + Meshes object. + """ + device = torch.device(device) + + verts = [ + torch.tensor( + [[0.1, 0.3, 0.5], [0.5, 0.2, 0.1], [0.6, 0.8, 0.7]], + dtype=torch.float32, + device=device, + ), + torch.tensor( + [ + [0.1, 0.3, 0.3], + [0.6, 0.7, 0.8], + [0.2, 0.3, 0.4], + [0.1, 0.5, 0.3], + ], + dtype=torch.float32, + device=device, + ), + torch.tensor( + [ + [0.7, 0.3, 0.6], + [0.2, 0.4, 0.8], + [0.9, 0.5, 0.2], + [0.2, 0.3, 0.4], + [0.9, 0.3, 0.8], + ], + dtype=torch.float32, + device=device, + ), + ] + faces = [ + torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device), + torch.tensor( + [[0, 1, 2], [1, 2, 3]], dtype=torch.int64, device=device + ), + torch.tensor( + [ + [1, 2, 0], + [0, 1, 3], + [2, 3, 1], + [4, 3, 2], + [4, 0, 1], + [4, 3, 1], + [4, 2, 1], + ], + dtype=torch.int64, + device=device, + ), + ] + return Meshes(verts=verts, faces=faces) + + def test_simple(self): + mesh = TestMeshes.init_simple_mesh("cuda:0") + + self.assertClose( + mesh.verts_packed_to_mesh_idx().cpu(), + torch.tensor([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2]), + ) + self.assertClose( + mesh.mesh_to_verts_packed_first_idx().cpu(), torch.tensor([0, 3, 7]) + ) + self.assertClose( + mesh.num_verts_per_mesh().cpu(), torch.tensor([3, 4, 5]) + ) + self.assertClose( + mesh.verts_padded_to_packed_idx().cpu(), + torch.tensor([0, 1, 2, 5, 6, 7, 8, 10, 11, 12, 13, 14]), + ) + self.assertClose( + mesh.faces_packed_to_mesh_idx().cpu(), + torch.tensor([0, 1, 1, 2, 2, 2, 2, 2, 2, 2]), + ) + self.assertClose( + mesh.mesh_to_faces_packed_first_idx().cpu(), torch.tensor([0, 1, 3]) + ) + self.assertClose( + mesh.num_faces_per_mesh().cpu(), torch.tensor([1, 2, 7]) + ) + self.assertClose( + mesh.num_edges_per_mesh().cpu(), + torch.tensor([3, 5, 10], dtype=torch.int32), + ) + + def test_simple_random_meshes(self): + + # Define the test mesh object either as a list or tensor of faces/verts. + for lists_to_tensors in (False, True): + N = 10 + mesh = TestMeshes.init_mesh( + N, 100, 300, lists_to_tensors=lists_to_tensors + ) + verts_list = mesh.verts_list() + faces_list = mesh.faces_list() + + # Check batch calculations. + verts_padded = mesh.verts_padded() + faces_padded = mesh.faces_padded() + verts_per_mesh = mesh.num_verts_per_mesh() + faces_per_mesh = mesh.num_faces_per_mesh() + for n in range(N): + v = verts_list[n].shape[0] + f = faces_list[n].shape[0] + self.assertClose(verts_padded[n, :v, :], verts_list[n]) + if verts_padded.shape[1] > v: + self.assertTrue(verts_padded[n, v:, :].eq(0).all()) + self.assertClose(faces_padded[n, :f, :], faces_list[n]) + if faces_padded.shape[1] > f: + self.assertTrue(faces_padded[n, f:, :].eq(-1).all()) + self.assertEqual(verts_per_mesh[n], v) + self.assertEqual(faces_per_mesh[n], f) + + # Check compute packed. + verts_packed = mesh.verts_packed() + vert_to_mesh = mesh.verts_packed_to_mesh_idx() + mesh_to_vert = mesh.mesh_to_verts_packed_first_idx() + faces_packed = mesh.faces_packed() + face_to_mesh = mesh.faces_packed_to_mesh_idx() + mesh_to_face = mesh.mesh_to_faces_packed_first_idx() + + curv, curf = 0, 0 + for n in range(N): + v = verts_list[n].shape[0] + f = faces_list[n].shape[0] + self.assertClose( + verts_packed[curv : curv + v, :], verts_list[n] + ) + self.assertClose( + faces_packed[curf : curf + f, :] - curv, faces_list[n] + ) + self.assertTrue(vert_to_mesh[curv : curv + v].eq(n).all()) + self.assertTrue(face_to_mesh[curf : curf + f].eq(n).all()) + self.assertTrue(mesh_to_vert[n] == curv) + self.assertTrue(mesh_to_face[n] == curf) + curv += v + curf += f + + # Check compute edges and compare with numpy unique. + edges = mesh.edges_packed().cpu().numpy() + edge_to_mesh_idx = mesh.edges_packed_to_mesh_idx().cpu().numpy() + num_edges_per_mesh = mesh.num_edges_per_mesh().cpu().numpy() + + npfaces_packed = mesh.faces_packed().cpu().numpy() + e01 = npfaces_packed[:, [0, 1]] + e12 = npfaces_packed[:, [1, 2]] + e20 = npfaces_packed[:, [2, 0]] + npedges = np.concatenate((e12, e20, e01), axis=0) + npedges = np.sort(npedges, axis=1) + + unique_edges, unique_idx = np.unique( + npedges, return_index=True, axis=0 + ) + self.assertTrue(np.allclose(edges, unique_edges)) + temp = face_to_mesh.cpu().numpy() + temp = np.concatenate((temp, temp, temp), axis=0) + edge_to_mesh = temp[unique_idx] + self.assertTrue(np.allclose(edge_to_mesh_idx, edge_to_mesh)) + num_edges = np.bincount(edge_to_mesh, minlength=N) + self.assertTrue(np.allclose(num_edges_per_mesh, num_edges)) + + def test_allempty(self): + verts_list = [] + faces_list = [] + mesh = Meshes(verts=verts_list, faces=faces_list) + self.assertEqual(len(mesh), 0) + self.assertEqual(mesh.verts_padded().shape[0], 0) + self.assertEqual(mesh.faces_padded().shape[0], 0) + self.assertEqual(mesh.verts_packed().shape[0], 0) + self.assertEqual(mesh.faces_packed().shape[0], 0) + + def test_empty(self): + N, V, F = 10, 100, 300 + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + valid = torch.randint(2, size=(N,), dtype=torch.uint8, device=device) + for n in range(N): + if valid[n]: + v = torch.randint( + 3, high=V, size=(1,), dtype=torch.int32, device=device + )[0] + f = torch.randint( + F, size=(1,), dtype=torch.int32, device=device + )[0] + verts = torch.rand((v, 3), dtype=torch.float32, device=device) + faces = torch.randint( + v, size=(f, 3), dtype=torch.int64, device=device + ) + else: + verts = torch.tensor([], dtype=torch.float32, device=device) + faces = torch.tensor([], dtype=torch.int64, device=device) + verts_list.append(verts) + faces_list.append(faces) + + mesh = Meshes(verts=verts_list, faces=faces_list) + verts_padded = mesh.verts_padded() + faces_padded = mesh.faces_padded() + verts_per_mesh = mesh.num_verts_per_mesh() + faces_per_mesh = mesh.num_faces_per_mesh() + for n in range(N): + v = len(verts_list[n]) + f = len(faces_list[n]) + if v > 0: + self.assertClose(verts_padded[n, :v, :], verts_list[n]) + if verts_padded.shape[1] > v: + self.assertTrue(verts_padded[n, v:, :].eq(0).all()) + if f > 0: + self.assertClose(faces_padded[n, :f, :], faces_list[n]) + if faces_padded.shape[1] > f: + self.assertTrue(faces_padded[n, f:, :].eq(-1).all()) + self.assertTrue(verts_per_mesh[n] == v) + self.assertTrue(faces_per_mesh[n] == f) + + def test_padding(self): + N, V, F = 10, 100, 300 + device = torch.device("cuda:0") + verts, faces = [], [] + valid = torch.randint(2, size=(N,), dtype=torch.uint8, device=device) + num_verts, num_faces = ( + torch.zeros(N, dtype=torch.int32), + torch.zeros(N, dtype=torch.int32), + ) + for n in range(N): + verts.append(torch.rand((V, 3), dtype=torch.float32, device=device)) + this_faces = torch.full( + (F, 3), -1, dtype=torch.int64, device=device + ) + if valid[n]: + v = torch.randint( + 3, high=V, size=(1,), dtype=torch.int32, device=device + )[0] + f = torch.randint( + F, size=(1,), dtype=torch.int32, device=device + )[0] + this_faces[:f, :] = torch.randint( + v, size=(f, 3), dtype=torch.int64, device=device + ) + num_verts[n] = v + num_faces[n] = f + faces.append(this_faces) + + mesh = Meshes(verts=torch.stack(verts), faces=torch.stack(faces)) + + self.assertListEqual( + mesh.num_faces_per_mesh().tolist(), num_faces.tolist() + ) + + for n, (vv, ff) in enumerate(zip(mesh.verts_list(), mesh.faces_list())): + self.assertClose(ff, faces[n][: num_faces[n]]) + self.assertClose(vv, verts[n]) + + new_faces = [ff.clone() for ff in faces] + v = torch.randint( + 3, high=V, size=(1,), dtype=torch.int32, device=device + )[0] + f = torch.randint(F - 10, size=(1,), dtype=torch.int32, device=device)[ + 0 + ] + this_faces = torch.full((F, 3), -1, dtype=torch.int64, device=device) + this_faces[10 : f + 10, :] = torch.randint( + v, size=(f, 3), dtype=torch.int64, device=device + ) + new_faces[3] = this_faces + + with self.assertRaisesRegex(ValueError, "Padding of faces"): + Meshes(verts=torch.stack(verts), faces=torch.stack(new_faces)) + + def test_clone(self): + N = 5 + mesh = TestMeshes.init_mesh(N, 10, 100) + for force in [0, 1]: + if force: + # force mesh to have computed attributes + mesh.verts_packed() + mesh.edges_packed() + mesh.verts_padded() + + new_mesh = mesh.clone() + + # Modify tensors in both meshes. + new_mesh._verts_list[0] = new_mesh._verts_list[0] * 5 + mesh._num_verts_per_mesh = torch.randint_like( + mesh.num_verts_per_mesh(), high=10 + ) + + # Check cloned and original Meshes objects do not share tensors. + self.assertFalse( + torch.allclose(new_mesh._verts_list[0], mesh._verts_list[0]) + ) + self.assertFalse( + torch.allclose( + mesh.num_verts_per_mesh(), new_mesh.num_verts_per_mesh() + ) + ) + self.assertSeparate(new_mesh.verts_packed(), mesh.verts_packed()) + self.assertSeparate(new_mesh.verts_padded(), mesh.verts_padded()) + self.assertSeparate(new_mesh.faces_packed(), mesh.faces_packed()) + self.assertSeparate(new_mesh.faces_padded(), mesh.faces_padded()) + self.assertSeparate(new_mesh.edges_packed(), mesh.edges_packed()) + + def test_laplacian_packed(self): + def naive_laplacian_packed(meshes): + verts_packed = meshes.verts_packed() + edges_packed = meshes.edges_packed() + V = verts_packed.shape[0] + + L = torch.zeros((V, V), dtype=torch.float32, device=meshes.device) + for e in edges_packed: + L[e[0], e[1]] = 1 + # symetric + L[e[1], e[0]] = 1 + + deg = L.sum(1).view(-1, 1) + deg[deg > 0] = 1.0 / deg[deg > 0] + L = L * deg + diag = torch.eye(V, dtype=torch.float32, device=meshes.device) + L.masked_fill_(diag > 0, -1) + return L + + # Note that we don't test with random meshes for this case, as the + # definition of Laplacian is defined for simple graphs (aka valid meshes) + meshes = TestMeshes.init_simple_mesh("cuda:0") + + lapl_naive = naive_laplacian_packed(meshes) + lapl = meshes.laplacian_packed().to_dense() + # check with naive + self.assertClose(lapl, lapl_naive) + + def test_offset_verts(self): + def naive_offset_verts(mesh, vert_offsets_packed): + # new Meshes class + new_verts_packed = mesh.verts_packed() + vert_offsets_packed + new_verts_list = list( + new_verts_packed.split(mesh.num_verts_per_mesh().tolist(), 0) + ) + new_faces_list = [f.clone() for f in mesh.faces_list()] + return Meshes(verts=new_verts_list, faces=new_faces_list) + + N = 5 + mesh = TestMeshes.init_mesh(N, 10, 100) + all_v = mesh.verts_packed().size(0) + verts_per_mesh = mesh.num_verts_per_mesh() + for force in [0, 1]: + if force: + # force mesh to have computed attributes + mesh._compute_packed(refresh=True) + mesh._compute_padded() + mesh._compute_edges_packed() + mesh.verts_padded_to_packed_idx() + mesh._compute_face_areas_normals(refresh=True) + mesh._compute_vertex_normals(refresh=True) + + deform = torch.rand( + (all_v, 3), dtype=torch.float32, device=mesh.device + ) + # new meshes class to hold the deformed mesh + new_mesh_naive = naive_offset_verts(mesh, deform) + + new_mesh = mesh.offset_verts(deform) + + # check verts_list & faces_list + verts_cumsum = torch.cumsum(verts_per_mesh, 0).tolist() + verts_cumsum.insert(0, 0) + for i in range(N): + self.assertClose( + new_mesh.verts_list()[i], + mesh.verts_list()[i] + + deform[verts_cumsum[i] : verts_cumsum[i + 1]], + ) + self.assertClose( + new_mesh.verts_list()[i], new_mesh_naive.verts_list()[i] + ) + self.assertClose( + mesh.faces_list()[i], new_mesh_naive.faces_list()[i] + ) + self.assertClose( + new_mesh.faces_list()[i], new_mesh_naive.faces_list()[i] + ) + # check faces and vertex normals + self.assertClose( + new_mesh.verts_normals_list()[i], + new_mesh_naive.verts_normals_list()[i], + ) + self.assertClose( + new_mesh.faces_normals_list()[i], + new_mesh_naive.faces_normals_list()[i], + ) + + # check padded & packed + self.assertClose( + new_mesh.faces_padded(), new_mesh_naive.faces_padded() + ) + self.assertClose( + new_mesh.verts_padded(), new_mesh_naive.verts_padded() + ) + self.assertClose( + new_mesh.faces_packed(), new_mesh_naive.faces_packed() + ) + self.assertClose( + new_mesh.verts_packed(), new_mesh_naive.verts_packed() + ) + self.assertClose( + new_mesh.edges_packed(), new_mesh_naive.edges_packed() + ) + self.assertClose( + new_mesh.verts_packed_to_mesh_idx(), + new_mesh_naive.verts_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.mesh_to_verts_packed_first_idx(), + new_mesh_naive.mesh_to_verts_packed_first_idx(), + ) + self.assertClose( + new_mesh.num_verts_per_mesh(), + new_mesh_naive.num_verts_per_mesh(), + ) + self.assertClose( + new_mesh.faces_packed_to_mesh_idx(), + new_mesh_naive.faces_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.mesh_to_faces_packed_first_idx(), + new_mesh_naive.mesh_to_faces_packed_first_idx(), + ) + self.assertClose( + new_mesh.num_faces_per_mesh(), + new_mesh_naive.num_faces_per_mesh(), + ) + self.assertClose( + new_mesh.edges_packed_to_mesh_idx(), + new_mesh_naive.edges_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.verts_padded_to_packed_idx(), + new_mesh_naive.verts_padded_to_packed_idx(), + ) + self.assertTrue(all(new_mesh.valid == new_mesh_naive.valid)) + self.assertTrue(new_mesh.equisized == new_mesh_naive.equisized) + + # check face areas, normals and vertex normals + self.assertClose( + new_mesh.verts_normals_packed(), + new_mesh_naive.verts_normals_packed(), + ) + self.assertClose( + new_mesh.verts_normals_padded(), + new_mesh_naive.verts_normals_padded(), + ) + self.assertClose( + new_mesh.faces_normals_packed(), + new_mesh_naive.faces_normals_packed(), + ) + self.assertClose( + new_mesh.faces_normals_padded(), + new_mesh_naive.faces_normals_padded(), + ) + self.assertClose( + new_mesh.faces_areas_packed(), + new_mesh_naive.faces_areas_packed(), + ) + + def test_scale_verts(self): + def naive_scale_verts(mesh, scale): + if not torch.is_tensor(scale): + scale = torch.ones(len(mesh)).mul_(scale) + # new Meshes class + new_verts_list = [ + scale[i] * v.clone() for (i, v) in enumerate(mesh.verts_list()) + ] + new_faces_list = [f.clone() for f in mesh.faces_list()] + return Meshes(verts=new_verts_list, faces=new_faces_list) + + N = 5 + for test in ["tensor", "scalar"]: + mesh = TestMeshes.init_mesh(N, 10, 100) + for force in [0, 1]: + if force: + # force mesh to have computed attributes + mesh.verts_packed() + mesh.edges_packed() + mesh.verts_padded() + mesh._compute_face_areas_normals(refresh=True) + mesh._compute_vertex_normals(refresh=True) + + if test == "tensor": + scales = torch.rand(N) + elif test == "scalar": + scales = torch.rand(1)[0].item() + new_mesh_naive = naive_scale_verts(mesh, scales) + new_mesh = mesh.scale_verts(scales) + for i in range(N): + if test == "tensor": + self.assertClose( + scales[i] * mesh.verts_list()[i], + new_mesh.verts_list()[i], + ) + else: + self.assertClose( + scales * mesh.verts_list()[i], + new_mesh.verts_list()[i], + ) + self.assertClose( + new_mesh.verts_list()[i], new_mesh_naive.verts_list()[i] + ) + self.assertClose( + mesh.faces_list()[i], new_mesh_naive.faces_list()[i] + ) + self.assertClose( + new_mesh.faces_list()[i], new_mesh_naive.faces_list()[i] + ) + # check face and vertex normals + self.assertClose( + new_mesh.verts_normals_list()[i], + new_mesh_naive.verts_normals_list()[i], + ) + self.assertClose( + new_mesh.faces_normals_list()[i], + new_mesh_naive.faces_normals_list()[i], + ) + + # check padded & packed + self.assertClose( + new_mesh.faces_padded(), new_mesh_naive.faces_padded() + ) + self.assertClose( + new_mesh.verts_padded(), new_mesh_naive.verts_padded() + ) + self.assertClose( + new_mesh.faces_packed(), new_mesh_naive.faces_packed() + ) + self.assertClose( + new_mesh.verts_packed(), new_mesh_naive.verts_packed() + ) + self.assertClose( + new_mesh.edges_packed(), new_mesh_naive.edges_packed() + ) + self.assertClose( + new_mesh.verts_packed_to_mesh_idx(), + new_mesh_naive.verts_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.mesh_to_verts_packed_first_idx(), + new_mesh_naive.mesh_to_verts_packed_first_idx(), + ) + self.assertClose( + new_mesh.num_verts_per_mesh(), + new_mesh_naive.num_verts_per_mesh(), + ) + self.assertClose( + new_mesh.faces_packed_to_mesh_idx(), + new_mesh_naive.faces_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.mesh_to_faces_packed_first_idx(), + new_mesh_naive.mesh_to_faces_packed_first_idx(), + ) + self.assertClose( + new_mesh.num_faces_per_mesh(), + new_mesh_naive.num_faces_per_mesh(), + ) + self.assertClose( + new_mesh.edges_packed_to_mesh_idx(), + new_mesh_naive.edges_packed_to_mesh_idx(), + ) + self.assertClose( + new_mesh.verts_padded_to_packed_idx(), + new_mesh_naive.verts_padded_to_packed_idx(), + ) + self.assertTrue(all(new_mesh.valid == new_mesh_naive.valid)) + self.assertTrue(new_mesh.equisized == new_mesh_naive.equisized) + + # check face areas, normals and vertex normals + self.assertClose( + new_mesh.verts_normals_packed(), + new_mesh_naive.verts_normals_packed(), + ) + self.assertClose( + new_mesh.verts_normals_padded(), + new_mesh_naive.verts_normals_padded(), + ) + self.assertClose( + new_mesh.faces_normals_packed(), + new_mesh_naive.faces_normals_packed(), + ) + self.assertClose( + new_mesh.faces_normals_padded(), + new_mesh_naive.faces_normals_padded(), + ) + self.assertClose( + new_mesh.faces_areas_packed(), + new_mesh_naive.faces_areas_packed(), + ) + + def test_extend_list(self): + N = 10 + mesh = TestMeshes.init_mesh(5, 10, 100) + for force in [0, 1]: + if force: + # force some computes to happen + mesh._compute_packed(refresh=True) + mesh._compute_padded() + mesh._compute_edges_packed() + mesh.verts_padded_to_packed_idx() + new_mesh = mesh.extend(N) + self.assertEqual(len(mesh) * 10, len(new_mesh)) + for i in range(len(mesh)): + for n in range(N): + self.assertClose( + mesh.verts_list()[i], new_mesh.verts_list()[i * N + n] + ) + self.assertClose( + mesh.faces_list()[i], new_mesh.faces_list()[i * N + n] + ) + self.assertTrue(mesh.valid[i] == new_mesh.valid[i * N + n]) + self.assertAllSeparate( + mesh.verts_list() + + new_mesh.verts_list() + + mesh.faces_list() + + new_mesh.faces_list() + ) + self.assertTrue(new_mesh._verts_packed is None) + self.assertTrue(new_mesh._faces_packed is None) + self.assertTrue(new_mesh._verts_padded is None) + self.assertTrue(new_mesh._faces_padded is None) + self.assertTrue(new_mesh._edges_packed is None) + + with self.assertRaises(ValueError): + mesh.extend(N=-1) + + def test_to(self): + mesh = TestMeshes.init_mesh(5, 10, 100, device=torch.device("cuda:0")) + device = torch.device("cuda:1") + + new_mesh = mesh.to(device) + self.assertTrue(new_mesh.device == device) + self.assertTrue(mesh.device == torch.device("cuda:0")) + + def test_split_mesh(self): + mesh = TestMeshes.init_mesh(5, 10, 100) + split_sizes = [2, 3] + split_meshes = mesh.split(split_sizes) + self.assertTrue(len(split_meshes[0]) == 2) + self.assertTrue( + split_meshes[0].verts_list() + == [ + mesh.get_mesh_verts_faces(0)[0], + mesh.get_mesh_verts_faces(1)[0], + ] + ) + self.assertTrue(len(split_meshes[1]) == 3) + self.assertTrue( + split_meshes[1].verts_list() + == [ + mesh.get_mesh_verts_faces(2)[0], + mesh.get_mesh_verts_faces(3)[0], + mesh.get_mesh_verts_faces(4)[0], + ] + ) + + split_sizes = [2, 0.3] + with self.assertRaises(ValueError): + mesh.split(split_sizes) + + def test_get_mesh_verts_faces(self): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + verts_faces = [(10, 100), (20, 200)] + for (V, F) in verts_faces: + verts = torch.rand((V, 3), dtype=torch.float32, device=device) + faces = torch.randint( + V, size=(F, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + + mesh = Meshes(verts=verts_list, faces=faces_list) + + for i, (V, F) in enumerate(verts_faces): + verts, faces = mesh.get_mesh_verts_faces(i) + self.assertTrue(len(verts) == V) + self.assertClose(verts, verts_list[i]) + self.assertTrue(len(faces) == F) + self.assertClose(faces, faces_list[i]) + + with self.assertRaises(ValueError): + mesh.get_mesh_verts_faces(5) + with self.assertRaises(ValueError): + mesh.get_mesh_verts_faces(0.2) + + def test_get_bounding_boxes(self): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + for (V, F) in [(10, 100)]: + verts = torch.rand((V, 3), dtype=torch.float32, device=device) + faces = torch.randint( + V, size=(F, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + + mins = torch.min(verts, dim=0)[0] + maxs = torch.max(verts, dim=0)[0] + bboxes_gt = torch.stack([mins, maxs], dim=1).unsqueeze(0) + mesh = Meshes(verts=verts_list, faces=faces_list) + bboxes = mesh.get_bounding_boxes() + self.assertClose(bboxes_gt, bboxes) + + def test_padded_to_packed_idx(self): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + verts_faces = [(10, 100), (20, 200), (30, 300)] + for (V, F) in verts_faces: + verts = torch.rand((V, 3), dtype=torch.float32, device=device) + faces = torch.randint( + V, size=(F, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + + mesh = Meshes(verts=verts_list, faces=faces_list) + verts_padded_to_packed_idx = mesh.verts_padded_to_packed_idx() + verts_packed = mesh.verts_packed() + verts_padded = mesh.verts_padded() + verts_padded_flat = verts_padded.view(-1, 3) + + self.assertClose( + verts_padded_flat[verts_padded_to_packed_idx], verts_packed + ) + + idx = verts_padded_to_packed_idx.view(-1, 1).expand(-1, 3) + self.assertClose(verts_padded_flat.gather(0, idx), verts_packed) + + def test_getitem(self): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + verts_faces = [(10, 100), (20, 200), (30, 300)] + for (V, F) in verts_faces: + verts = torch.rand((V, 3), dtype=torch.float32, device=device) + faces = torch.randint( + V, size=(F, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + + mesh = Meshes(verts=verts_list, faces=faces_list) + + def check_equal(selected, indices): + for selectedIdx, index in enumerate(indices): + self.assertClose( + selected.verts_list()[selectedIdx], mesh.verts_list()[index] + ) + self.assertClose( + selected.faces_list()[selectedIdx], mesh.faces_list()[index] + ) + + # int index + index = 1 + mesh_selected = mesh[index] + self.assertTrue(len(mesh_selected) == 1) + check_equal(mesh_selected, [index]) + + # list index + index = [1, 2] + mesh_selected = mesh[index] + self.assertTrue(len(mesh_selected) == len(index)) + check_equal(mesh_selected, index) + + # slice index + index = slice(0, 2, 1) + mesh_selected = mesh[index] + check_equal(mesh_selected, [0, 1]) + + # bool tensor + index = torch.tensor([1, 0, 1], dtype=torch.bool, device=device) + mesh_selected = mesh[index] + self.assertTrue(len(mesh_selected) == index.sum()) + check_equal(mesh_selected, [0, 2]) + + # int tensor + index = torch.tensor([1, 2], dtype=torch.int64, device=device) + mesh_selected = mesh[index] + self.assertTrue(len(mesh_selected) == index.numel()) + check_equal(mesh_selected, index.tolist()) + + # invalid index + index = torch.tensor([1, 0, 1], dtype=torch.float32, device=device) + with self.assertRaises(IndexError): + mesh_selected = mesh[index] + index = 1.2 + with self.assertRaises(IndexError): + mesh_selected = mesh[index] + + def test_compute_faces_areas(self): + verts = torch.tensor( + [ + [0.0, 0.0, 0.0], + [0.5, 0.0, 0.0], + [0.5, 0.5, 0.0], + [0.5, 0.0, 0.0], + [0.25, 0.8, 0.0], + ], + dtype=torch.float32, + ) + faces = torch.tensor([[0, 1, 2], [0, 3, 4]], dtype=torch.int64) + mesh = Meshes(verts=[verts], faces=[faces]) + + face_areas = mesh.faces_areas_packed() + expected_areas = torch.tensor([0.125, 0.2]) + self.assertTrue(torch.allclose(face_areas, expected_areas)) + + def test_compute_normals(self): + + # Simple case with one mesh where normals point in either +/- ijk + verts = torch.tensor( + [ + [0.1, 0.3, 0.0], + [0.5, 0.2, 0.0], + [0.6, 0.8, 0.0], + [0.0, 0.3, 0.2], + [0.0, 0.2, 0.5], + [0.0, 0.8, 0.7], + [0.5, 0.0, 0.2], + [0.6, 0.0, 0.5], + [0.8, 0.0, 0.7], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ], + dtype=torch.float32, + ) + faces = torch.tensor( + [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]], dtype=torch.int64 + ) + mesh = Meshes(verts=[verts], faces=[faces]) + + verts_normals_expected = torch.tensor( + [ + [0.0, 0.0, 1.0], + [0.0, 0.0, 1.0], + [0.0, 0.0, 1.0], + [-1.0, 0.0, 0.0], + [-1.0, 0.0, 0.0], + [-1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + ] + ) + faces_normals_expected = verts_normals_expected[[0, 3, 6, 9], :] + + self.assertTrue( + torch.allclose(mesh.verts_normals_list()[0], verts_normals_expected) + ) + self.assertTrue( + torch.allclose(mesh.faces_normals_list()[0], faces_normals_expected) + ) + self.assertTrue( + torch.allclose(mesh.verts_normals_packed(), verts_normals_expected) + ) + self.assertTrue( + torch.allclose(mesh.faces_normals_packed(), faces_normals_expected) + ) + + # Multiple meshes in the batch with equal sized meshes + meshes_extended = mesh.extend(3) + for m in meshes_extended.verts_normals_list(): + self.assertTrue(torch.allclose(m, verts_normals_expected)) + for f in meshes_extended.faces_normals_list(): + self.assertTrue(torch.allclose(f, faces_normals_expected)) + + # Multiple meshes in the batch with different sized meshes + # Check padded and packed normals are the correct sizes. + verts2 = torch.tensor( + [ + [0.1, 0.3, 0.0], + [0.5, 0.2, 0.0], + [0.6, 0.8, 0.0], + [0.0, 0.3, 0.2], + [0.0, 0.2, 0.5], + [0.0, 0.8, 0.7], + ], + dtype=torch.float32, + ) + faces2 = torch.tensor([[0, 1, 2], [3, 4, 5]], dtype=torch.int64) + verts_list = [verts, verts2] + faces_list = [faces, faces2] + meshes = Meshes(verts=verts_list, faces=faces_list) + verts_normals_padded = meshes.verts_normals_padded() + faces_normals_padded = meshes.faces_normals_padded() + + for n in range(len(meshes)): + v = verts_list[n].shape[0] + f = faces_list[n].shape[0] + if verts_normals_padded.shape[1] > v: + self.assertTrue(verts_normals_padded[n, v:, :].eq(0).all()) + self.assertTrue( + torch.allclose( + verts_normals_padded[n, :v, :].view(-1, 3), + verts_normals_expected[:v, :], + ) + ) + if faces_normals_padded.shape[1] > f: + self.assertTrue(faces_normals_padded[n, f:, :].eq(0).all()) + self.assertTrue( + torch.allclose( + faces_normals_padded[n, :f, :].view(-1, 3), + faces_normals_expected[:f, :], + ) + ) + + verts_normals_packed = meshes.verts_normals_packed() + faces_normals_packed = meshes.faces_normals_packed() + self.assertTrue( + list(verts_normals_packed.shape) + == [verts.shape[0] + verts2.shape[0], 3] + ) + self.assertTrue( + list(faces_normals_packed.shape) + == [faces.shape[0] + faces2.shape[0], 3] + ) + + # Single mesh where two faces share one vertex so the normal is + # the weighted sum of the two face normals. + verts = torch.tensor( + [ + [0.1, 0.3, 0.0], + [0.5, 0.2, 0.0], + [0.0, 0.3, 0.2], # vertex is shared between two faces + [0.0, 0.2, 0.5], + [0.0, 0.8, 0.7], + ], + dtype=torch.float32, + ) + faces = torch.tensor([[0, 1, 2], [2, 3, 4]], dtype=torch.int64) + mesh = Meshes(verts=[verts], faces=[faces]) + + verts_normals_expected = torch.tensor( + [ + [-0.2408, -0.9631, -0.1204], + [-0.2408, -0.9631, -0.1204], + [-0.9389, -0.3414, -0.0427], + [-1.0000, 0.0000, 0.0000], + [-1.0000, 0.0000, 0.0000], + ] + ) + faces_normals_expected = torch.tensor( + [[-0.2408, -0.9631, -0.1204], [-1.0000, 0.0000, 0.0000]] + ) + self.assertTrue( + torch.allclose( + mesh.verts_normals_list()[0], verts_normals_expected, atol=4e-5 + ) + ) + self.assertTrue( + torch.allclose( + mesh.faces_normals_list()[0], faces_normals_expected, atol=4e-5 + ) + ) + + # Check empty mesh has empty normals + meshes = Meshes(verts=[], faces=[]) + self.assertEqual(meshes.verts_normals_packed().shape[0], 0) + self.assertEqual(meshes.verts_normals_padded().shape[0], 0) + self.assertEqual(meshes.verts_normals_list(), []) + self.assertEqual(meshes.faces_normals_packed().shape[0], 0) + self.assertEqual(meshes.faces_normals_padded().shape[0], 0) + self.assertEqual(meshes.faces_normals_list(), []) + + def test_compute_faces_areas_cpu_cuda(self): + num_meshes = 10 + max_v = 100 + max_f = 300 + mesh_cpu = TestMeshes.init_mesh(num_meshes, max_v, max_f, device="cpu") + device = torch.device("cuda:0") + mesh_cuda = mesh_cpu.to(device) + + face_areas_cpu = mesh_cpu.faces_areas_packed() + face_normals_cpu = mesh_cpu.faces_normals_packed() + face_areas_cuda = mesh_cuda.faces_areas_packed() + face_normals_cuda = mesh_cuda.faces_normals_packed() + self.assertClose(face_areas_cpu, face_areas_cuda.cpu(), atol=1e-6) + # because of the normalization of the normals with arbitrarily small values, + # normals can become unstable. Thus only compare normals, for faces + # with areas > eps=1e-6 + nonzero = face_areas_cpu > 1e-6 + self.assertClose( + face_normals_cpu[nonzero], + face_normals_cuda.cpu()[nonzero], + atol=1e-6, + ) + + @staticmethod + def compute_packed_with_init( + num_meshes: int = 10, + max_v: int = 100, + max_f: int = 300, + device: str = "cpu", + ): + mesh = TestMeshes.init_mesh(num_meshes, max_v, max_f, device=device) + torch.cuda.synchronize() + + def compute_packed(): + mesh._compute_packed(refresh=True) + torch.cuda.synchronize() + + return compute_packed + + @staticmethod + def compute_padded_with_init( + num_meshes: int = 10, + max_v: int = 100, + max_f: int = 300, + device: str = "cpu", + ): + mesh = TestMeshes.init_mesh(num_meshes, max_v, max_f, device=device) + torch.cuda.synchronize() + + def compute_padded(): + mesh._compute_padded(refresh=True) + torch.cuda.synchronize() + + return compute_padded diff --git a/tests/test_nearest_neighbor_points.py b/tests/test_nearest_neighbor_points.py new file mode 100644 index 00000000..697b5477 --- /dev/null +++ b/tests/test_nearest_neighbor_points.py @@ -0,0 +1,82 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import unittest +import torch + +from pytorch3d import _C + + +class TestNearestNeighborPoints(unittest.TestCase): + @staticmethod + def nn_points_idx_naive(x, y): + """ + PyTorch implementation of nn_points_idx function. + """ + N, P1, D = x.shape + _N, P2, _D = y.shape + assert N == _N and D == _D + diffs = x.view(N, P1, 1, D) - y.view(N, 1, P2, D) + dists2 = (diffs * diffs).sum(3) + idx = dists2.argmin(2) + return idx + + def test_nn_cuda(self): + """ + Test cuda output vs naive python implementation. + """ + device = torch.device("cuda:0") + for D in [3, 4]: + for N in [1, 4]: + for P1 in [1, 8, 64, 128]: + for P2 in [32, 128]: + x = torch.randn(N, P1, D, device=device) + y = torch.randn(N, P2, D, device=device) + + # _C.nn_points_idx should dispatch + # to the cpp or cuda versions of the function + # depending on the input type. + idx1 = _C.nn_points_idx(x, y) + idx2 = TestNearestNeighborPoints.nn_points_idx_naive( + x, y + ) + self.assertTrue(idx1.size(1) == P1) + self.assertTrue(torch.all(idx1 == idx2)) + + def test_nn_cuda_error(self): + """ + Check that nn_points_idx throws an error if cpu tensors + are given as input. + """ + x = torch.randn(1, 1, 3) + y = torch.randn(1, 1, 3) + with self.assertRaises(Exception) as err: + _C.nn_points_idx(x, y) + self.assertTrue("Not implemented on the CPU" in str(err.exception)) + + @staticmethod + def bm_nn_points_cuda_with_init( + N: int = 4, D: int = 4, P1: int = 128, P2: int = 128 + ): + device = torch.device("cuda:0") + x = torch.randn(N, P1, D, device=device) + y = torch.randn(N, P2, D, device=device) + torch.cuda.synchronize() + + def nn_cpp(): + _C.nn_points_idx(x.contiguous(), y.contiguous()) + torch.cuda.synchronize() + + return nn_cpp + + @staticmethod + def bm_nn_points_python_with_init( + N: int = 4, D: int = 4, P1: int = 128, P2: int = 128 + ): + x = torch.randn(N, P1, D) + y = torch.randn(N, P2, D) + + def nn_python(): + TestNearestNeighborPoints.nn_points_idx_naive(x, y) + + return nn_python diff --git a/tests/test_obj_io.py b/tests/test_obj_io.py new file mode 100644 index 00000000..a02ebd80 --- /dev/null +++ b/tests/test_obj_io.py @@ -0,0 +1,486 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import os +import unittest +from io import StringIO +from pathlib import Path +import torch + +from pytorch3d.io import load_obj, save_obj + + +class TestMeshObjIO(unittest.TestCase): + def test_load_obj_simple(self): + obj_file = "\n".join( + [ + "# this is a comment", # Comments should be ignored. + "v 0.1 0.2 0.3", + "v 0.2 0.3 0.4", + "v 0.3 0.4 0.5", + "v 0.4 0.5 0.6", # some obj files have multiple spaces after v + "f 1 2 3", + "f 1 2 4 3 1", # Polygons should be split into triangles + ] + ) + obj_file = StringIO(obj_file) + verts, faces, aux = load_obj(obj_file) + normals = aux.normals + textures = aux.verts_uvs + materials = aux.material_colors + tex_maps = aux.texture_images + + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + expected_faces = torch.tensor( + [ + [0, 1, 2], # First face + [0, 1, 3], # Second face (polygon) + [0, 3, 2], # Second face (polygon) + [0, 2, 0], # Second face (polygon) + ], + dtype=torch.int64, + ) + self.assertTrue(torch.all(verts == expected_verts)) + self.assertTrue(torch.all(faces.verts_idx == expected_faces)) + self.assertTrue(faces.normals_idx == []) + self.assertTrue(faces.textures_idx == []) + self.assertTrue( + torch.all(faces.materials_idx == -torch.ones(len(expected_faces))) + ) + self.assertTrue(normals is None) + self.assertTrue(textures is None) + self.assertTrue(materials is None) + self.assertTrue(tex_maps is None) + + def test_load_obj_complex(self): + obj_file = "\n".join( + [ + "# this is a comment", # Comments should be ignored. + "v 0.1 0.2 0.3", + "v 0.2 0.3 0.4", + "v 0.3 0.4 0.5", + "v 0.4 0.5 0.6", + "vn 0.000000 0.000000 -1.000000", + "vn -1.000000 -0.000000 -0.000000", + "vn -0.000000 -0.000000 1.000000", # Normals should not be ignored. + "v 0.5 0.6 0.7", + "vt 0.749279 0.501284 0.0", # Some files add 0.0 - ignore this. + "vt 0.999110 0.501077", + "vt 0.999455 0.750380", + "f 1 2 3", + "f 1 2 4 3 5", # Polygons should be split into triangles + "f 2/1/2 3/1/2 4/2/2", # Texture/normals are loaded correctly. + "f -1 -2 1", # Negative indexing counts from the end. + ] + ) + obj_file = StringIO(obj_file) + verts, faces, aux = load_obj(obj_file) + normals = aux.normals + textures = aux.verts_uvs + materials = aux.material_colors + tex_maps = aux.texture_images + + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + [0.5, 0.6, 0.7], + ], + dtype=torch.float32, + ) + expected_faces = torch.tensor( + [ + [0, 1, 2], # First face + [0, 1, 3], # Second face (polygon) + [0, 3, 2], # Second face (polygon) + [0, 2, 4], # Second face (polygon) + [1, 2, 3], # Third face (normals / texture) + [4, 3, 0], # Fourth face (negative indices) + ], + dtype=torch.int64, + ) + expected_normals = torch.tensor( + [ + [0.000000, 0.000000, -1.000000], + [-1.000000, -0.000000, -0.000000], + [-0.000000, -0.000000, 1.000000], + ], + dtype=torch.float32, + ) + expected_textures = torch.tensor( + [[0.749279, 0.501284], [0.999110, 0.501077], [0.999455, 0.750380]], + dtype=torch.float32, + ) + expected_faces_normals_idx = torch.tensor( + [[1, 1, 1]], dtype=torch.int64 + ) + expected_faces_textures_idx = torch.tensor( + [[0, 0, 1]], dtype=torch.int64 + ) + + self.assertTrue(torch.all(verts == expected_verts)) + self.assertTrue(torch.all(faces.verts_idx == expected_faces)) + self.assertTrue(torch.allclose(normals, expected_normals)) + self.assertTrue(torch.allclose(textures, expected_textures)) + self.assertTrue( + torch.allclose(faces.normals_idx, expected_faces_normals_idx) + ) + self.assertTrue( + torch.allclose(faces.textures_idx, expected_faces_textures_idx) + ) + self.assertTrue(materials is None) + self.assertTrue(tex_maps is None) + + def test_load_obj_normals_only(self): + obj_file = "\n".join( + [ + "v 0.1 0.2 0.3", + "v 0.2 0.3 0.4", + "v 0.3 0.4 0.5", + "v 0.4 0.5 0.6", + "vn 0.000000 0.000000 -1.000000", + "vn -1.000000 -0.000000 -0.000000", + "f 2//1 3//1 4//2", + ] + ) + obj_file = StringIO(obj_file) + expected_faces_normals_idx = torch.tensor( + [[0, 0, 1]], dtype=torch.int64 + ) + expected_normals = torch.tensor( + [ + [0.000000, 0.000000, -1.000000], + [-1.000000, -0.000000, -0.000000], + ], + dtype=torch.float32, + ) + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + verts, faces, aux = load_obj(obj_file) + normals = aux.normals + textures = aux.verts_uvs + materials = aux.material_colors + tex_maps = aux.texture_images + self.assertTrue( + torch.allclose(faces.normals_idx, expected_faces_normals_idx) + ) + self.assertTrue(torch.allclose(normals, expected_normals)) + self.assertTrue(torch.allclose(verts, expected_verts)) + self.assertTrue(faces.textures_idx == []) + self.assertTrue(textures is None) + self.assertTrue(materials is None) + self.assertTrue(tex_maps is None) + + def test_load_obj_textures_only(self): + obj_file = "\n".join( + [ + "v 0.1 0.2 0.3", + "v 0.2 0.3 0.4", + "v 0.3 0.4 0.5", + "v 0.4 0.5 0.6", + "vt 0.999110 0.501077", + "vt 0.999455 0.750380", + "f 2/1 3/1 4/2", + ] + ) + obj_file = StringIO(obj_file) + expected_faces_textures_idx = torch.tensor( + [[0, 0, 1]], dtype=torch.int64 + ) + expected_textures = torch.tensor( + [[0.999110, 0.501077], [0.999455, 0.750380]], dtype=torch.float32 + ) + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + verts, faces, aux = load_obj(obj_file) + normals = aux.normals + textures = aux.verts_uvs + materials = aux.material_colors + tex_maps = aux.texture_images + + self.assertTrue( + torch.allclose(faces.textures_idx, expected_faces_textures_idx) + ) + self.assertTrue(torch.allclose(expected_textures, textures)) + self.assertTrue(torch.allclose(expected_verts, verts)) + self.assertTrue(faces.normals_idx == []) + self.assertTrue(normals is None) + self.assertTrue(materials is None) + self.assertTrue(tex_maps is None) + + def test_load_obj_error_textures(self): + obj_file = "\n".join(["vt 0.1"]) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("does not have 2 values" in str(err.exception)) + + def test_load_obj_error_normals(self): + obj_file = "\n".join(["vn 0.1"]) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("does not have 3 values" in str(err.exception)) + + def test_load_obj_error_vertices(self): + obj_file = "\n".join(["v 1"]) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("does not have 3 values" in str(err.exception)) + + def test_load_obj_error_inconsistent_triplets(self): + obj_file = "\n".join(["f 2//1 3/1 4/1/2"]) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue( + "Vertex properties are inconsistent" in str(err.exception) + ) + + def test_load_obj_error_too_many_vertex_properties(self): + obj_file = "\n".join(["f 2/1/1/3"]) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue( + "Face vertices can ony have 3 properties" in str(err.exception) + ) + + def test_load_obj_error_invalid_vertex_indices(self): + obj_file = "\n".join( + ["v 0.1 0.2 0.3", "v 0.1 0.2 0.3", "v 0.1 0.2 0.3", "f -2 5 1"] + ) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("Faces have invalid indices." in str(err.exception)) + + def test_load_obj_error_invalid_normal_indices(self): + obj_file = "\n".join( + [ + "v 0.1 0.2 0.3", + "v 0.1 0.2 0.3", + "v 0.1 0.2 0.3", + "vn 0.1 0.2 0.3", + "vn 0.1 0.2 0.3", + "vn 0.1 0.2 0.3", + "f -2/2 2/4 1/1", + ] + ) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("Faces have invalid indices." in str(err.exception)) + + def test_load_obj_error_invalid_texture_indices(self): + obj_file = "\n".join( + [ + "v 0.1 0.2 0.3", + "v 0.1 0.2 0.3", + "v 0.1 0.2 0.3", + "vt 0.1 0.2", + "vt 0.1 0.2", + "vt 0.1 0.2", + "f -2//2 2//6 1//1", + ] + ) + obj_file = StringIO(obj_file) + + with self.assertRaises(ValueError) as err: + load_obj(obj_file) + self.assertTrue("Faces have invalid indices." in str(err.exception)) + + def test_save_obj(self): + verts = torch.tensor( + [ + [0.01, 0.2, 0.301], + [0.2, 0.03, 0.408], + [0.3, 0.4, 0.05], + [0.6, 0.7, 0.8], + ], + dtype=torch.float32, + ) + faces = torch.tensor( + [[0, 2, 1], [0, 1, 2], [3, 2, 1], [3, 1, 0]], dtype=torch.int64 + ) + obj_file = StringIO() + save_obj(obj_file, verts, faces, decimal_places=2) + expected_file = "\n".join( + [ + "v 0.01 0.20 0.30", + "v 0.20 0.03 0.41", + "v 0.30 0.40 0.05", + "v 0.60 0.70 0.80", + "f 1 3 2", + "f 1 2 3", + "f 4 3 2", + "f 4 2 1", + ] + ) + actual_file = obj_file.getvalue() + self.assertEqual(actual_file, expected_file) + + def test_load_mtl(self): + DATA_DIR = ( + Path(__file__).resolve().parent.parent / "docs/tutorials/data" + ) + obj_filename = "cow_mesh/cow.obj" + filename = os.path.join(DATA_DIR, obj_filename) + verts, faces, aux = load_obj(filename) + materials = aux.material_colors + tex_maps = aux.texture_images + + dtype = torch.float32 + expected_materials = { + "material_1": { + "ambient_color": torch.tensor([1.0, 1.0, 1.0], dtype=dtype), + "diffuse_color": torch.tensor([1.0, 1.0, 1.0], dtype=dtype), + "specular_color": torch.tensor([0.0, 0.0, 0.0], dtype=dtype), + "shininess": torch.tensor([10.0], dtype=dtype), + } + } + # Check that there is an image with material name material_1. + self.assertTrue(tuple(tex_maps.keys()) == ("material_1",)) + self.assertTrue(torch.is_tensor(tuple(tex_maps.values())[0])) + self.assertTrue( + torch.all(faces.materials_idx == torch.zeros(len(faces.verts_idx))) + ) + + # Check all keys and values in dictionary are the same. + for n1, n2 in zip(materials.keys(), expected_materials.keys()): + self.assertTrue(n1 == n2) + for k1, k2 in zip( + materials[n1].keys(), expected_materials[n2].keys() + ): + self.assertTrue( + torch.allclose( + materials[n1][k1], expected_materials[n2][k2] + ) + ) + + def test_load_mtl_fail(self): + # Faces have a material + obj_file = "\n".join( + [ + "v 0.1 0.2 0.3", + "v 0.2 0.3 0.4", + "v 0.3 0.4 0.5", + "v 0.4 0.5 0.6", + "usemtl material_1", + "f 1 2 3", + "f 1 2 4", + ] + ) + obj_file = StringIO(obj_file) + with self.assertWarnsRegex(Warning, "No mtl file provided"): + verts, faces, aux = load_obj(obj_file) + + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + expected_faces = torch.tensor([[0, 1, 2], [0, 1, 3]], dtype=torch.int64) + self.assertTrue(torch.allclose(verts, expected_verts)) + self.assertTrue(torch.allclose(faces.verts_idx, expected_faces)) + self.assertTrue(aux.material_colors is None) + self.assertTrue(aux.texture_images is None) + self.assertTrue(aux.normals is None) + self.assertTrue(aux.verts_uvs is None) + + def test_load_obj_missing_texture(self): + DATA_DIR = Path(__file__).resolve().parent / "data" + obj_filename = "missing_files_obj/model.obj" + filename = os.path.join(DATA_DIR, obj_filename) + with self.assertWarnsRegex(Warning, "Texture file does not exist"): + verts, faces, aux = load_obj(filename) + + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + expected_faces = torch.tensor([[0, 1, 2], [0, 1, 3]], dtype=torch.int64) + self.assertTrue(torch.allclose(verts, expected_verts)) + self.assertTrue(torch.allclose(faces.verts_idx, expected_faces)) + + def test_load_obj_missing_mtl(self): + DATA_DIR = Path(__file__).resolve().parent / "data" + obj_filename = "missing_files_obj/model2.obj" + filename = os.path.join(DATA_DIR, obj_filename) + with self.assertWarnsRegex(Warning, "Mtl file does not exist"): + verts, faces, aux = load_obj(filename) + + expected_verts = torch.tensor( + [ + [0.1, 0.2, 0.3], + [0.2, 0.3, 0.4], + [0.3, 0.4, 0.5], + [0.4, 0.5, 0.6], + ], + dtype=torch.float32, + ) + expected_faces = torch.tensor([[0, 1, 2], [0, 1, 3]], dtype=torch.int64) + self.assertTrue(torch.allclose(verts, expected_verts)) + self.assertTrue(torch.allclose(faces.verts_idx, expected_faces)) + + @staticmethod + def save_obj_with_init(V: int, F: int): + verts_list = torch.tensor(V * [[0.11, 0.22, 0.33]]).view(-1, 3) + faces_list = torch.tensor(F * [[1, 2, 3]]).view(-1, 3) + obj_file = StringIO() + + def save_mesh(): + save_obj(obj_file, verts_list, faces_list, decimal_places=2) + + return save_mesh + + @staticmethod + def load_obj_with_init(V: int, F: int): + obj = "\n".join(["v 0.1 0.2 0.3"] * V + ["f 1 2 3"] * F) + + def load_mesh(): + obj_file = StringIO(obj) + verts, faces, aux = load_obj(obj_file) + + return load_mesh diff --git a/tests/test_ply_io.py b/tests/test_ply_io.py new file mode 100644 index 00000000..97cb579d --- /dev/null +++ b/tests/test_ply_io.py @@ -0,0 +1,434 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import struct +import unittest +from io import BytesIO, StringIO +import torch + +from pytorch3d.io.ply_io import _load_ply_raw, load_ply, save_ply + +from common_testing import TestCaseMixin + + +class TestMeshPlyIO(TestCaseMixin, unittest.TestCase): + def test_raw_load_simple_ascii(self): + ply_file = "\n".join( + [ + "ply", + "format ascii 1.0", + "comment made by Greg Turk", + "comment this file is a cube", + "element vertex 8", + "property float x", + "property float y", + "property float z", + "element face 6", + "property list uchar int vertex_index", + "element irregular_list 3", + "property list uchar int vertex_index", + "end_header", + "0 0 0", + "0 0 1", + "0 1 1", + "0 1 0", + "1 0 0", + "1 0 1", + "1 1 1", + "1 1 0", + "4 0 1 2 3", + "4 7 6 5 4", + "4 0 4 5 1", + "4 1 5 6 2", + "4 2 6 7 3", + "4 3 7 4 0", # end of faces + "4 0 1 2 3", + "4 7 6 5 4", + "3 4 5 1", + ] + ) + for line_ending in [None, "\n", "\r\n"]: + if line_ending is None: + stream = StringIO(ply_file) + else: + byte_file = ply_file.encode("ascii") + if line_ending == "\r\n": + byte_file = byte_file.replace(b"\n", b"\r\n") + stream = BytesIO(byte_file) + header, data = _load_ply_raw(stream) + self.assertTrue(header.ascii) + self.assertEqual(len(data), 3) + self.assertTupleEqual(data["face"].shape, (6, 4)) + self.assertClose([0, 1, 2, 3], data["face"][0]) + self.assertClose([3, 7, 4, 0], data["face"][5]) + self.assertTupleEqual(data["vertex"].shape, (8, 3)) + irregular = data["irregular_list"] + self.assertEqual(len(irregular), 3) + self.assertEqual(type(irregular), list) + [x] = irregular[0] + self.assertClose(x, [0, 1, 2, 3]) + [x] = irregular[1] + self.assertClose(x, [7, 6, 5, 4]) + [x] = irregular[2] + self.assertClose(x, [4, 5, 1]) + + def test_load_simple_ascii(self): + ply_file = "\n".join( + [ + "ply", + "format ascii 1.0", + "comment made by Greg Turk", + "comment this file is a cube", + "element vertex 8", + "property float x", + "property float y", + "property float z", + "element face 6", + "property list uchar int vertex_index", + "end_header", + "0 0 0", + "0 0 1", + "0 1 1", + "0 1 0", + "1 0 0", + "1 0 1", + "1 1 1", + "1 1 0", + "4 0 1 2 3", + "4 7 6 5 4", + "4 0 4 5 1", + "4 1 5 6 2", + "4 2 6 7 3", + "4 3 7 4 0", + ] + ) + for line_ending in [None, "\n", "\r\n"]: + if line_ending is None: + stream = StringIO(ply_file) + else: + byte_file = ply_file.encode("ascii") + if line_ending == "\r\n": + byte_file = byte_file.replace(b"\n", b"\r\n") + stream = BytesIO(byte_file) + verts, faces = load_ply(stream) + self.assertEqual(verts.shape, (8, 3)) + self.assertEqual(faces.shape, (12, 3)) + verts_expected = [ + [0, 0, 0], + [0, 0, 1], + [0, 1, 1], + [0, 1, 0], + [1, 0, 0], + [1, 0, 1], + [1, 1, 1], + [1, 1, 0], + ] + self.assertClose(verts, torch.FloatTensor(verts_expected)) + faces_expected = [ + [0, 1, 2], + [7, 6, 5], + [0, 4, 5], + [1, 5, 6], + [2, 6, 7], + [3, 7, 4], + [0, 2, 3], + [7, 5, 4], + [0, 5, 1], + [1, 6, 2], + [2, 7, 3], + [3, 4, 0], + ] + self.assertClose(faces, torch.LongTensor(faces_expected)) + + def test_simple_save(self): + verts = torch.tensor( + [[0, 0, 0], [0, 0, 1], [0, 1, 0], [1, 0, 0]], dtype=torch.float32 + ) + faces = torch.tensor([[0, 1, 2], [0, 3, 4]]) + file = StringIO() + save_ply(file, verts=verts, faces=faces) + file.seek(0) + verts2, faces2 = load_ply(file) + self.assertClose(verts, verts2) + self.assertClose(faces, faces2) + + def test_load_simple_binary(self): + for big_endian in [True, False]: + verts = ( + "0 0 0 " + "0 0 1 " + "0 1 1 " + "0 1 0 " + "1 0 0 " + "1 0 1 " + "1 1 1 " + "1 1 0" + ).split() + faces = ( + "4 0 1 2 3 " + "4 7 6 5 4 " + "4 0 4 5 1 " + "4 1 5 6 2 " + "4 2 6 7 3 " + "4 3 7 4 0 " # end of first 6 + "4 0 1 2 3 " + "4 7 6 5 4 " + "3 4 5 1" + ).split() + short_one = b"\00\01" if big_endian else b"\01\00" + mixed_data = b"\00\00" b"\03\03" + ( + short_one + b"\00\01\01\01" b"\00\02" + ) + minus_one_data = b"\xff" * 14 + endian_char = ">" if big_endian else "<" + format = ( + "format binary_big_endian 1.0" + if big_endian + else "format binary_little_endian 1.0" + ) + vertex_pattern = endian_char + "24f" + vertex_data = struct.pack(vertex_pattern, *map(float, verts)) + vertex1_pattern = endian_char + "fdffdffdffdffdffdffdffdf" + vertex1_data = struct.pack(vertex1_pattern, *map(float, verts)) + face_char_pattern = endian_char + "44b" + face_char_data = struct.pack(face_char_pattern, *map(int, faces)) + header = "\n".join( + [ + "ply", + format, + "element vertex 8", + "property float x", + "property float y", + "property float z", + "element vertex1 8", + "property float x", + "property double y", + "property float z", + "element face 6", + "property list uchar uchar vertex_index", + "element irregular_list 3", + "property list uchar uchar vertex_index", + "element mixed 2", + "property list short uint foo", + "property short bar", + "element minus_ones 1", + "property char 1", + "property uchar 2", + "property short 3", + "property ushort 4", + "property int 5", + "property uint 6", + "end_header\n", + ] + ) + ply_file = b"".join( + [ + header.encode("ascii"), + vertex_data, + vertex1_data, + face_char_data, + mixed_data, + minus_one_data, + ] + ) + metadata, data = _load_ply_raw(BytesIO(ply_file)) + self.assertFalse(metadata.ascii) + self.assertEqual(len(data), 6) + self.assertTupleEqual(data["face"].shape, (6, 4)) + self.assertClose([0, 1, 2, 3], data["face"][0]) + self.assertClose([3, 7, 4, 0], data["face"][5]) + + self.assertTupleEqual(data["vertex"].shape, (8, 3)) + self.assertEqual(len(data["vertex1"]), 8) + self.assertClose(data["vertex"], data["vertex1"]) + self.assertClose(data["vertex"].flatten(), list(map(float, verts))) + + irregular = data["irregular_list"] + self.assertEqual(len(irregular), 3) + self.assertEqual(type(irregular), list) + [x] = irregular[0] + self.assertClose(x, [0, 1, 2, 3]) + [x] = irregular[1] + self.assertClose(x, [7, 6, 5, 4]) + [x] = irregular[2] + self.assertClose(x, [4, 5, 1]) + + mixed = data["mixed"] + self.assertEqual(len(mixed), 2) + self.assertEqual(len(mixed[0]), 2) + self.assertEqual(len(mixed[1]), 2) + self.assertEqual(mixed[0][1], 3 * 256 + 3) + self.assertEqual(len(mixed[0][0]), 0) + self.assertEqual(mixed[1][1], (2 if big_endian else 2 * 256)) + base = 1 + 256 + 256 * 256 + self.assertEqual(len(mixed[1][0]), 1) + self.assertEqual(mixed[1][0][0], base if big_endian else 256 * base) + + self.assertListEqual( + data["minus_ones"], [(-1, 255, -1, 65535, -1, 4294967295)] + ) + + def test_bad_ply_syntax(self): + """Some syntactically bad ply files.""" + lines = [ + "ply", + "format ascii 1.0", + "comment dashfadskfj;k", + "element vertex 1", + "property float x", + "element listy 1", + "property list uint int x", + "end_header", + "0", + "0", + ] + lines2 = lines.copy() + # this is ok + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[0] = "PLY" + with self.assertRaisesRegex(ValueError, "Invalid file header."): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[2] = "#this is a comment" + with self.assertRaisesRegex(ValueError, "Invalid line.*"): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[3] = lines[4] + lines2[4] = lines[3] + with self.assertRaisesRegex( + ValueError, "Encountered property before any element." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[8] = "1 2" + with self.assertRaisesRegex( + ValueError, "Inconsistent data for vertex." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines[:-1] + with self.assertRaisesRegex(ValueError, "Not enough data for listy."): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[5] = "element listy 2" + with self.assertRaisesRegex(ValueError, "Not enough data for listy."): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2.insert(4, "property short x") + with self.assertRaisesRegex( + ValueError, "Cannot have two properties called x in vertex." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2.insert(4, "property zz short") + with self.assertRaisesRegex(ValueError, "Invalid datatype: zz"): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2.append("3") + with self.assertRaisesRegex(ValueError, "Extra data at end of file."): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2.append("comment foo") + with self.assertRaisesRegex(ValueError, "Extra data at end of file."): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2.insert(4, "element bad 1") + with self.assertRaisesRegex( + ValueError, "Found an element with no properties." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[-1] = "3 2 3 3" + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[-1] = "3 1 2 3 4" + msg = "A line of listy data did not have the specified length." + with self.assertRaisesRegex(ValueError, msg): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2 = lines.copy() + lines2[3] = "element vertex one" + msg = "Number of items for vertex was not a number." + with self.assertRaisesRegex(ValueError, msg): + _load_ply_raw(StringIO("\n".join(lines2))) + + # Heterogenous cases + lines2 = lines.copy() + lines2.insert(4, "property double y") + + with self.assertRaisesRegex( + ValueError, "Too little data for an element." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2[-2] = "3.3 4.2" + _load_ply_raw(StringIO("\n".join(lines2))) + + lines2[-2] = "3.3 4.3 2" + with self.assertRaisesRegex( + ValueError, "Too much data for an element." + ): + _load_ply_raw(StringIO("\n".join(lines2))) + + # Now make the ply file actually be readable as a Mesh + + with self.assertRaisesRegex( + ValueError, "The ply file has no face element." + ): + load_ply(StringIO("\n".join(lines))) + + lines2 = lines.copy() + lines2[5] = "element face 1" + with self.assertRaisesRegex(ValueError, "Invalid vertices in file."): + load_ply(StringIO("\n".join(lines2))) + + lines2.insert(5, "property float z") + lines2.insert(5, "property float y") + lines2[-2] = "0 0 0" + with self.assertRaisesRegex( + ValueError, "Faces must have at least 3 vertices." + ): + load_ply(StringIO("\n".join(lines2))) + + # Good one + lines2[-1] = "3 0 0 0" + load_ply(StringIO("\n".join(lines2))) + + @staticmethod + def save_ply_bm(V: int, F: int): + verts_list = torch.tensor(V * [[0.11, 0.22, 0.33]]).view(-1, 3) + faces_list = torch.tensor(F * [[0, 1, 2]]).view(-1, 3) + + def save_mesh(): + file = StringIO() + save_ply(file, verts_list, faces_list, 2) + + return save_mesh + + @staticmethod + def load_ply_bm(V: int, F: int): + verts = torch.tensor([[0.1, 0.2, 0.3]]).expand(V, 3) + faces = torch.tensor([[0, 1, 2]], dtype=torch.int64).expand(F, 3) + ply_file = StringIO() + save_ply(ply_file, verts=verts, faces=faces) + ply = ply_file.getvalue() + # Recreate stream so it's unaffected by how it was created. + + def load_mesh(): + ply_file = StringIO(ply) + verts, faces = load_ply(ply_file) + + return load_mesh diff --git a/tests/test_rasterize_meshes.py b/tests/test_rasterize_meshes.py new file mode 100644 index 00000000..360b2b13 --- /dev/null +++ b/tests/test_rasterize_meshes.py @@ -0,0 +1,977 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + +import functools +import unittest +import torch + +from pytorch3d import _C +from pytorch3d.renderer.mesh.rasterize_meshes import ( + rasterize_meshes, + rasterize_meshes_python, +) +from pytorch3d.structures import Meshes +from pytorch3d.utils import ico_sphere + + +class TestRasterizeMeshes(unittest.TestCase): + def test_simple_python(self): + device = torch.device("cpu") + self._simple_triangle_raster( + rasterize_meshes_python, device, bin_size=-1 + ) # don't set binsize + self._simple_blurry_raster(rasterize_meshes_python, device, bin_size=-1) + self._test_behind_camera(rasterize_meshes_python, device, bin_size=-1) + self._test_perspective_correct( + rasterize_meshes_python, device, bin_size=-1 + ) + + def test_simple_cpu_naive(self): + device = torch.device("cpu") + self._simple_triangle_raster(rasterize_meshes, device) + self._simple_blurry_raster(rasterize_meshes, device) + self._test_behind_camera(rasterize_meshes, device) + self._test_perspective_correct(rasterize_meshes, device) + + def test_simple_cuda_naive(self): + device = torch.device("cuda:0") + self._simple_triangle_raster(rasterize_meshes, device, bin_size=0) + self._simple_blurry_raster(rasterize_meshes, device, bin_size=0) + self._test_behind_camera(rasterize_meshes, device, bin_size=0) + self._test_perspective_correct(rasterize_meshes, device, bin_size=0) + + def test_simple_cuda_binned(self): + device = torch.device("cuda:0") + self._simple_triangle_raster(rasterize_meshes, device, bin_size=5) + self._simple_blurry_raster(rasterize_meshes, device, bin_size=5) + self._test_behind_camera(rasterize_meshes, device, bin_size=5) + self._test_perspective_correct(rasterize_meshes, device, bin_size=5) + + def test_python_vs_cpu_vs_cuda(self): + torch.manual_seed(231) + device = torch.device("cpu") + image_size = 32 + blur_radius = 0.1 ** 2 + faces_per_pixel = 3 + + for d in ["cpu", "cuda"]: + device = torch.device(d) + compare_grads = True + # Mesh with a single face. + verts1 = torch.tensor( + [[0.0, 0.6, 0.1], [-0.7, -0.4, 0.5], [0.7, -0.4, 0.7]], + dtype=torch.float32, + requires_grad=True, + device=device, + ) + faces1 = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + meshes1 = Meshes(verts=[verts1], faces=[faces1]) + args1 = (meshes1, image_size, blur_radius, faces_per_pixel) + verts2 = verts1.detach().clone() + verts2.requires_grad = True + meshes2 = Meshes(verts=[verts2], faces=[faces1]) + args2 = (meshes2, image_size, blur_radius, faces_per_pixel) + self._compare_impls( + rasterize_meshes_python, + rasterize_meshes, + args1, + args2, + verts1, + verts2, + compare_grads=compare_grads, + ) + + # Mesh with multiple faces. + # fmt: off + verts1 = torch.tensor( + [ + [ -0.5, 0.0, 0.1], # noqa: E241, E201 + [ 0.0, 0.6, 0.5], # noqa: E241, E201 + [ 0.5, 0.0, 0.7], # noqa: E241, E201 + [-0.25, 0.0, 0.9], # noqa: E241, E201 + [ 0.26, 0.5, 0.8], # noqa: E241, E201 + [ 0.76, 0.0, 0.8], # noqa: E241, E201 + [-0.41, 0.0, 0.5], # noqa: E241, E201 + [ 0.61, 0.6, 0.6], # noqa: E241, E201 + [ 0.41, 0.0, 0.5], # noqa: E241, E201 + [ -0.2, 0.0, -0.5], # noqa: E241, E201 + [ 0.3, 0.6, -0.5], # noqa: E241, E201 + [ 0.4, 0.0, -0.5], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + requires_grad=True + ) + faces1 = torch.tensor( + [ + [ 1, 0, 2], # noqa: E241, E201 + [ 4, 3, 5], # noqa: E241, E201 + [ 7, 6, 8], # noqa: E241, E201 + [10, 9, 11] # noqa: E241, E201 + ], + dtype=torch.int64, + device=device, + ) + # fmt: on + meshes = Meshes(verts=[verts1], faces=[faces1]) + args1 = (meshes, image_size, blur_radius, faces_per_pixel) + verts2 = verts1.clone().detach() + verts2.requires_grad = True + meshes2 = Meshes(verts=[verts2], faces=[faces1]) + args2 = (meshes2, image_size, blur_radius, faces_per_pixel) + self._compare_impls( + rasterize_meshes_python, + rasterize_meshes, + args1, + args2, + verts1, + verts2, + compare_grads=compare_grads, + ) + + # Icosphere + meshes = ico_sphere(device=device) + verts1, faces1 = meshes.get_mesh_verts_faces(0) + verts1.requires_grad = True + meshes = Meshes(verts=[verts1], faces=[faces1]) + args1 = (meshes, image_size, blur_radius, faces_per_pixel) + verts2 = verts1.detach().clone() + verts2.requires_grad = True + meshes2 = Meshes(verts=[verts2], faces=[faces1]) + args2 = (meshes2, image_size, blur_radius, faces_per_pixel) + self._compare_impls( + rasterize_meshes_python, + rasterize_meshes, + args1, + args2, + verts1, + verts2, + compare_grads=compare_grads, + ) + + def test_cpu_vs_cuda_naive(self): + """ + Compare naive versions of cuda and cpp + """ + + torch.manual_seed(231) + image_size = 64 + radius = 0.1 ** 2 + faces_per_pixel = 3 + device = torch.device("cpu") + meshes_cpu = ico_sphere(0, device) + verts1, faces1 = meshes_cpu.get_mesh_verts_faces(0) + verts1.requires_grad = True + meshes_cpu = Meshes(verts=[verts1], faces=[faces1]) + + device = torch.device("cuda:0") + meshes_cuda = ico_sphere(0, device) + verts2, faces2 = meshes_cuda.get_mesh_verts_faces(0) + verts2.requires_grad = True + meshes_cuda = Meshes(verts=[verts2], faces=[faces2]) + + args_cpu = (meshes_cpu, image_size, radius, faces_per_pixel) + args_cuda = (meshes_cuda, image_size, radius, faces_per_pixel, 0, 0) + self._compare_impls( + rasterize_meshes, + rasterize_meshes, + args_cpu, + args_cuda, + verts1, + verts2, + compare_grads=True, + ) + + def test_coarse_cpu(self): + return self._test_coarse_rasterize(torch.device("cpu")) + + def test_coarse_cuda(self): + return self._test_coarse_rasterize(torch.device("cuda:0")) + + def test_cpp_vs_cuda_naive_vs_cuda_binned(self): + # Make sure that the backward pass runs for all pathways + image_size = 64 # test is too slow for very large images. + N = 1 + radius = 0.1 ** 2 + faces_per_pixel = 3 + + grad_zbuf = torch.randn(N, image_size, image_size, faces_per_pixel) + grad_dist = torch.randn(N, image_size, image_size, faces_per_pixel) + grad_bary = torch.randn(N, image_size, image_size, faces_per_pixel, 3) + + device = torch.device("cpu") + meshes = ico_sphere(0, device) + verts, faces = meshes.get_mesh_verts_faces(0) + verts.requires_grad = True + meshes = Meshes(verts=[verts], faces=[faces]) + + # Option I: CPU, naive + args = (meshes, image_size, radius, faces_per_pixel) + idx1, zbuf1, bary1, dist1 = rasterize_meshes(*args) + + loss = ( + (zbuf1 * grad_zbuf).sum() + + (dist1 * grad_dist).sum() + + (bary1 * grad_bary).sum() + ) + loss.backward() + idx1 = idx1.data.cpu().clone() + zbuf1 = zbuf1.data.cpu().clone() + dist1 = dist1.data.cpu().clone() + grad1 = verts.grad.data.cpu().clone() + + # Option II: CUDA, naive + device = torch.device("cuda:0") + meshes = ico_sphere(0, device) + verts, faces = meshes.get_mesh_verts_faces(0) + verts.requires_grad = True + meshes = Meshes(verts=[verts], faces=[faces]) + + args = (meshes, image_size, radius, faces_per_pixel, 0, 0) + idx2, zbuf2, bary2, dist2 = rasterize_meshes(*args) + grad_zbuf = grad_zbuf.cuda() + grad_dist = grad_dist.cuda() + grad_bary = grad_bary.cuda() + loss = ( + (zbuf2 * grad_zbuf).sum() + + (dist2 * grad_dist).sum() + + (bary2 * grad_bary).sum() + ) + loss.backward() + idx2 = idx2.data.cpu().clone() + zbuf2 = zbuf2.data.cpu().clone() + dist2 = dist2.data.cpu().clone() + grad2 = verts.grad.data.cpu().clone() + + # Option III: CUDA, binned + device = torch.device("cuda:0") + meshes = ico_sphere(0, device) + verts, faces = meshes.get_mesh_verts_faces(0) + verts.requires_grad = True + meshes = Meshes(verts=[verts], faces=[faces]) + + args = (meshes, image_size, radius, faces_per_pixel, 32, 500) + idx3, zbuf3, bary3, dist3 = rasterize_meshes(*args) + + loss = ( + (zbuf3 * grad_zbuf).sum() + + (dist3 * grad_dist).sum() + + (bary3 * grad_bary).sum() + ) + loss.backward() + idx3 = idx3.data.cpu().clone() + zbuf3 = zbuf3.data.cpu().clone() + dist3 = dist3.data.cpu().clone() + grad3 = verts.grad.data.cpu().clone() + + # Make sure everything was the same + self.assertTrue((idx1 == idx2).all().item()) + self.assertTrue((idx1 == idx3).all().item()) + self.assertTrue(torch.allclose(zbuf1, zbuf2, atol=1e-6)) + self.assertTrue(torch.allclose(zbuf1, zbuf3, atol=1e-6)) + self.assertTrue(torch.allclose(dist1, dist2, atol=1e-6)) + self.assertTrue(torch.allclose(dist1, dist3, atol=1e-6)) + + self.assertTrue(torch.allclose(grad1, grad2, rtol=5e-3)) # flaky test + self.assertTrue(torch.allclose(grad1, grad3, rtol=5e-3)) + self.assertTrue(torch.allclose(grad2, grad3, rtol=5e-3)) + + def test_compare_coarse_cpu_vs_cuda(self): + torch.manual_seed(231) + N = 1 + image_size = 512 + blur_radius = 0.0 + bin_size = 32 + max_faces_per_bin = 20 + + device = torch.device("cpu") + meshes = ico_sphere(2, device) + + faces = meshes.faces_packed() + verts = meshes.verts_packed() + faces_verts = verts[faces] + num_faces_per_mesh = meshes.num_faces_per_mesh() + mesh_to_face_first_idx = meshes.mesh_to_faces_packed_first_idx() + args = ( + faces_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin, + ) + bin_faces_cpu = _C._rasterize_meshes_coarse(*args) + + device = torch.device("cuda:0") + meshes = ico_sphere(2, device) + + faces = meshes.faces_packed() + verts = meshes.verts_packed() + faces_verts = verts[faces] + num_faces_per_mesh = meshes.num_faces_per_mesh() + mesh_to_face_first_idx = meshes.mesh_to_faces_packed_first_idx() + args = ( + faces_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin, + ) + bin_faces_cuda = _C._rasterize_meshes_coarse(*args) + + # Bin faces might not be the same: CUDA version might write them in + # any order. But if we sort the non-(-1) elements of the CUDA output + # then they should be the same. + for n in range(N): + for by in range(bin_faces_cpu.shape[1]): + for bx in range(bin_faces_cpu.shape[2]): + K = (bin_faces_cuda[n, by, bx] != -1).sum().item() + idxs_cpu = bin_faces_cpu[n, by, bx].tolist() + idxs_cuda = bin_faces_cuda[n, by, bx].tolist() + idxs_cuda[:K] = sorted(idxs_cuda[:K]) + self.assertEqual(idxs_cpu, idxs_cuda) + + def test_python_vs_cpp_perspective_correct(self): + torch.manual_seed(232) + N = 2 + V = 10 + F = 5 + verts1 = torch.randn(N, V, 3, requires_grad=True) + verts2 = verts1.detach().clone().requires_grad_(True) + faces = torch.randint(V, size=(N, F, 3)) + meshes1 = Meshes(verts1, faces) + meshes2 = Meshes(verts2, faces) + + kwargs = {"image_size": 24, "perspective_correct": True} + fn1 = functools.partial(rasterize_meshes, meshes1, **kwargs) + fn2 = functools.partial(rasterize_meshes_python, meshes2, **kwargs) + args = () + self._compare_impls( + fn1, fn2, args, args, verts1, verts2, compare_grads=True + ) + + def test_cpp_vs_cuda_perspective_correct(self): + meshes = ico_sphere(2, device=torch.device("cpu")) + verts1, faces1 = meshes.get_mesh_verts_faces(0) + verts1.requires_grad = True + meshes1 = Meshes(verts=[verts1], faces=[faces1]) + verts2 = verts1.detach().cuda().requires_grad_(True) + faces2 = faces1.detach().clone().cuda() + meshes2 = Meshes(verts=[verts2], faces=[faces2]) + + kwargs = {"image_size": 64, "perspective_correct": True} + fn1 = functools.partial(rasterize_meshes, meshes1, **kwargs) + fn2 = functools.partial(rasterize_meshes, meshes2, bin_size=0, **kwargs) + args = () + self._compare_impls( + fn1, fn2, args, args, verts1, verts2, compare_grads=True + ) + + def test_cuda_naive_vs_binned_perspective_correct(self): + meshes = ico_sphere(2, device=torch.device("cuda")) + verts1, faces1 = meshes.get_mesh_verts_faces(0) + verts1.requires_grad = True + meshes1 = Meshes(verts=[verts1], faces=[faces1]) + verts2 = verts1.detach().clone().requires_grad_(True) + faces2 = faces1.detach().clone() + meshes2 = Meshes(verts=[verts2], faces=[faces2]) + + kwargs = {"image_size": 64, "perspective_correct": True} + fn1 = functools.partial(rasterize_meshes, meshes1, bin_size=0, **kwargs) + fn2 = functools.partial(rasterize_meshes, meshes2, bin_size=8, **kwargs) + args = () + self._compare_impls( + fn1, fn2, args, args, verts1, verts2, compare_grads=True + ) + + def _compare_impls( + self, + fn1, + fn2, + args1, + args2, + grad_var1=None, + grad_var2=None, + compare_grads=False, + ): + idx1, zbuf1, bary1, dist1 = fn1(*args1) + idx2, zbuf2, bary2, dist2 = fn2(*args2) + self.assertTrue((idx1.cpu() == idx2.cpu()).all().item()) + self.assertTrue(torch.allclose(zbuf1.cpu(), zbuf2.cpu(), rtol=1e-4)) + self.assertTrue(torch.allclose(dist1.cpu(), dist2.cpu(), rtol=6e-3)) + self.assertTrue(torch.allclose(bary1.cpu(), bary2.cpu(), rtol=1e-3)) + if not compare_grads: + return + + # Compare gradients. + torch.manual_seed(231) + grad_zbuf = torch.randn_like(zbuf1) + grad_dist = torch.randn_like(dist1) + grad_bary = torch.randn_like(bary1) + loss1 = ( + (dist1 * grad_dist).sum() + + (zbuf1 * grad_zbuf).sum() + + (bary1 * grad_bary).sum() + ) + loss1.backward() + grad_verts1 = grad_var1.grad.data.clone().cpu() + + grad_zbuf = grad_zbuf.to(zbuf2) + grad_dist = grad_dist.to(dist2) + grad_bary = grad_bary.to(bary2) + loss2 = ( + (dist2 * grad_dist).sum() + + (zbuf2 * grad_zbuf).sum() + + (bary2 * grad_bary).sum() + ) + grad_var1.grad.data.zero_() + loss2.backward() + grad_verts2 = grad_var2.grad.data.clone().cpu() + self.assertTrue(torch.allclose(grad_verts1, grad_verts2, rtol=1e-3)) + + def _test_perspective_correct( + self, rasterize_meshes_fn, device, bin_size=None + ): + # fmt: off + verts = torch.tensor([ + [-0.4, -0.4, 10], # noqa: E241, E201 + [ 0.4, -0.4, 10], # noqa: E241, E201 + [ 0.0, 0.4, 20], # noqa: E241, E201 + ], dtype=torch.float32, device=device) + # fmt: on + faces = torch.tensor([[0, 1, 2]], device=device) + meshes = Meshes(verts=[verts], faces=[faces]) + kwargs = { + "meshes": meshes, + "image_size": 11, + "faces_per_pixel": 1, + "blur_radius": 0.2, + "perspective_correct": False, + } + if bin_size != -1: + kwargs["bin_size"] = bin_size + + # Run with and without perspective correction + idx_f, zbuf_f, bary_f, dists_f = rasterize_meshes_fn(**kwargs) + kwargs["perspective_correct"] = True + idx_t, zbuf_t, bary_t, dists_t = rasterize_meshes_fn(**kwargs) + + # idx and dists should be the same with or without perspecitve correction + # fmt: off + idx_expected = torch.tensor([ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, 0, -1, -1], # noqa: E241, E201 + [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1], # noqa: E241, E201 + [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1], # noqa: E241, E201 + [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, 0, -1, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, 0, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0, 0, 0, 0, 0, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0, 0, 0, 0, 0, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0, 0, 0, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], dtype=torch.int64, device=device).view(1, 11, 11, 1) + dists_expected = torch.tensor([ + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 0.1283, 0.1071, 0.1071, 0.1071, 0.1071, 0.1071, 0.1283, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, 0.1283, 0.0423, 0.0212, 0.0212, 0.0212, 0.0212, 0.0212, 0.0423, 0.1283, -1.0000], # noqa: E241, E201 + [-1.0000, 0.1084, 0.0225, -0.0003, -0.0013, -0.0013, -0.0013, -0.0003, 0.0225, 0.1084, -1.0000], # noqa: E241, E201 + [-1.0000, 0.1523, 0.0518, 0.0042, -0.0095, -0.0476, -0.0095, 0.0042, 0.0518, 0.1523, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 0.0955, 0.0214, -0.0003, -0.0320, -0.0003, 0.0214, 0.0955, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 0.1523, 0.0518, 0.0042, -0.0095, 0.0042, 0.0518, 0.1523, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 0.0955, 0.0214, -0.0003, 0.0214, 0.0955, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 0.1523, 0.0542, 0.0212, 0.0542, 0.1523, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, 0.1402, 0.1071, 0.1402, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + ], dtype=torch.float32, device=device).view(1, 11, 11, 1) + + # zbuf and barycentric will be different with perspective correction + zbuf_f_expected = torch.tensor([ + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 5.9091, 5.9091, 5.9091, 5.9091, 5.9091, 5.9091, 5.9091, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, 8.1818, 8.1818, 8.1818, 8.1818, 8.1818, 8.1818, 8.1818, 8.1818, 8.1818, -1.0000], # noqa: E241, E201 + [-1.0000, 10.4545, 10.4545, 10.4545, 10.4545, 10.4545, 10.4545, 10.4545, 10.4545, 10.4545, -1.0000], # noqa: E241, E201 + [-1.0000, 12.7273, 12.7273, 12.7273, 12.7273, 12.7273, 12.7273, 12.7273, 12.7273, 12.7273, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 15.0000, 15.0000, 15.0000, 15.0000, 15.0000, 15.0000, 15.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 17.2727, 17.2727, 17.2727, 17.2727, 17.2727, 17.2727, 17.2727, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 19.5455, 19.5455, 19.5455, 19.5455, 19.5455, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 21.8182, 21.8182, 21.8182, 21.8182, 21.8182, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, 24.0909, 24.0909, 24.0909, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + ], dtype=torch.float32, device=device).view(1, 11, 11, 1) + zbuf_t_expected = torch.tensor([ + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 8.3019, 8.3019, 8.3019, 8.3019, 8.3019, 8.3019, 8.3019, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, 9.1667, 9.1667, 9.1667, 9.1667, 9.1667, 9.1667, 9.1667, 9.1667, 9.1667, -1.0000], # noqa: E241, E201 + [-1.0000, 10.2326, 10.2326, 10.2326, 10.2326, 10.2326, 10.2326, 10.2326, 10.2326, 10.2326, -1.0000], # noqa: E241, E201 + [-1.0000, 11.5789, 11.5789, 11.5789, 11.5789, 11.5789, 11.5789, 11.5789, 11.5789, 11.5789, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 13.3333, 13.3333, 13.3333, 13.3333, 13.3333, 13.3333, 13.3333, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, 15.7143, 15.7143, 15.7143, 15.7143, 15.7143, 15.7143, 15.7143, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 19.1304, 19.1304, 19.1304, 19.1304, 19.1304, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, 24.4444, 24.4444, 24.4444, 24.4444, 24.4444, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, 33.8462, 33.8462, 33.8461, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + [-1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000, -1.0000], # noqa: E241, E201 + ], dtype=torch.float32, device=device).view(1, 11, 11, 1) + # fmt: on + + self.assertTrue(torch.all(idx_f == idx_expected).item()) + self.assertTrue(torch.all(idx_t == idx_expected).item()) + dists_t_max_diff = (dists_t - dists_expected).abs().max().item() + dists_f_max_diff = (dists_f - dists_expected).abs().max().item() + self.assertLess(dists_t_max_diff, 1e-4) + self.assertLess(dists_f_max_diff, 1e-4) + zbuf_f_max_diff = (zbuf_f - zbuf_f_expected).abs().max().item() + zbuf_t_max_diff = (zbuf_t - zbuf_t_expected).abs().max().item() + self.assertLess(zbuf_f_max_diff, 1e-4) + self.assertLess(zbuf_t_max_diff, 1e-4) + + # Check barycentrics by using them to re-compute zbuf + z0 = verts[0, 2] + z1 = verts[1, 2] + z2 = verts[2, 2] + w0_f, w1_f, w2_f = bary_f.unbind(dim=4) + w0_t, w1_t, w2_t = bary_t.unbind(dim=4) + zbuf_f_bary = w0_f * z0 + w1_f * z1 + w2_f * z2 + zbuf_t_bary = w0_t * z0 + w1_t * z1 + w2_t * z2 + mask = idx_expected != -1 + zbuf_f_bary_diff = ( + (zbuf_f_bary[mask] - zbuf_f_expected[mask]).abs().max() + ) + zbuf_t_bary_diff = ( + (zbuf_t_bary[mask] - zbuf_t_expected[mask]).abs().max() + ) + self.assertLess(zbuf_f_bary_diff, 1e-4) + self.assertLess(zbuf_t_bary_diff, 1e-4) + + def _test_behind_camera(self, rasterize_meshes_fn, device, bin_size=None): + """ + All verts are behind the camera so nothing should get rasterized. + """ + N = 1 + # fmt: off + verts = torch.tensor( + [ + [ -0.5, 0.0, -0.1], # noqa: E241, E201 + [ 0.0, 0.6, -0.1], # noqa: E241, E201 + [ 0.5, 0.0, -0.1], # noqa: E241, E201 + [-0.25, 0.0, -0.9], # noqa: E241, E201 + [ 0.25, 0.5, -0.9], # noqa: E241, E201 + [ 0.75, 0.0, -0.9], # noqa: E241, E201 + [ -0.4, 0.0, -0.5], # noqa: E241, E201 + [ 0.6, 0.6, -0.5], # noqa: E241, E201 + [ 0.8, 0.0, -0.5], # noqa: E241, E201 + [ -0.2, 0.0, -0.5], # noqa: E241, E201 + [ 0.3, 0.6, -0.5], # noqa: E241, E201 + [ 0.4, 0.0, -0.5], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + ) + # fmt: on + faces = torch.tensor( + [[1, 0, 2], [4, 3, 5], [7, 6, 8], [10, 9, 11]], + dtype=torch.int64, + device=device, + ) + meshes = Meshes(verts=[verts], faces=[faces]) + image_size = 16 + faces_per_pixel = 1 + radius = 0.2 + idx_expected = torch.full( + (N, image_size, image_size, faces_per_pixel), + fill_value=-1, + dtype=torch.int64, + device=device, + ) + bary_expected = torch.full( + (N, image_size, image_size, faces_per_pixel, 3), + fill_value=-1, + dtype=torch.float32, + device=device, + ) + zbuf_expected = torch.full( + (N, image_size, image_size, faces_per_pixel), + fill_value=-1, + dtype=torch.float32, + device=device, + ) + dists_expected = zbuf_expected.clone() + if bin_size == -1: + # naive python version with no binning + idx, zbuf, bary, dists = rasterize_meshes_fn( + meshes, image_size, radius, faces_per_pixel + ) + else: + idx, zbuf, bary, dists = rasterize_meshes_fn( + meshes, image_size, radius, faces_per_pixel, bin_size + ) + idx_same = (idx == idx_expected).all().item() + zbuf_same = (zbuf == zbuf_expected).all().item() + self.assertTrue(idx_same) + self.assertTrue(zbuf_same) + self.assertTrue(torch.allclose(bary, bary_expected)) + self.assertTrue(torch.allclose(dists, dists_expected)) + + def _simple_triangle_raster(self, raster_fn, device, bin_size=None): + image_size = 10 + + # Mesh with a single face. + verts0 = torch.tensor( + [[-0.7, -0.4, 0.1], [0.0, 0.6, 0.1], [0.7, -0.4, 0.1]], + dtype=torch.float32, + device=device, + ) + faces0 = torch.tensor([[1, 0, 2]], dtype=torch.int64, device=device) + + # Mesh with two overlapping faces. + # fmt: off + verts1 = torch.tensor( + [ + [-0.7, -0.4, 0.1], # noqa: E241, E201 + [ 0.0, 0.6, 0.1], # noqa: E241, E201 + [ 0.7, -0.4, 0.1], # noqa: E241, E201 + [-0.7, 0.4, 0.5], # noqa: E241, E201 + [ 0.0, -0.6, 0.5], # noqa: E241, E201 + [ 0.7, 0.4, 0.5], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + ) + # fmt on + faces1 = torch.tensor( + [[1, 0, 2], [3, 4, 5]], dtype=torch.int64, device=device + ) + + # fmt off + expected_p2face_k0 = torch.tensor( + [ + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0, 0, 0, 0, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0, 0, 0, 0, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0, 0, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 1, 1, 1, 1, 1, 1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 1, 1, 1, 1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 1, 1, 1, 1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 2, 2, 1, 1, 2, 2, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + ], + dtype=torch.int64, + device=device, + ) + expected_zbuf_k0 = torch.tensor( + [ + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.1, 0.1, 0.1, 0.1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.1, 0.1, 0.1, 0.1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0.1, 0.1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.1, 0.1, 0.1, 0.1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.1, 0.1, 0.1, 0.1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0.5, 0.5, 0.1, 0.1, 0.5, 0.5, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + ], + device=device, + ) + # fmt: on + + meshes = Meshes(verts=[verts0, verts1], faces=[faces0, faces1]) + if bin_size == -1: + # simple python case with no binning + p2face, zbuf, bary, pix_dists = raster_fn( + meshes, image_size, 0.0, 2 + ) + else: + p2face, zbuf, bary, pix_dists = raster_fn( + meshes, image_size, 0.0, 2, bin_size + ) + # k = 0, closest point. + self.assertTrue(torch.allclose(p2face[..., 0], expected_p2face_k0)) + self.assertTrue(torch.allclose(zbuf[..., 0], expected_zbuf_k0)) + + # k = 1, second closest point. + expected_p2face_k1 = expected_p2face_k0.clone() + expected_p2face_k1[0, :] = ( + torch.ones_like(expected_p2face_k1[0, :]) * -1 + ) + + # fmt: off + expected_p2face_k1[1, :] = torch.tensor( + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 2, 2, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 2, 2, 2, 2, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 2, 2, 2, 2, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 2, 2, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + dtype=torch.int64, + device=device, + ) + expected_zbuf_k1 = expected_zbuf_k0.clone() + expected_zbuf_k1[0, :] = torch.ones_like(expected_zbuf_k1[0, :]) * -1 + expected_zbuf_k1[1, :] = torch.tensor( + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0.5, 0.5, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.5, 0.5, 0.5, 0.5, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, 0.5, 0.5, 0.5, 0.5, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0.5, 0.5, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + ) + # fmt: on + self.assertTrue(torch.allclose(p2face[..., 1], expected_p2face_k1)) + self.assertTrue(torch.allclose(zbuf[..., 1], expected_zbuf_k1)) + + def _simple_blurry_raster(self, raster_fn, device, bin_size=None): + """ + Check that pix_to_face, dist and zbuf values are invariant to the + ordering of faces. + """ + image_size = 10 + blur_radius = 0.12 ** 2 + faces_per_pixel = 1 + + # fmt: off + verts = torch.tensor( + [ + [ -0.5, 0.0, 0.1], # noqa: E241, E201 + [ 0.0, 0.6, 0.1], # noqa: E241, E201 + [ 0.5, 0.0, 0.1], # noqa: E241, E201 + [-0.25, 0.0, 0.9], # noqa: E241, E201 + [0.25, 0.5, 0.9], # noqa: E241, E201 + [0.75, 0.0, 0.9], # noqa: E241, E201 + [-0.4, 0.0, 0.5], # noqa: E241, E201 + [ 0.6, 0.6, 0.5], # noqa: E241, E201 + [ 0.8, 0.0, 0.5], # noqa: E241, E201 + [-0.2, 0.0, -0.5], # noqa: E241, E201 face behind the camera + [ 0.3, 0.6, -0.5], # noqa: E241, E201 + [ 0.4, 0.0, -0.5], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + ) + faces_packed = torch.tensor( + [[1, 0, 2], [4, 3, 5], [7, 6, 8], [10, 9, 11]], + dtype=torch.int64, + device=device, + ) + expected_p2f = torch.tensor( + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, 2, -1], # noqa: E241, E201 + [-1, -1, 0, 0, 0, 0, 0, 0, 2, -1], # noqa: E241, E201 + [-1, -1, -1, 0, 0, 0, 0, 2, 2, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0, 0, 2, 2, 2, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + dtype=torch.int64, + device=device, + ) + expected_zbuf = torch.tensor( + [ + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.5, -1], # noqa: E241, E201 + [-1, -1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.5, -1], # noqa: E241, E201 + [-1, -1, -1, 0.1, 0.1, 0.1, 0.1, 0.5, 0.5, -1], # noqa: E241, E201 + [-1, -1, -1, -1, 0.1, 0.1, 0.5, 0.5, 0.5, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], # noqa: E241, E201 + ], + dtype=torch.float32, + device=device, + ) + # fmt: on + + for i, order in enumerate([[0, 1, 2], [1, 2, 0], [2, 0, 1]]): + faces = faces_packed[order] # rearrange order of faces. + mesh = Meshes(verts=[verts], faces=[faces]) + if bin_size == -1: + # simple python case with no binning + pix_to_face, zbuf, bary_coords, dists = raster_fn( + mesh, image_size, blur_radius, faces_per_pixel + ) + else: + pix_to_face, zbuf, bary_coords, dists = raster_fn( + mesh, image_size, blur_radius, faces_per_pixel, bin_size + ) + + if i == 0: + expected_dists = dists + p2f = expected_p2f.clone() + p2f[expected_p2f == 0] = order.index(0) + p2f[expected_p2f == 1] = order.index(1) + p2f[expected_p2f == 2] = order.index(2) + + self.assertTrue(torch.allclose(pix_to_face.squeeze(), p2f)) + self.assertTrue( + torch.allclose(zbuf.squeeze(), expected_zbuf, rtol=1e-5) + ) + self.assertTrue(torch.allclose(dists, expected_dists)) + + def _test_coarse_rasterize(self, device): + image_size = 16 + blur_radius = 0.2 ** 2 + bin_size = 8 + max_faces_per_bin = 3 + + # fmt: off + verts = torch.tensor( + [ + [-0.5, 0.0, 0.1], # noqa: E241, E201 + [ 0.0, 0.6, 0.1], # noqa: E241, E201 + [ 0.5, 0.0, 0.1], # noqa: E241, E201 + [-0.3, 0.0, 0.4], # noqa: E241, E201 + [ 0.3, 0.5, 0.4], # noqa: E241, E201 + [0.75, 0.0, 0.4], # noqa: E241, E201 + [-0.4, -0.3, 0.9], # noqa: E241, E201 + [ 0.2, -0.7, 0.9], # noqa: E241, E201 + [ 0.4, -0.3, 0.9], # noqa: E241, E201 + [-0.4, 0.0, -1.5], # noqa: E241, E201 + [ 0.6, 0.6, -1.5], # noqa: E241, E201 + [ 0.8, 0.0, -1.5], # noqa: E241, E201 + ], + device=device, + ) + faces = torch.tensor( + [ + [ 1, 0, 2], # noqa: E241, E201 bin 00 and bin 01 + [ 4, 3, 5], # noqa: E241, E201 bin 00 and bin 01 + [ 7, 6, 8], # noqa: E241, E201 bin 10 and bin 11 + [10, 9, 11], # noqa: E241, E201 negative z, should not appear. + ], + dtype=torch.int64, + device=device, + ) + # fmt: on + + meshes = Meshes(verts=[verts], faces=[faces]) + faces_verts = verts[faces] + num_faces_per_mesh = meshes.num_faces_per_mesh() + mesh_to_face_first_idx = meshes.mesh_to_faces_packed_first_idx() + + bin_faces_expected = ( + torch.ones( + (1, 2, 2, max_faces_per_bin), dtype=torch.int32, device=device + ) + * -1 + ) + bin_faces_expected[0, 0, 0, 0:2] = torch.tensor([0, 1]) + bin_faces_expected[0, 0, 1, 0:2] = torch.tensor([0, 1]) + bin_faces_expected[0, 1, 0, 0:3] = torch.tensor([0, 1, 2]) + bin_faces_expected[0, 1, 1, 0:3] = torch.tensor([0, 1, 2]) + bin_faces = _C._rasterize_meshes_coarse( + faces_verts, + mesh_to_face_first_idx, + num_faces_per_mesh, + image_size, + blur_radius, + bin_size, + max_faces_per_bin, + ) + bin_faces_same = ( + bin_faces.squeeze().flip(dims=[0]) == bin_faces_expected + ).all() + self.assertTrue(bin_faces_same.item() == 1) + + @staticmethod + def rasterize_meshes_python_with_init( + num_meshes: int, ico_level: int, image_size: int, blur_radius: float + ): + device = torch.device("cpu") + meshes = ico_sphere(ico_level, device) + meshes_batch = meshes.extend(num_meshes) + + def rasterize(): + rasterize_meshes_python(meshes_batch, image_size, blur_radius) + + return rasterize + + @staticmethod + def rasterize_meshes_cpu_with_init( + num_meshes: int, ico_level: int, image_size: int, blur_radius: float + ): + meshes = ico_sphere(ico_level, torch.device("cpu")) + meshes_batch = meshes.extend(num_meshes) + + def rasterize(): + rasterize_meshes(meshes_batch, image_size, blur_radius, bin_size=0) + + return rasterize + + @staticmethod + def rasterize_meshes_cuda_with_init( + num_meshes: int, + ico_level: int, + image_size: int, + blur_radius: float, + bin_size: int, + max_faces_per_bin: int, + ): + + meshes = ico_sphere(ico_level, torch.device("cuda:0")) + meshes_batch = meshes.extend(num_meshes) + torch.cuda.synchronize() + + def rasterize(): + rasterize_meshes( + meshes_batch, + image_size, + blur_radius, + 8, + bin_size, + max_faces_per_bin, + ) + torch.cuda.synchronize() + + return rasterize diff --git a/tests/test_rasterizer.py b/tests/test_rasterizer.py new file mode 100644 index 00000000..88083732 --- /dev/null +++ b/tests/test_rasterizer.py @@ -0,0 +1,109 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +import unittest +from pathlib import Path +import torch +from PIL import Image + +from pytorch3d.renderer.cameras import ( + OpenGLPerspectiveCameras, + look_at_view_transform, +) +from pytorch3d.renderer.mesh.rasterizer import ( + MeshRasterizer, + RasterizationSettings, +) +from pytorch3d.utils.ico_sphere import ico_sphere + +DATA_DIR = Path(__file__).resolve().parent / "data" +DEBUG = False # Set DEBUG to true to save outputs from the tests. + + +def convert_image_to_binary_mask(filename): + with Image.open(filename) as raw_image: + image = torch.from_numpy(np.array(raw_image)) + min = image.min() + max = image.max() + image_norm = (image - min) / (max - min) + image_norm[image_norm > 0] == 1.0 + image_norm = image_norm.to(torch.int64) + return image_norm + + +class TestMeshRasterizer(unittest.TestCase): + def test_simple_sphere(self): + device = torch.device("cuda:0") + ref_filename = "test_rasterized_sphere.png" + image_ref_filename = DATA_DIR / ref_filename + + # Rescale image_ref to the 0 - 1 range and convert to a binary mask. + image_ref = convert_image_to_binary_mask(image_ref_filename) + + # Init mesh + sphere_mesh = ico_sphere(5, device) + + # Init rasterizer settings + R, T = look_at_view_transform(2.7, 0, 0) + cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + raster_settings = RasterizationSettings( + image_size=512, blur_radius=0.0, faces_per_pixel=1, bin_size=0 + ) + + # Init rasterizer + rasterizer = MeshRasterizer( + cameras=cameras, raster_settings=raster_settings + ) + + #################################### + # 1. Test rasterizing a single mesh + #################################### + + fragments = rasterizer(sphere_mesh) + image = fragments.pix_to_face[0, ..., 0].squeeze().cpu() + # Convert pix_to_face to a binary mask + image[image >= 0] = 1.0 + image[image < 0] = 0.0 + + if DEBUG: + Image.fromarray((image.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_test_rasterized_sphere.png" + ) + + self.assertTrue(torch.allclose(image, image_ref)) + + ################################## + # 2. Test with a batch of meshes + ################################## + + batch_size = 10 + sphere_meshes = sphere_mesh.extend(batch_size) + fragments = rasterizer(sphere_meshes) + for i in range(batch_size): + image = fragments.pix_to_face[i, ..., 0].squeeze().cpu() + image[image >= 0] = 1.0 + image[image < 0] = 0.0 + self.assertTrue(torch.allclose(image, image_ref)) + + #################################################### + # 3. Test that passing kwargs to rasterizer works. + #################################################### + + # Change the view transform to zoom in. + R, T = look_at_view_transform(2.0, 0, 0, device=device) + fragments = rasterizer(sphere_mesh, R=R, T=T) + image = fragments.pix_to_face[0, ..., 0].squeeze().cpu() + image[image >= 0] = 1.0 + image[image < 0] = 0.0 + + ref_filename = "test_rasterized_sphere_zoom.png" + image_ref_filename = DATA_DIR / ref_filename + image_ref = convert_image_to_binary_mask(image_ref_filename) + + if DEBUG: + Image.fromarray((image.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_test_rasterized_sphere_zoom.png" + ) + self.assertTrue(torch.allclose(image, image_ref)) diff --git a/tests/test_rendering_meshes.py b/tests/test_rendering_meshes.py new file mode 100644 index 00000000..b3cb1966 --- /dev/null +++ b/tests/test_rendering_meshes.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +""" +Sanity checks for output images from the renderer. +""" +import numpy as np +import unittest +from pathlib import Path +import torch +from PIL import Image + +from pytorch3d.io import load_obj +from pytorch3d.renderer.cameras import ( + OpenGLPerspectiveCameras, + look_at_view_transform, +) +from pytorch3d.renderer.lighting import PointLights +from pytorch3d.renderer.materials import Materials +from pytorch3d.renderer.mesh.rasterizer import ( + MeshRasterizer, + RasterizationSettings, +) +from pytorch3d.renderer.mesh.renderer import MeshRenderer +from pytorch3d.renderer.mesh.shader import ( + BlendParams, + GouradShader, + PhongShader, + SilhouetteShader, + TexturedPhongShader, +) +from pytorch3d.renderer.mesh.texturing import Textures +from pytorch3d.structures.meshes import Meshes +from pytorch3d.utils.ico_sphere import ico_sphere + +# Save out images generated in the tests for debugging +# All saved images have prefix DEBUG_ +DEBUG = False +DATA_DIR = Path(__file__).resolve().parent / "data" + + +def load_rgb_image(filename, data_dir=DATA_DIR): + filepath = data_dir / filename + with Image.open(filepath) as raw_image: + image = torch.from_numpy(np.array(raw_image) / 255.0) + image = image.to(dtype=torch.float32) + return image[..., :3] + + +class TestRenderingMeshes(unittest.TestCase): + def test_simple_sphere(self, elevated_camera=False): + """ + Test output of phong and gourad shading matches a reference image using + the default values for the light sources. + + Args: + elevated_camera: Defines whether the camera observing the scene should + have an elevation of 45 degrees. + """ + device = torch.device("cuda:0") + + # Init mesh + sphere_mesh = ico_sphere(5, device) + verts_padded = sphere_mesh.verts_padded() + faces_padded = sphere_mesh.faces_padded() + textures = Textures(verts_rgb=torch.ones_like(verts_padded)) + sphere_mesh = Meshes( + verts=verts_padded, faces=faces_padded, textures=textures + ) + + # Init rasterizer settings + if elevated_camera: + R, T = look_at_view_transform(2.7, 45.0, 0.0) + postfix = "_elevated_camera" + else: + R, T = look_at_view_transform(2.7, 0.0, 0.0) + postfix = "" + cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + raster_settings = RasterizationSettings( + image_size=512, blur_radius=0.0, faces_per_pixel=1, bin_size=0 + ) + + # Init shader settings + materials = Materials(device=device) + lights = PointLights(device=device) + lights.location = torch.tensor([0.0, 0.0, -2.0], device=device)[None] + + # Init renderer + rasterizer = MeshRasterizer( + cameras=cameras, raster_settings=raster_settings + ) + renderer = MeshRenderer( + rasterizer=rasterizer, + shader=PhongShader( + lights=lights, cameras=cameras, materials=materials + ), + ) + images = renderer(sphere_mesh) + rgb = images[0, ..., :3].squeeze().cpu() + if DEBUG: + Image.fromarray((rgb.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_simple_sphere_light%s.png" % postfix + ) + + # Load reference image + image_ref_phong = load_rgb_image( + "test_simple_sphere_illuminated%s.png" % postfix + ) + self.assertTrue(torch.allclose(rgb, image_ref_phong, atol=0.05)) + + ################################### + # Move the light behind the object + ################################### + # Check the image is dark + lights.location[..., 2] = +2.0 + images = renderer(sphere_mesh, lights=lights) + rgb = images[0, ..., :3].squeeze().cpu() + if DEBUG: + Image.fromarray((rgb.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_simple_sphere_dark%s.png" % postfix + ) + + # Load reference image + image_ref_phong_dark = load_rgb_image( + "test_simple_sphere_dark%s.png" % postfix + ) + self.assertTrue(torch.allclose(rgb, image_ref_phong_dark, atol=0.05)) + + ###################################### + # Change the shader to a GouradShader + ###################################### + lights.location = torch.tensor([0.0, 0.0, -2.0], device=device)[None] + renderer = MeshRenderer( + rasterizer=rasterizer, + shader=GouradShader( + lights=lights, cameras=cameras, materials=materials + ), + ) + images = renderer(sphere_mesh) + rgb = images[0, ..., :3].squeeze().cpu() + if DEBUG: + Image.fromarray((rgb.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_simple_sphere_light_gourad%s.png" % postfix + ) + + # Load reference image + image_ref_gourad = load_rgb_image( + "test_simple_sphere_light_gourad%s.png" % postfix + ) + self.assertTrue(torch.allclose(rgb, image_ref_gourad, atol=0.005)) + self.assertFalse(torch.allclose(rgb, image_ref_phong, atol=0.005)) + + def test_simple_sphere_elevated_camera(self): + """ + Test output of phong and gourad shading matches a reference image using + the default values for the light sources. + + The rendering is performed with a camera that has non-zero elevation. + """ + self.test_simple_sphere(elevated_camera=True) + + def test_simple_sphere_batched(self): + """ + Test output of phong shading matches a reference image using + the default values for the light sources. + """ + batch_size = 5 + device = torch.device("cuda:0") + + # Init mesh + sphere_meshes = ico_sphere(5, device).extend(batch_size) + verts_padded = sphere_meshes.verts_padded() + faces_padded = sphere_meshes.faces_padded() + textures = Textures(verts_rgb=torch.ones_like(verts_padded)) + sphere_meshes = Meshes( + verts=verts_padded, faces=faces_padded, textures=textures + ) + + # Init rasterizer settings + dist = torch.tensor([2.7]).repeat(batch_size).to(device) + elev = torch.zeros_like(dist) + azim = torch.zeros_like(dist) + R, T = look_at_view_transform(dist, elev, azim) + cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + raster_settings = RasterizationSettings( + image_size=512, blur_radius=0.0, faces_per_pixel=1, bin_size=0 + ) + + # Init shader settings + materials = Materials(device=device) + lights = PointLights(device=device) + lights.location = torch.tensor([0.0, 0.0, -2.0], device=device)[None] + + # Init renderer + renderer = MeshRenderer( + rasterizer=MeshRasterizer( + cameras=cameras, raster_settings=raster_settings + ), + shader=PhongShader( + lights=lights, cameras=cameras, materials=materials + ), + ) + images = renderer(sphere_meshes) + + # Load ref image + image_ref = load_rgb_image("test_simple_sphere_illuminated.png") + + for i in range(batch_size): + rgb = images[i, ..., :3].squeeze().cpu() + if DEBUG: + Image.fromarray((rgb.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / f"DEBUG_simple_sphere_{i}.png" + ) + self.assertTrue(torch.allclose(rgb, image_ref, atol=0.05)) + + def test_silhouette_with_grad(self): + """ + Test silhouette blending. Also check that gradient calculation works. + """ + device = torch.device("cuda:0") + ref_filename = "test_silhouette.png" + image_ref_filename = DATA_DIR / ref_filename + sphere_mesh = ico_sphere(5, device) + verts, faces = sphere_mesh.get_mesh_verts_faces(0) + sphere_mesh = Meshes(verts=[verts], faces=[faces]) + + blend_params = BlendParams(sigma=1e-4, gamma=1e-4) + raster_settings = RasterizationSettings( + image_size=512, + blur_radius=np.log(1.0 / 1e-4 - 1.0) * blend_params.sigma, + faces_per_pixel=80, + bin_size=0, + ) + + # Init rasterizer settings + R, T = look_at_view_transform(2.7, 10, 20) + cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + + # Init renderer + renderer = MeshRenderer( + rasterizer=MeshRasterizer( + cameras=cameras, raster_settings=raster_settings + ), + shader=SilhouetteShader(blend_params=blend_params), + ) + images = renderer(sphere_mesh) + alpha = images[0, ..., 3].squeeze().cpu() + if DEBUG: + Image.fromarray((alpha.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_silhouette_grad.png" + ) + + with Image.open(image_ref_filename) as raw_image_ref: + image_ref = torch.from_numpy(np.array(raw_image_ref)) + image_ref = image_ref.to(dtype=torch.float32) / 255.0 + self.assertTrue(torch.allclose(alpha, image_ref, atol=0.055)) + + # Check grad exist + verts.requires_grad = True + sphere_mesh = Meshes(verts=[verts], faces=[faces]) + images = renderer(sphere_mesh) + images[0, ...].sum().backward() + self.assertIsNotNone(verts.grad) + + def test_texture_map(self): + """ + Test a mesh with a texture map is loaded and rendered correctly + """ + device = torch.device("cuda:0") + DATA_DIR = ( + Path(__file__).resolve().parent.parent / "docs/tutorials/data" + ) + obj_filename = DATA_DIR / "cow_mesh/cow.obj" + + # Load mesh + texture + verts, faces, aux = load_obj(obj_filename) + faces_idx = faces.verts_idx.to(device) + verts = verts.to(device) + texture_uvs = aux.verts_uvs + materials = aux.material_colors + tex_maps = aux.texture_images + + # tex_maps is a dictionary of material names as keys and texture images + # as values. Only need the images for this example. + textures = Textures( + maps=list(tex_maps.values()), + faces_uvs=faces.textures_idx.to(torch.int64).to(device)[None, :], + verts_uvs=texture_uvs.to(torch.float32).to(device)[None, :], + ) + mesh = Meshes(verts=[verts], faces=[faces_idx], textures=textures) + + # Init rasterizer settings + R, T = look_at_view_transform(2.7, 10, 20) + cameras = OpenGLPerspectiveCameras(device=device, R=R, T=T) + raster_settings = RasterizationSettings( + image_size=512, blur_radius=0.0, faces_per_pixel=1, bin_size=0 + ) + + # Init shader settings + materials = Materials(device=device) + lights = PointLights(device=device) + lights.location = torch.tensor([0.0, 0.0, -2.0], device=device)[None] + raster_settings = RasterizationSettings( + image_size=512, blur_radius=0.0, faces_per_pixel=1, bin_size=0 + ) + + # Init renderer + renderer = MeshRenderer( + rasterizer=MeshRasterizer( + cameras=cameras, raster_settings=raster_settings + ), + shader=TexturedPhongShader( + lights=lights, cameras=cameras, materials=materials + ), + ) + images = renderer(mesh) + rgb = images[0, ..., :3].squeeze().cpu() + + # Load reference image + image_ref = load_rgb_image("test_texture_map.png") + + if DEBUG: + Image.fromarray((rgb.numpy() * 255).astype(np.uint8)).save( + DATA_DIR / "DEBUG_texture_map.png" + ) + + # There's a calculation instability on the corner of the ear of the cow. + # We ignore that pixel. + image_ref[137, 166] = 0 + rgb[137, 166] = 0 + + self.assertTrue(torch.allclose(rgb, image_ref, atol=0.05)) + + # Check grad exists + verts = verts.clone() + verts.requires_grad = True + mesh = Meshes(verts=[verts], faces=[faces_idx], textures=textures) + images = renderer(mesh) + images[0, ...].sum().backward() + self.assertIsNotNone(verts.grad) diff --git a/tests/test_rotation_conversions.py b/tests/test_rotation_conversions.py new file mode 100644 index 00000000..4f35d8c9 --- /dev/null +++ b/tests/test_rotation_conversions.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved + + +import itertools +import math +import unittest +import torch + +from pytorch3d.transforms.rotation_conversions import ( + euler_angles_to_matrix, + matrix_to_euler_angles, + matrix_to_quaternion, + quaternion_apply, + quaternion_multiply, + quaternion_to_matrix, + random_quaternions, + random_rotation, + random_rotations, +) + + +class TestRandomRotation(unittest.TestCase): + def setUp(self) -> None: + super().setUp() + torch.manual_seed(1) + + def test_random_rotation_invariant(self): + """The image of the x-axis isn't biased among quadrants.""" + N = 1000 + base = random_rotation() + quadrants = list(itertools.product([False, True], repeat=3)) + + matrices = random_rotations(N) + transformed = torch.matmul(base, matrices) + transformed2 = torch.matmul(matrices, base) + + for k, results in enumerate([matrices, transformed, transformed2]): + counts = {i: 0 for i in quadrants} + for j in range(N): + counts[tuple(i.item() > 0 for i in results[j, 0])] += 1 + average = N / 8.0 + counts_tensor = torch.tensor(list(counts.values())) + chisquare_statistic = torch.sum( + (counts_tensor - average) * (counts_tensor - average) / average + ) + # The 0.1 significance level for chisquare(8-1) is + # scipy.stats.chi2(7).ppf(0.9) == 12.017. + self.assertLess( + chisquare_statistic, 12, (counts, chisquare_statistic, k) + ) + + +class TestRotationConversion(unittest.TestCase): + def setUp(self) -> None: + super().setUp() + torch.manual_seed(1) + + def test_from_quat(self): + """quat -> mtx -> quat""" + data = random_quaternions(13, dtype=torch.float64) + mdata = matrix_to_quaternion(quaternion_to_matrix(data)) + self.assertTrue(torch.allclose(data, mdata)) + + def test_to_quat(self): + """mtx -> quat -> mtx""" + data = random_rotations(13, dtype=torch.float64) + mdata = quaternion_to_matrix(matrix_to_quaternion(data)) + self.assertTrue(torch.allclose(data, mdata)) + + def test_quat_grad_exists(self): + """Quaternion calculations are differentiable.""" + rotation = random_rotation(requires_grad=True) + modified = quaternion_to_matrix(matrix_to_quaternion(rotation)) + [g] = torch.autograd.grad(modified.sum(), rotation) + self.assertTrue(torch.isfinite(g).all()) + + def _tait_bryan_conventions(self): + return map("".join, itertools.permutations("XYZ")) + + def _proper_euler_conventions(self): + letterpairs = itertools.permutations("XYZ", 2) + return (l0 + l1 + l0 for l0, l1 in letterpairs) + + def _all_euler_angle_conventions(self): + return itertools.chain( + self._tait_bryan_conventions(), self._proper_euler_conventions() + ) + + def test_conventions(self): + """The conventions listings have the right length.""" + all = list(self._all_euler_angle_conventions()) + self.assertEqual(len(all), 12) + self.assertEqual(len(set(all)), 12) + + def test_from_euler(self): + """euler -> mtx -> euler""" + n_repetitions = 10 + # tolerance is how much we keep the middle angle away from the extreme + # allowed values which make the calculation unstable (Gimbal lock). + tolerance = 0.04 + half_pi = math.pi / 2 + data = torch.zeros(n_repetitions, 3) + data.uniform_(-math.pi, math.pi) + + data[:, 1].uniform_(-half_pi + tolerance, half_pi - tolerance) + for convention in self._tait_bryan_conventions(): + matrices = euler_angles_to_matrix(data, convention) + mdata = matrix_to_euler_angles(matrices, convention) + self.assertTrue(torch.allclose(data, mdata)) + + data[:, 1] += half_pi + for convention in self._proper_euler_conventions(): + matrices = euler_angles_to_matrix(data, convention) + mdata = matrix_to_euler_angles(matrices, convention) + self.assertTrue(torch.allclose(data, mdata)) + + def test_to_euler(self): + """mtx -> euler -> mtx""" + data = random_rotations(13, dtype=torch.float64) + + for convention in self._all_euler_angle_conventions(): + euler_angles = matrix_to_euler_angles(data, convention) + mdata = euler_angles_to_matrix(euler_angles, convention) + self.assertTrue(torch.allclose(data, mdata)) + + def test_euler_grad_exists(self): + """Euler angle calculations are differentiable.""" + rotation = random_rotation(dtype=torch.float64, requires_grad=True) + for convention in self._all_euler_angle_conventions(): + euler_angles = matrix_to_euler_angles(rotation, convention) + mdata = euler_angles_to_matrix(euler_angles, convention) + [g] = torch.autograd.grad(mdata.sum(), rotation) + self.assertTrue(torch.isfinite(g).all()) + + def test_quaternion_multiplication(self): + """Quaternion and matrix multiplication are equivalent.""" + a = random_quaternions(15, torch.float64).reshape((3, 5, 4)) + b = random_quaternions(21, torch.float64).reshape((7, 3, 1, 4)) + ab = quaternion_multiply(a, b) + self.assertEqual(ab.shape, (7, 3, 5, 4)) + a_matrix = quaternion_to_matrix(a) + b_matrix = quaternion_to_matrix(b) + ab_matrix = torch.matmul(a_matrix, b_matrix) + ab_from_matrix = matrix_to_quaternion(ab_matrix) + self.assertEqual(ab.shape, ab_from_matrix.shape) + self.assertTrue(torch.allclose(ab, ab_from_matrix)) + + def test_quaternion_application(self): + """Applying a quaternion is the same as applying the matrix.""" + quaternions = random_quaternions(3, torch.float64, requires_grad=True) + matrices = quaternion_to_matrix(quaternions) + points = torch.randn(3, 3, dtype=torch.float64, requires_grad=True) + transform1 = quaternion_apply(quaternions, points) + transform2 = torch.matmul(matrices, points[..., None])[..., 0] + self.assertTrue(torch.allclose(transform1, transform2)) + + [p, q] = torch.autograd.grad(transform1.sum(), [points, quaternions]) + self.assertTrue(torch.isfinite(p).all()) + self.assertTrue(torch.isfinite(q).all()) diff --git a/tests/test_sample_points_from_meshes.py b/tests/test_sample_points_from_meshes.py new file mode 100644 index 00000000..0f633def --- /dev/null +++ b/tests/test_sample_points_from_meshes.py @@ -0,0 +1,473 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +from pathlib import Path +import torch + +from pytorch3d import _C +from pytorch3d.ops.sample_points_from_meshes import sample_points_from_meshes +from pytorch3d.structures.meshes import Meshes +from pytorch3d.utils.ico_sphere import ico_sphere + + +class TestSamplePoints(unittest.TestCase): + def setUp(self) -> None: + super().setUp() + torch.manual_seed(1) + + @staticmethod + def init_meshes( + num_meshes: int = 10, + num_verts: int = 1000, + num_faces: int = 3000, + device: str = "cpu", + ): + device = torch.device(device) + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = torch.rand( + (num_verts, 3), dtype=torch.float32, device=device + ) + faces = torch.randint( + num_verts, size=(num_faces, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + + return meshes + + def test_all_empty_meshes(self): + """ + Check sample_points_from_meshes raises an exception if all meshes are + invalid. + """ + device = torch.device("cuda:0") + verts1 = torch.tensor([], dtype=torch.float32, device=device) + faces1 = torch.tensor([], dtype=torch.int64, device=device) + meshes = Meshes( + verts=[verts1, verts1, verts1], faces=[faces1, faces1, faces1] + ) + with self.assertRaises(ValueError) as err: + sample_points_from_meshes( + meshes, num_samples=100, return_normals=True + ) + self.assertTrue("Meshes are empty." in str(err.exception)) + + def test_sampling_output(self): + """ + Check outputs of sampling are correct for different meshes. + For an ico_sphere, the sampled vertices should lie on a unit sphere. + For an empty mesh, the samples and normals should be 0. + """ + device = torch.device("cuda:0") + + # Unit simplex. + verts_pyramid = torch.tensor( + [ + [0.0, 0.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0], + ], + dtype=torch.float32, + device=device, + ) + faces_pyramid = torch.tensor( + [[0, 1, 2], [0, 2, 3], [0, 1, 3], [1, 2, 3]], + dtype=torch.int64, + device=device, + ) + sphere_mesh = ico_sphere(9, device) + verts_sphere, faces_sphere = sphere_mesh.get_mesh_verts_faces(0) + verts_empty = torch.tensor([], dtype=torch.float32, device=device) + faces_empty = torch.tensor([], dtype=torch.int64, device=device) + num_samples = 10 + meshes = Meshes( + verts=[verts_empty, verts_sphere, verts_pyramid], + faces=[faces_empty, faces_sphere, faces_pyramid], + ) + samples, normals = sample_points_from_meshes( + meshes, num_samples=num_samples, return_normals=True + ) + samples = samples.cpu() + normals = normals.cpu() + + self.assertEqual(samples.shape, (3, num_samples, 3)) + self.assertEqual(normals.shape, (3, num_samples, 3)) + + # Empty meshes: should have all zeros for samples and normals. + self.assertTrue( + torch.allclose(samples[0, :], torch.zeros((1, num_samples, 3))) + ) + self.assertTrue( + torch.allclose(normals[0, :], torch.zeros((1, num_samples, 3))) + ) + + # Sphere: points should have radius 1. + x, y, z = samples[1, :].unbind(1) + radius = torch.sqrt(x ** 2 + y ** 2 + z ** 2) + + self.assertTrue(torch.allclose(radius, torch.ones((num_samples)))) + + # Pyramid: points shoudl lie on one of the faces. + pyramid_verts = samples[2, :] + pyramid_normals = normals[2, :] + + self.assertTrue( + torch.allclose( + pyramid_verts.lt(1).float(), torch.ones_like(pyramid_verts) + ) + ) + self.assertTrue( + torch.allclose( + (pyramid_verts >= 0).float(), torch.ones_like(pyramid_verts) + ) + ) + + # Face 1: z = 0, x + y <= 1, normals = (0, 0, 1). + face_1_idxs = pyramid_verts[:, 2] == 0 + face_1_verts, face_1_normals = ( + pyramid_verts[face_1_idxs, :], + pyramid_normals[face_1_idxs, :], + ) + self.assertTrue( + torch.all((face_1_verts[:, 0] + face_1_verts[:, 1]) <= 1) + ) + self.assertTrue( + torch.allclose( + face_1_normals, + torch.tensor([0, 0, 1], dtype=torch.float32).expand( + face_1_normals.size() + ), + ) + ) + + # Face 2: x = 0, z + y <= 1, normals = (1, 0, 0). + face_2_idxs = pyramid_verts[:, 0] == 0 + face_2_verts, face_2_normals = ( + pyramid_verts[face_2_idxs, :], + pyramid_normals[face_2_idxs, :], + ) + self.assertTrue( + torch.all((face_2_verts[:, 1] + face_2_verts[:, 2]) <= 1) + ) + self.assertTrue( + torch.allclose( + face_2_normals, + torch.tensor([1, 0, 0], dtype=torch.float32).expand( + face_2_normals.size() + ), + ) + ) + + # Face 3: y = 0, x + z <= 1, normals = (0, -1, 0). + face_3_idxs = pyramid_verts[:, 1] == 0 + face_3_verts, face_3_normals = ( + pyramid_verts[face_3_idxs, :], + pyramid_normals[face_3_idxs, :], + ) + self.assertTrue( + torch.all((face_3_verts[:, 0] + face_3_verts[:, 2]) <= 1) + ) + self.assertTrue( + torch.allclose( + face_3_normals, + torch.tensor([0, -1, 0], dtype=torch.float32).expand( + face_3_normals.size() + ), + ) + ) + + # Face 4: x + y + z = 1, normals = (1, 1, 1)/sqrt(3). + face_4_idxs = pyramid_verts.gt(0).all(1) + face_4_verts, face_4_normals = ( + pyramid_verts[face_4_idxs, :], + pyramid_normals[face_4_idxs, :], + ) + self.assertTrue( + torch.allclose( + face_4_verts.sum(1), torch.ones(face_4_verts.size(0)) + ) + ) + self.assertTrue( + torch.allclose( + face_4_normals, + ( + torch.tensor([1, 1, 1], dtype=torch.float32) + / torch.sqrt(torch.tensor(3, dtype=torch.float32)) + ).expand(face_4_normals.size()), + ) + ) + + def test_mutinomial(self): + """ + Confirm that torch.multinomial does not sample elements which have + zero probability. + """ + freqs = torch.cuda.FloatTensor( + [ + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.03178183361887932, + 0.027680952101945877, + 0.033176131546497345, + 0.046052902936935425, + 0.07742464542388916, + 0.11543981730937958, + 0.14148041605949402, + 0.15784293413162231, + 0.13180233538150787, + 0.08271478116512299, + 0.049702685326337814, + 0.027557924389839172, + 0.018125897273421288, + 0.011851548217236996, + 0.010252203792333603, + 0.007422595750540495, + 0.005372154992073774, + 0.0045109698548913, + 0.0036087757907807827, + 0.0035267581697553396, + 0.0018864056328311563, + 0.0024605290964245796, + 0.0022964938543736935, + 0.0018453967059031129, + 0.0010662291897460818, + 0.0009842115687206388, + 0.00045109697384759784, + 0.0007791675161570311, + 0.00020504408166743815, + 0.00020504408166743815, + 0.00020504408166743815, + 0.00012302644609007984, + 0.0, + 0.00012302644609007984, + 4.100881778867915e-05, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + 0.0, + ] + ) + + sample = [] + for _ in range(1000): + torch.cuda.get_rng_state() + sample = torch.multinomial(freqs, 1000, True) + if freqs[sample].min() == 0: + sample_idx = (freqs[sample] == 0).nonzero()[0][0] + sampled = sample[sample_idx] + print( + "%s th element of last sample was %s, which has probability %s" + % (sample_idx, sampled, freqs[sampled]) + ) + return False + return True + + def test_multinomial_weights(self): + """ + Confirm that torch.multinomial does not sample elements which have + zero probability using a real example of input from a training run. + """ + weights = torch.load(Path(__file__).resolve().parent / "weights.pt") + S = 4096 + num_trials = 100 + for _ in range(0, num_trials): + weights[weights < 0] = 0.0 + samples = weights.multinomial(S, replacement=True) + sampled_weights = weights[samples] + assert sampled_weights.min() > 0 + if sampled_weights.min() <= 0: + return False + return True + + @staticmethod + def face_areas(verts, faces): + """ + Vectorized PyTorch implementation of triangle face area function. + """ + verts_faces = verts[faces] + v0x = verts_faces[:, 0::3, 0] + v0y = verts_faces[:, 0::3, 1] + v0z = verts_faces[:, 0::3, 2] + + v1x = verts_faces[:, 1::3, 0] + v1y = verts_faces[:, 1::3, 1] + v1z = verts_faces[:, 1::3, 2] + + v2x = verts_faces[:, 2::3, 0] + v2y = verts_faces[:, 2::3, 1] + v2z = verts_faces[:, 2::3, 2] + + ax = v0x - v2x + ay = v0y - v2y + az = v0z - v2z + + bx = v1x - v2x + by = v1y - v2y + bz = v1z - v2z + + cx = ay * bz - az * by + cy = az * bx - ax * bz + cz = ax * by - ay * bx + + # this gives the area of the parallelogram with sides a and b + area_sqr = cx * cx + cy * cy + cz * cz + # the area of the triangle is half + return torch.sqrt(area_sqr) / 2.0 + + def test_face_areas(self): + """ + Check the results from face_areas cuda and PyTorch implementions are + the same. Check that face_areas throws an error if cpu tensors are + given as input. + """ + meshes = self.init_meshes(10, 1000, 3000, device="cuda:0") + verts = meshes.verts_packed() + faces = meshes.faces_packed() + + areas_torch = self.face_areas(verts, faces).squeeze() + areas_cuda, _ = _C.face_areas_normals(verts, faces) + self.assertTrue(torch.allclose(areas_torch, areas_cuda, atol=5e-8)) + with self.assertRaises(Exception) as err: + _C.face_areas_normals(verts.cpu(), faces.cpu()) + self.assertTrue("Not implemented on the CPU" in str(err.exception)) + + @staticmethod + def packed_to_padded_tensor(inputs, first_idxs, max_size): + """ + PyTorch implementation of cuda packed_to_padded_tensor function. + """ + num_meshes = first_idxs.size(0) + inputs_padded = torch.zeros((num_meshes, max_size)) + for m in range(num_meshes): + s = first_idxs[m] + if m == num_meshes - 1: + f = inputs.size(0) + else: + f = first_idxs[m + 1] + inputs_padded[m, :f] = inputs[s:f] + + return inputs_padded + + def test_packed_to_padded_tensor(self): + """ + Check the results from packed_to_padded cuda and PyTorch implementions + are the same. + """ + meshes = self.init_meshes(1, 3, 5, device="cuda:0") + verts = meshes.verts_packed() + faces = meshes.faces_packed() + mesh_to_faces_packed_first_idx = meshes.mesh_to_faces_packed_first_idx() + max_faces = meshes.num_faces_per_mesh().max().item() + + areas, _ = _C.face_areas_normals(verts, faces) + areas_padded = _C.packed_to_padded_tensor( + areas, mesh_to_faces_packed_first_idx, max_faces + ).cpu() + areas_padded_cpu = TestSamplePoints.packed_to_padded_tensor( + areas, mesh_to_faces_packed_first_idx, max_faces + ) + self.assertTrue(torch.allclose(areas_padded, areas_padded_cpu)) + with self.assertRaises(Exception) as err: + _C.packed_to_padded_tensor( + areas.cpu(), mesh_to_faces_packed_first_idx, max_faces + ) + self.assertTrue("Not implemented on the CPU" in str(err.exception)) + + @staticmethod + def sample_points_with_init( + num_meshes: int, + num_verts: int, + num_faces: int, + num_samples: int, + device: str = "cpu", + ): + device = torch.device(device) + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = torch.rand( + (num_verts, 3), dtype=torch.float32, device=device + ) + faces = torch.randint( + num_verts, size=(num_faces, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + torch.cuda.synchronize() + + def sample_points(): + sample_points_from_meshes( + meshes, num_samples=num_samples, return_normals=True + ) + torch.cuda.synchronize() + + return sample_points + + @staticmethod + def face_areas_with_init( + num_meshes: int, num_verts: int, num_faces: int, cuda: str = True + ): + device = "cuda" if cuda else "cpu" + meshes = TestSamplePoints.init_meshes( + num_meshes, num_verts, num_faces, device + ) + verts = meshes.verts_packed() + faces = meshes.faces_packed() + torch.cuda.synchronize() + + def face_areas(): + if cuda: + _C.face_areas_normals(verts, faces) + else: + TestSamplePoints.face_areas(verts, faces) + torch.cuda.synchronize() + + return face_areas + + @staticmethod + def packed_to_padded_with_init( + num_meshes: int, num_verts: int, num_faces: int, cuda: str = True + ): + device = "cuda" if cuda else "cpu" + meshes = TestSamplePoints.init_meshes( + num_meshes, num_verts, num_faces, device + ) + verts = meshes.verts_packed() + faces = meshes.faces_packed() + mesh_to_faces_packed_first_idx = meshes.mesh_to_faces_packed_first_idx() + max_faces = meshes.num_faces_per_mesh().max().item() + + if cuda: + areas, _ = _C.face_areas_normals(verts, faces) + else: + areas = TestSamplePoints.face_areas(verts, faces) + torch.cuda.synchronize() + + def packed_to_padded(): + if cuda: + _C.packed_to_padded_tensor( + areas, mesh_to_faces_packed_first_idx, max_faces + ) + else: + TestSamplePoints.packed_to_padded_tensor( + areas, mesh_to_faces_packed_first_idx, max_faces + ) + torch.cuda.synchronize() + + return packed_to_padded diff --git a/tests/test_so3.py b/tests/test_so3.py new file mode 100644 index 00000000..74801167 --- /dev/null +++ b/tests/test_so3.py @@ -0,0 +1,200 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import numpy as np +import unittest +import torch + +from pytorch3d.transforms.so3 import ( + hat, + so3_exponential_map, + so3_log_map, + so3_relative_angle, +) + + +class TestSO3(unittest.TestCase): + def setUp(self) -> None: + super().setUp() + torch.manual_seed(42) + np.random.seed(42) + + @staticmethod + def init_log_rot(batch_size: int = 10): + """ + Initialize a list of `batch_size` 3-dimensional vectors representing + randomly generated logarithms of rotation matrices. + """ + device = torch.device("cuda:0") + log_rot = torch.randn( + (batch_size, 3), dtype=torch.float32, device=device + ) + return log_rot + + @staticmethod + def init_rot(batch_size: int = 10): + """ + Randomly generate a batch of `batch_size` 3x3 rotation matrices. + """ + device = torch.device("cuda:0") + + # TODO(dnovotny): replace with random_rotation from random_rotation.py + rot = [] + for _ in range(batch_size): + r = torch.qr(torch.randn((3, 3), device=device))[0] + f = torch.randint(2, (3,), device=device, dtype=torch.float32) + if f.sum() % 2 == 0: + f = 1 - f + rot.append(r * (2 * f - 1).float()) + rot = torch.stack(rot) + + return rot + + def test_determinant(self): + """ + Tests whether the determinants of 3x3 rotation matrices produced + by `so3_exponential_map` are (almost) equal to 1. + """ + log_rot = TestSO3.init_log_rot(batch_size=30) + Rs = so3_exponential_map(log_rot) + for R in Rs: + det = np.linalg.det(R.cpu().numpy()) + self.assertAlmostEqual(float(det), 1.0, 5) + + def test_cross(self): + """ + For a pair of randomly generated 3-dimensional vectors `a` and `b`, + tests whether a matrix product of `hat(a)` and `b` equals the result + of a cross product between `a` and `b`. + """ + device = torch.device("cuda:0") + a, b = torch.randn((2, 100, 3), dtype=torch.float32, device=device) + hat_a = hat(a) + cross = torch.bmm(hat_a, b[:, :, None])[:, :, 0] + torch_cross = torch.cross(a, b, dim=1) + max_df = (cross - torch_cross).abs().max() + self.assertAlmostEqual(float(max_df), 0.0, 5) + + def test_bad_so3_input_value_err(self): + """ + Tests whether `so3_exponential_map` and `so3_log_map` correctly return + a ValueError if called with an argument of incorrect shape or, in case + of `so3_exponential_map`, unexpected trace. + """ + device = torch.device("cuda:0") + log_rot = torch.randn(size=[5, 4], device=device) + with self.assertRaises(ValueError) as err: + so3_exponential_map(log_rot) + self.assertTrue( + "Input tensor shape has to be Nx3." in str(err.exception) + ) + + rot = torch.randn(size=[5, 3, 5], device=device) + with self.assertRaises(ValueError) as err: + so3_log_map(rot) + self.assertTrue( + "Input has to be a batch of 3x3 Tensors." in str(err.exception) + ) + + # trace of rot definitely bigger than 3 or smaller than -1 + rot = torch.cat( + ( + torch.rand(size=[5, 3, 3], device=device) + 4.0, + torch.rand(size=[5, 3, 3], device=device) - 3.0, + ) + ) + with self.assertRaises(ValueError) as err: + so3_log_map(rot) + self.assertTrue( + "A matrix has trace outside valid range [-1-eps,3+eps]." + in str(err.exception) + ) + + def test_so3_exp_singularity(self, batch_size: int = 100): + """ + Tests whether the `so3_exponential_map` is robust to the input vectors + the norms of which are close to the numerically unstable region + (vectors with low l2-norms). + """ + # generate random log-rotations with a tiny angle + log_rot = TestSO3.init_log_rot(batch_size=batch_size) + log_rot_small = log_rot * 1e-6 + R = so3_exponential_map(log_rot_small) + # tests whether all outputs are finite + R_sum = float(R.sum()) + self.assertEqual(R_sum, R_sum) + + def test_so3_log_singularity(self, batch_size: int = 100): + """ + Tests whether the `so3_log_map` is robust to the input matrices + who's rotation angles are close to the numerically unstable region + (i.e. matrices with low rotation angles). + """ + # generate random rotations with a tiny angle + device = torch.device("cuda:0") + r = torch.eye(3, device=device)[None].repeat((batch_size, 1, 1)) + r += torch.randn((batch_size, 3, 3), device=device) * 1e-3 + r = torch.stack([torch.qr(r_)[0] for r_ in r]) + # the log of the rotation matrix r + r_log = so3_log_map(r) + # tests whether all outputs are finite + r_sum = float(r_log.sum()) + self.assertEqual(r_sum, r_sum) + + def test_so3_log_to_exp_to_log(self, batch_size: int = 100): + """ + Check that `so3_log_map(so3_exponential_map(log_rot))==log_rot` for + a randomly generated batch of rotation matrix logarithms `log_rot`. + """ + log_rot = TestSO3.init_log_rot(batch_size=batch_size) + log_rot_ = so3_log_map(so3_exponential_map(log_rot)) + max_df = (log_rot - log_rot_).abs().max() + self.assertAlmostEqual(float(max_df), 0.0, 4) + + def test_so3_exp_to_log_to_exp(self, batch_size: int = 100): + """ + Check that `so3_exponential_map(so3_log_map(R))==R` for + a batch of randomly generated rotation matrices `R`. + """ + rot = TestSO3.init_rot(batch_size=batch_size) + rot_ = so3_exponential_map(so3_log_map(rot)) + angles = so3_relative_angle(rot, rot_) + max_angle = angles.max() + # a lot of precision lost here :( + # TODO: fix this test?? + self.assertTrue(np.allclose(float(max_angle), 0.0, atol=0.1)) + + def test_so3_cos_angle(self, batch_size: int = 100): + """ + Check that `so3_relative_angle(R1, R2, cos_angle=False).cos()` + is the same as `so3_relative_angle(R1, R2, cos_angle=True)` + batches of randomly generated rotation matrices `R1` and `R2`. + """ + rot1 = TestSO3.init_rot(batch_size=batch_size) + rot2 = TestSO3.init_rot(batch_size=batch_size) + angles = so3_relative_angle(rot1, rot2, cos_angle=False).cos() + angles_ = so3_relative_angle(rot1, rot2, cos_angle=True) + self.assertTrue(torch.allclose(angles, angles_)) + + @staticmethod + def so3_expmap(batch_size: int = 10): + log_rot = TestSO3.init_log_rot(batch_size=batch_size) + torch.cuda.synchronize() + + def compute_rots(): + so3_exponential_map(log_rot) + torch.cuda.synchronize() + + return compute_rots + + @staticmethod + def so3_logmap(batch_size: int = 10): + log_rot = TestSO3.init_rot(batch_size=batch_size) + torch.cuda.synchronize() + + def compute_logs(): + so3_log_map(log_rot) + torch.cuda.synchronize() + + return compute_logs diff --git a/tests/test_struct_utils.py b/tests/test_struct_utils.py new file mode 100644 index 00000000..c4aad820 --- /dev/null +++ b/tests/test_struct_utils.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +import torch + +from pytorch3d.structures import utils as struct_utils + +from common_testing import TestCaseMixin + + +class TestStructUtils(TestCaseMixin, unittest.TestCase): + def test_list_to_padded(self): + device = torch.device("cuda:0") + N = 5 + K = 20 + ndim = 2 + x = [] + for _ in range(N): + dims = torch.randint(K, size=(ndim,)).tolist() + x.append(torch.rand(dims, device=device)) + pad_size = [K] * ndim + x_padded = struct_utils.list_to_padded( + x, pad_size=pad_size, pad_value=0.0, equisized=False + ) + + self.assertEqual(x_padded.shape[1], K) + self.assertEqual(x_padded.shape[2], K) + for i in range(N): + self.assertClose( + x_padded[i, : x[i].shape[0], : x[i].shape[1]], x[i] + ) + + # check for no pad size (defaults to max dimension) + x_padded = struct_utils.list_to_padded( + x, pad_value=0.0, equisized=False + ) + max_size0 = max(y.shape[0] for y in x) + max_size1 = max(y.shape[1] for y in x) + self.assertEqual(x_padded.shape[1], max_size0) + self.assertEqual(x_padded.shape[2], max_size1) + for i in range(N): + self.assertClose( + x_padded[i, : x[i].shape[0], : x[i].shape[1]], x[i] + ) + + # check for equisized + x = [torch.rand((K, 10), device=device) for _ in range(N)] + x_padded = struct_utils.list_to_padded(x, equisized=True) + self.assertClose(x_padded, torch.stack(x, 0)) + + # catch ValueError for invalid dimensions + with self.assertRaisesRegex(ValueError, "Pad size must"): + pad_size = [K] * 4 + struct_utils.list_to_padded( + x, pad_size=pad_size, pad_value=0.0, equisized=False + ) + + # invalid input tensor dimensions + x = [] + ndim = 3 + for _ in range(N): + dims = torch.randint(K, size=(ndim,)).tolist() + x.append(torch.rand(dims, device=device)) + pad_size = [K] * 2 + with self.assertRaisesRegex(ValueError, "Supports only"): + x_padded = struct_utils.list_to_padded( + x, pad_size=pad_size, pad_value=0.0, equisized=False + ) + + def test_padded_to_list(self): + device = torch.device("cuda:0") + N = 5 + K = 20 + ndim = 2 + dims = [K] * ndim + x = torch.rand([N] + dims, device=device) + + x_list = struct_utils.padded_to_list(x) + for i in range(N): + self.assertClose(x_list[i], x[i]) + + split_size = torch.randint(1, K, size=(N,)).tolist() + x_list = struct_utils.padded_to_list(x, split_size) + for i in range(N): + self.assertClose(x_list[i], x[i, : split_size[i]]) + + split_size = torch.randint(1, K, size=(2 * N,)).view(N, 2).unbind(0) + x_list = struct_utils.padded_to_list(x, split_size) + for i in range(N): + self.assertClose( + x_list[i], x[i, : split_size[i][0], : split_size[i][1]] + ) + + with self.assertRaisesRegex(ValueError, "Supports only"): + x = torch.rand((N, K, K, K, K), device=device) + split_size = torch.randint(1, K, size=(N,)).tolist() + struct_utils.padded_to_list(x, split_size) + + def test_list_to_packed(self): + device = torch.device("cuda:0") + N = 5 + K = 20 + x, x_dims = [], [] + dim2 = torch.randint(K, size=(1,)).item() + for _ in range(N): + dim1 = torch.randint(K, size=(1,)).item() + x_dims.append(dim1) + x.append(torch.rand([dim1, dim2], device=device)) + + out = struct_utils.list_to_packed(x) + x_packed = out[0] + num_items = out[1] + item_packed_first_idx = out[2] + item_packed_to_list_idx = out[3] + + cur = 0 + for i in range(N): + self.assertTrue(num_items[i] == x_dims[i]) + self.assertTrue(item_packed_first_idx[i] == cur) + self.assertTrue( + item_packed_to_list_idx[cur : cur + x_dims[i]].eq(i).all() + ) + self.assertClose(x_packed[cur : cur + x_dims[i]], x[i]) + cur += x_dims[i] diff --git a/tests/test_subdivide_meshes.py b/tests/test_subdivide_meshes.py new file mode 100644 index 00000000..fb84c9bb --- /dev/null +++ b/tests/test_subdivide_meshes.py @@ -0,0 +1,235 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +import torch + +from pytorch3d.ops.subdivide_meshes import SubdivideMeshes +from pytorch3d.structures.meshes import Meshes +from pytorch3d.utils.ico_sphere import ico_sphere + + +class TestSubdivideMeshes(unittest.TestCase): + def test_simple_subdivide(self): + # Create a mesh with one face and check the subdivided mesh has + # 4 faces with the correct vertex coordinates. + device = torch.device("cuda:0") + verts = torch.tensor( + [[0.5, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]], + dtype=torch.float32, + device=device, + requires_grad=True, + ) + faces = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + mesh = Meshes(verts=[verts], faces=[faces]) + subdivide = SubdivideMeshes() + new_mesh = subdivide(mesh) + + # Subdivided face: + # + # v0 + # /\ + # / \ + # / f0 \ + # v4 /______\ v3 + # /\ /\ + # / \ f3 / \ + # / f2 \ / f1 \ + # /______\/______\ + # v2 v5 v1 + # + gt_subdivide_verts = torch.tensor( + [ + [0.5, 1.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.75, 0.5, 0.0], + [0.25, 0.5, 0.0], + [0.5, 0.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + gt_subdivide_faces = torch.tensor( + [[0, 3, 4], [1, 5, 3], [2, 4, 5], [5, 4, 3]], + dtype=torch.int64, + device=device, + ) + new_verts, new_faces = new_mesh.get_mesh_verts_faces(0) + self.assertTrue(torch.allclose(new_verts, gt_subdivide_verts)) + self.assertTrue(torch.allclose(new_faces, gt_subdivide_faces)) + self.assertTrue(new_verts.requires_grad == verts.requires_grad) + + def test_heterogeneous_meshes(self): + device = torch.device("cuda:0") + verts1 = torch.tensor( + [[0.5, 1.0, 0.0], [1.0, 0.0, 0.0], [0.0, 0.0, 0.0]], + dtype=torch.float32, + device=device, + requires_grad=True, + ) + faces1 = torch.tensor([[0, 1, 2]], dtype=torch.int64, device=device) + verts2 = torch.tensor( + [ + [0.5, 1.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [1.5, 1.0, 0.0], + ], + dtype=torch.float32, + device=device, + requires_grad=True, + ) + faces2 = torch.tensor( + [[0, 1, 2], [0, 3, 1]], dtype=torch.int64, device=device + ) + faces3 = torch.tensor( + [[0, 1, 2], [0, 2, 3]], dtype=torch.int64, device=device + ) + mesh = Meshes( + verts=[verts1, verts2, verts2], faces=[faces1, faces2, faces3] + ) + subdivide = SubdivideMeshes() + new_mesh = subdivide(mesh.clone()) + + gt_subdivided_verts1 = torch.tensor( + [ + [0.5, 1.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [0.75, 0.5, 0.0], + [0.25, 0.5, 0.0], + [0.5, 0.0, 0.0], + ], + dtype=torch.float32, + device=device, + ) + gt_subdivided_faces1 = torch.tensor( + [[0, 3, 4], [1, 5, 3], [2, 4, 5], [5, 4, 3]], + dtype=torch.int64, + device=device, + ) + # faces2: + # + # v0 _______e2_______ v3 + # /\ / + # / \ / + # / \ / + # e1 / \ e0 / e4 + # / \ / + # / \ / + # / \ / + # /______________\/ + # v2 e3 v1 + # + # Subdivided faces2: + # + # v0 _______v6_______ v3 + # /\ /\ / + # / \ f1 / \ f3 / + # / f0 \ / f7 \ / + # v5 /______v4______\/v8 + # /\ /\ / + # / \ f6 / \ f5 / + # / f4 \ / f2 \ / + # /______\/______\/ + # v2 v7 v1 + # + gt_subdivided_verts2 = torch.tensor( + [ + [0.5, 1.0, 0.0], + [1.0, 0.0, 0.0], + [0.0, 0.0, 0.0], + [1.5, 1.0, 0.0], + [0.75, 0.5, 0.0], + [0.25, 0.5, 0.0], + [1.0, 1.0, 0.0], + [0.5, 0.0, 0.0], + [1.25, 0.5, 0.0], + ], + dtype=torch.float32, + device=device, + ) + gt_subdivided_faces2 = torch.tensor( + [ + [0, 4, 5], + [0, 6, 4], + [1, 7, 4], + [3, 8, 6], + [2, 5, 7], + [1, 4, 8], + [7, 5, 4], + [8, 4, 6], + ], + dtype=torch.int64, + device=device, + ) + gt_subdivided_verts3 = gt_subdivided_verts2.clone() + gt_subdivided_verts3[-1, :] = torch.tensor( + [0.75, 0.5, 0], dtype=torch.float32, device=device + ) + gt_subdivided_faces3 = torch.tensor( + [ + [0, 4, 5], + [0, 5, 6], + [1, 7, 4], + [2, 8, 5], + [2, 5, 7], + [3, 6, 8], + [7, 5, 4], + [8, 6, 5], + ], + dtype=torch.int64, + device=device, + ) + new_mesh_verts1, new_mesh_faces1 = new_mesh.get_mesh_verts_faces(0) + new_mesh_verts2, new_mesh_faces2 = new_mesh.get_mesh_verts_faces(1) + new_mesh_verts3, new_mesh_faces3 = new_mesh.get_mesh_verts_faces(2) + self.assertTrue(torch.allclose(new_mesh_verts1, gt_subdivided_verts1)) + self.assertTrue(torch.allclose(new_mesh_faces1, gt_subdivided_faces1)) + self.assertTrue(torch.allclose(new_mesh_verts2, gt_subdivided_verts2)) + self.assertTrue(torch.allclose(new_mesh_faces2, gt_subdivided_faces2)) + self.assertTrue(torch.allclose(new_mesh_verts3, gt_subdivided_verts3)) + self.assertTrue(torch.allclose(new_mesh_faces3, gt_subdivided_faces3)) + self.assertTrue(new_mesh_verts1.requires_grad == verts1.requires_grad) + self.assertTrue(new_mesh_verts2.requires_grad == verts2.requires_grad) + self.assertTrue(new_mesh_verts3.requires_grad == verts2.requires_grad) + + def test_subdivide_features(self): + device = torch.device("cuda:0") + mesh = ico_sphere(0, device) + N = 10 + mesh = mesh.extend(N) + edges = mesh.edges_packed() + V = mesh.num_verts_per_mesh()[0] + D = 256 + feats = torch.rand( + (N * V, D), dtype=torch.float32, device=device, requires_grad=True + ) # packed features + app_feats = feats[edges].mean(1) + subdivide = SubdivideMeshes() + new_mesh, new_feats = subdivide(mesh, feats) + gt_feats = torch.cat( + (feats.view(N, V, D), app_feats.view(N, -1, D)), dim=1 + ).view(-1, D) + self.assertTrue(torch.allclose(new_feats, gt_feats)) + self.assertTrue(new_feats.requires_grad == gt_feats.requires_grad) + + @staticmethod + def subdivide_meshes_with_init( + num_meshes: int = 10, same_topo: bool = False + ): + device = torch.device("cuda:0") + meshes = ico_sphere(0, device=device) + if num_meshes > 1: + meshes = meshes.extend(num_meshes) + meshes_init = meshes.clone() if same_topo else None + torch.cuda.synchronize() + + def subdivide_meshes(): + subdivide = SubdivideMeshes(meshes=meshes_init) + subdivide(meshes=meshes.clone()) + torch.cuda.synchronize() + + return subdivide_meshes diff --git a/tests/test_texturing.py b/tests/test_texturing.py new file mode 100644 index 00000000..cd3399db --- /dev/null +++ b/tests/test_texturing.py @@ -0,0 +1,232 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +import torch +import torch.nn.functional as F + +from pytorch3d.renderer.mesh.rasterizer import Fragments +from pytorch3d.renderer.mesh.texturing import ( + _clip_barycentric_coordinates, + interpolate_face_attributes, + interpolate_texture_map, + interpolate_vertex_colors, +) +from pytorch3d.structures import Meshes, Textures + +from common_testing import TestCaseMixin +from test_meshes import TestMeshes + + +class TestTexturing(TestCaseMixin, unittest.TestCase): + def test_interpolate_attributes(self): + """ + This tests both interpolate_vertex_colors as well as + interpolate_face_attributes. + """ + verts = torch.randn((4, 3), dtype=torch.float32) + faces = torch.tensor([[2, 1, 0], [3, 1, 0]], dtype=torch.int64) + vert_tex = torch.tensor( + [[0, 1, 0], [0, 1, 1], [1, 1, 0], [1, 1, 1]], dtype=torch.float32 + ) + tex = Textures(verts_rgb=vert_tex[None, :]) + mesh = Meshes(verts=[verts], faces=[faces], textures=tex) + pix_to_face = torch.tensor([0, 1], dtype=torch.int64).view(1, 1, 1, 2) + barycentric_coords = torch.tensor( + [[0.5, 0.3, 0.2], [0.3, 0.6, 0.1]], dtype=torch.float32 + ).view(1, 1, 1, 2, -1) + expected_vals = torch.tensor( + [[0.5, 1.0, 0.3], [0.3, 1.0, 0.9]], dtype=torch.float32 + ).view(1, 1, 1, 2, -1) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=barycentric_coords, + zbuf=torch.ones_like(pix_to_face), + dists=torch.ones_like(pix_to_face), + ) + texels = interpolate_vertex_colors(fragments, mesh) + self.assertTrue(torch.allclose(texels, expected_vals[None, :])) + + def test_interpolate_attributes_grad(self): + verts = torch.randn((4, 3), dtype=torch.float32) + faces = torch.tensor([[2, 1, 0], [3, 1, 0]], dtype=torch.int64) + vert_tex = torch.tensor( + [[0, 1, 0], [0, 1, 1], [1, 1, 0], [1, 1, 1]], + dtype=torch.float32, + requires_grad=True, + ) + tex = Textures(verts_rgb=vert_tex[None, :]) + mesh = Meshes(verts=[verts], faces=[faces], textures=tex) + pix_to_face = torch.tensor([0, 1], dtype=torch.int64).view(1, 1, 1, 2) + barycentric_coords = torch.tensor( + [[0.5, 0.3, 0.2], [0.3, 0.6, 0.1]], dtype=torch.float32 + ).view(1, 1, 1, 2, -1) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=barycentric_coords, + zbuf=torch.ones_like(pix_to_face), + dists=torch.ones_like(pix_to_face), + ) + grad_vert_tex = torch.tensor( + [ + [0.3, 0.3, 0.3], + [0.9, 0.9, 0.9], + [0.5, 0.5, 0.5], + [0.3, 0.3, 0.3], + ], + dtype=torch.float32, + ) + texels = interpolate_vertex_colors(fragments, mesh) + texels.sum().backward() + self.assertTrue(hasattr(vert_tex, "grad")) + self.assertTrue(torch.allclose(vert_tex.grad, grad_vert_tex[None, :])) + + def test_interpolate_face_attributes_fail(self): + # 1. A face can only have 3 verts + # i.e. face_attributes must have shape (F, 3, D) + face_attributes = torch.ones(1, 4, 3) + pix_to_face = torch.ones((1, 1, 1, 1)) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=pix_to_face[..., None].expand(-1, -1, -1, -1, 3), + zbuf=pix_to_face, + dists=pix_to_face, + ) + with self.assertRaises(ValueError): + interpolate_face_attributes(fragments, face_attributes) + + # 2. pix_to_face must have shape (N, H, W, K) + pix_to_face = torch.ones((1, 1, 1, 1, 3)) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=pix_to_face, + zbuf=pix_to_face, + dists=pix_to_face, + ) + with self.assertRaises(ValueError): + interpolate_face_attributes(fragments, face_attributes) + + def test_interpolate_texture_map(self): + barycentric_coords = torch.tensor( + [[0.5, 0.3, 0.2], [0.3, 0.6, 0.1]], dtype=torch.float32 + ).view(1, 1, 1, 2, -1) + dummy_verts = torch.zeros(4, 3) + vert_uvs = torch.tensor( + [[1, 0], [0, 1], [1, 1], [0, 0]], dtype=torch.float32 + ) + face_uvs = torch.tensor([[0, 1, 2], [1, 2, 3]], dtype=torch.int64) + interpolated_uvs = torch.tensor( + [[0.5 + 0.2, 0.3 + 0.2], [0.6, 0.3 + 0.6]], dtype=torch.float32 + ) + + # Create a dummy texture map + H = 2 + W = 2 + x = torch.linspace(0, 1, W).view(1, W).expand(H, W) + y = torch.linspace(0, 1, H).view(H, 1).expand(H, W) + tex_map = torch.stack([x, y], dim=2).view(1, H, W, 2) + pix_to_face = torch.tensor([0, 1], dtype=torch.int64).view(1, 1, 1, 2) + fragments = Fragments( + pix_to_face=pix_to_face, + bary_coords=barycentric_coords, + zbuf=pix_to_face, + dists=pix_to_face, + ) + tex = Textures( + maps=tex_map, + faces_uvs=face_uvs[None, ...], + verts_uvs=vert_uvs[None, ...], + ) + meshes = Meshes(verts=[dummy_verts], faces=[face_uvs], textures=tex) + texels = interpolate_texture_map(fragments, meshes) + + # Expected output + pixel_uvs = interpolated_uvs * 2.0 - 1.0 + pixel_uvs = pixel_uvs.view(2, 1, 1, 2) + tex_map = torch.flip(tex_map, [1]) + tex_map = tex_map.permute(0, 3, 1, 2) + tex_map = torch.cat([tex_map, tex_map], dim=0) + expected_out = F.grid_sample(tex_map, pixel_uvs, align_corners=False) + self.assertTrue( + torch.allclose(texels.squeeze(), expected_out.squeeze()) + ) + + def test_clone(self): + V = 20 + tex = Textures( + maps=torch.ones((5, 16, 16, 3)), + faces_uvs=torch.randint(size=(5, 10, 3), low=0, high=V), + verts_uvs=torch.ones((5, V, 2)), + ) + tex_cloned = tex.clone() + self.assertSeparate(tex._faces_uvs_padded, tex_cloned._faces_uvs_padded) + self.assertSeparate(tex._verts_uvs_padded, tex_cloned._verts_uvs_padded) + self.assertSeparate(tex._maps_padded, tex_cloned._maps_padded) + + def test_to(self): + V = 20 + tex = Textures( + maps=torch.ones((5, 16, 16, 3)), + faces_uvs=torch.randint(size=(5, 10, 3), low=0, high=V), + verts_uvs=torch.ones((5, V, 2)), + ) + device = torch.device("cuda:0") + tex = tex.to(device) + self.assertTrue(tex._faces_uvs_padded.device == device) + self.assertTrue(tex._verts_uvs_padded.device == device) + self.assertTrue(tex._maps_padded.device == device) + + def test_extend(self): + B = 10 + mesh = TestMeshes.init_mesh(B, 30, 50) + V = mesh._V + F = mesh._F + tex = Textures( + maps=torch.randn((B, 16, 16, 3)), + faces_uvs=torch.randint(size=(B, F, 3), low=0, high=V), + verts_uvs=torch.randn((B, V, 2)), + ) + tex_mesh = Meshes( + verts=mesh.verts_padded(), faces=mesh.faces_padded(), textures=tex + ) + N = 20 + new_mesh = tex_mesh.extend(N) + + self.assertEqual(len(tex_mesh) * N, len(new_mesh)) + + tex_init = tex_mesh.textures + new_tex = new_mesh.textures + + for i in range(len(tex_mesh)): + for n in range(N): + self.assertClose( + tex_init.faces_uvs_list()[i], + new_tex.faces_uvs_list()[i * N + n], + ) + self.assertClose( + tex_init.verts_uvs_list()[i], + new_tex.verts_uvs_list()[i * N + n], + ) + self.assertAllSeparate( + [ + tex_init.faces_uvs_padded(), + new_tex.faces_uvs_padded(), + tex_init.verts_uvs_padded(), + new_tex.verts_uvs_padded(), + tex_init.maps_padded(), + new_tex.maps_padded(), + ] + ) + with self.assertRaises(ValueError): + tex_mesh.extend(N=-1) + + def test_clip_barycentric_coords(self): + barycentric_coords = torch.tensor( + [[1.5, -0.3, -0.2], [1.2, 0.3, -0.5]], dtype=torch.float32 + ) + expected_out = torch.tensor( + [[1.0, 0.0, 0.0], [1.0 / 1.3, 0.3 / 1.3, 0.0]], dtype=torch.float32 + ) + clipped = _clip_barycentric_coordinates(barycentric_coords) + self.assertTrue(torch.allclose(clipped, expected_out)) diff --git a/tests/test_transforms.py b/tests/test_transforms.py new file mode 100644 index 00000000..1db25ff7 --- /dev/null +++ b/tests/test_transforms.py @@ -0,0 +1,1025 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import math +import unittest +import torch + +from pytorch3d.transforms.so3 import so3_exponential_map +from pytorch3d.transforms.transform3d import ( + Rotate, + RotateAxisAngle, + Scale, + Transform3d, + Translate, +) + + +class TestTransform(unittest.TestCase): + def test_to(self): + tr = Translate(torch.FloatTensor([[1.0, 2.0, 3.0]])) + R = torch.FloatTensor( + [[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]] + ) + R = Rotate(R) + t = Transform3d().compose(R, tr) + for _ in range(3): + t.cpu() + t.cuda() + t.cuda() + t.cpu() + + def test_clone(self): + """ + Check that cloned transformations contain different _matrix objects. + Also, the clone of a composed translation and rotation has to be + the same as composition of clones of translation and rotation. + """ + tr = Translate(torch.FloatTensor([[1.0, 2.0, 3.0]])) + R = torch.FloatTensor( + [[0.0, 1.0, 0.0], [0.0, 0.0, 1.0], [1.0, 0.0, 0.0]] + ) + R = Rotate(R) + + # check that the _matrix property of clones of + # both transforms are different + for t in (R, tr): + self.assertTrue(t._matrix is not t.clone()._matrix) + + # check that the _transforms lists of composition of R, tr contain + # different objects + t1 = Transform3d().compose(R, tr) + for t, t_clone in (t1._transforms, t1.clone()._transforms): + self.assertTrue(t is not t_clone) + self.assertTrue(t._matrix is not t_clone._matrix) + + # check that all composed transforms are numerically equivalent + t2 = Transform3d().compose(R.clone(), tr.clone()) + t3 = t1.clone() + for t_pair in ((t1, t2), (t1, t3), (t2, t3)): + matrix1 = t_pair[0].get_matrix() + matrix2 = t_pair[1].get_matrix() + self.assertTrue(torch.allclose(matrix1, matrix2)) + + def test_translate(self): + t = Transform3d().translate(1, 2, 3) + points = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.5, 0.5, 0.0]] + ).view(1, 3, 3) + normals = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]] + ).view(1, 3, 3) + points_out = t.transform_points(points) + normals_out = t.transform_normals(normals) + points_out_expected = torch.tensor( + [[2.0, 2.0, 3.0], [1.0, 3.0, 3.0], [1.5, 2.5, 3.0]] + ).view(1, 3, 3) + normals_out_expected = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]] + ).view(1, 3, 3) + self.assertTrue(torch.allclose(points_out, points_out_expected)) + self.assertTrue(torch.allclose(normals_out, normals_out_expected)) + + def test_scale(self): + t = Transform3d().scale(2.0).scale(0.5, 0.25, 1.0) + points = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.5, 0.5, 0.0]] + ).view(1, 3, 3) + normals = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]] + ).view(1, 3, 3) + points_out = t.transform_points(points) + normals_out = t.transform_normals(normals) + points_out_expected = torch.tensor( + [[1.00, 0.00, 0.00], [0.00, 0.50, 0.00], [0.50, 0.25, 0.00]] + ).view(1, 3, 3) + normals_out_expected = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 2.0, 0.0], [1.0, 2.0, 0.0]] + ).view(1, 3, 3) + self.assertTrue(torch.allclose(points_out, points_out_expected)) + self.assertTrue(torch.allclose(normals_out, normals_out_expected)) + + def test_scale_translate(self): + t = Transform3d().scale(2, 1, 3).translate(1, 2, 3) + points = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.5, 0.5, 0.0]] + ).view(1, 3, 3) + normals = torch.tensor( + [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [1.0, 1.0, 0.0]] + ).view(1, 3, 3) + points_out = t.transform_points(points) + normals_out = t.transform_normals(normals) + points_out_expected = torch.tensor( + [[3.0, 2.0, 3.0], [1.0, 3.0, 3.0], [2.0, 2.5, 3.0]] + ).view(1, 3, 3) + normals_out_expected = torch.tensor( + [[0.5, 0.0, 0.0], [0.0, 1.0, 0.0], [0.5, 1.0, 0.0]] + ).view(1, 3, 3) + self.assertTrue(torch.allclose(points_out, points_out_expected)) + self.assertTrue(torch.allclose(normals_out, normals_out_expected)) + + def test_rotate_axis_angle(self): + t = Transform3d().rotate_axis_angle(-90.0, axis="Z") + points = torch.tensor( + [[0.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 1.0, 1.0]] + ).view(1, 3, 3) + normals = torch.tensor( + [[1.0, 0.0, 0.0], [1.0, 0.0, 0.0], [1.0, 0.0, 0.0]] + ).view(1, 3, 3) + points_out = t.transform_points(points) + normals_out = t.transform_normals(normals) + points_out_expected = torch.tensor( + [[0.0, 0.0, 0.0], [-1.0, 0.0, 0.0], [-1.0, 0.0, 1.0]] + ).view(1, 3, 3) + normals_out_expected = torch.tensor( + [[0.0, 1.0, 0.0], [0.0, 1.0, 0.0], [0.0, 1.0, 0.0]] + ).view(1, 3, 3) + self.assertTrue(torch.allclose(points_out, points_out_expected)) + self.assertTrue(torch.allclose(normals_out, normals_out_expected)) + + def test_transform_points_fail(self): + t1 = Scale(0.1, 0.1, 0.1) + P = 7 + with self.assertRaises(ValueError): + t1.transform_points(torch.randn(P)) + + def test_compose_fail(self): + # Only composing Transform3d objects is possible + t1 = Scale(0.1, 0.1, 0.1) + with self.assertRaises(ValueError): + t1.compose(torch.randn(100)) + + def test_transform_points_eps(self): + t1 = Transform3d() + persp_proj = [ + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + [0.0, 0.0, 1.0, 0.0], + ] + ] + t1._matrix = torch.FloatTensor(persp_proj) + points = torch.tensor( + [[0.0, 1.0, 0.0], [0.0, 0.0, 1e-5], [-1.0, 0.0, 1e-5]] + ).view( + 1, 3, 3 + ) # a set of points with z-coord very close to 0 + + proj = t1.transform_points(points) + proj_eps = t1.transform_points(points, eps=1e-4) + + self.assertTrue(not bool(torch.isfinite(proj.sum()))) + self.assertTrue(bool(torch.isfinite(proj_eps.sum()))) + + def test_inverse(self, batch_size=5): + device = torch.device("cuda:0") + + # generate a random chain of transforms + for _ in range(10): # 10 different tries + + # list of transform matrices + ts = [] + + for i in range(10): + choice = float(torch.rand(1)) + if choice <= 1.0 / 3.0: + t_ = Translate( + torch.randn( + (batch_size, 3), dtype=torch.float32, device=device + ), + device=device, + ) + elif choice <= 2.0 / 3.0: + t_ = Rotate( + so3_exponential_map( + torch.randn( + (batch_size, 3), + dtype=torch.float32, + device=device, + ) + ), + device=device, + ) + else: + rand_t = torch.randn( + (batch_size, 3), dtype=torch.float32, device=device + ) + rand_t = rand_t.sign() * torch.clamp(rand_t.abs(), 0.2) + t_ = Scale(rand_t, device=device) + ts.append(t_._matrix.clone()) + + if i == 0: + t = t_ + else: + t = t.compose(t_) + + # generate the inverse transformation in several possible ways + m1 = t.inverse(invert_composed=True).get_matrix() + m2 = t.inverse(invert_composed=True)._matrix + m3 = t.inverse(invert_composed=False).get_matrix() + m4 = t.get_matrix().inverse() + + # compute the inverse explicitly ... + m5 = torch.eye(4, dtype=torch.float32, device=device) + m5 = m5[None].repeat(batch_size, 1, 1) + for t_ in ts: + m5 = torch.bmm(torch.inverse(t_), m5) + + # assert all same + for m in (m1, m2, m3, m4): + self.assertTrue(torch.allclose(m, m5, atol=1e-3)) + + +class TestTranslate(unittest.TestCase): + def test_python_scalar(self): + t = Translate(0.2, 0.3, 0.4) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_torch_scalar(self): + x = torch.tensor(0.2) + y = torch.tensor(0.3) + z = torch.tensor(0.4) + t = Translate(x, y, z) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_mixed_scalars(self): + x = 0.2 + y = torch.tensor(0.3) + z = 0.4 + t = Translate(x, y, z) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_torch_scalar_grads(self): + # Make sure backprop works if we give torch scalars + x = torch.tensor(0.2, requires_grad=True) + y = torch.tensor(0.3, requires_grad=True) + z = torch.tensor(0.4) + t = Translate(x, y, z) + t._matrix.sum().backward() + self.assertTrue(hasattr(x, "grad")) + self.assertTrue(hasattr(y, "grad")) + self.assertTrue(torch.allclose(x.grad, x.new_ones(x.shape))) + self.assertTrue(torch.allclose(y.grad, y.new_ones(y.shape))) + + def test_torch_vectors(self): + x = torch.tensor([0.2, 2.0]) + y = torch.tensor([0.3, 3.0]) + z = torch.tensor([0.4, 4.0]) + t = Translate(x, y, z) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ], + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [2.0, 3.0, 4.0, 1], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_vector_broadcast(self): + x = torch.tensor([0.2, 2.0]) + y = torch.tensor([0.3, 3.0]) + z = torch.tensor([0.4]) + t = Translate(x, y, z) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ], + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [2.0, 3.0, 0.4, 1], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_bad_broadcast(self): + x = torch.tensor([0.2, 2.0, 20.0]) + y = torch.tensor([0.3, 3.0]) + z = torch.tensor([0.4]) + with self.assertRaises(ValueError): + Translate(x, y, z) + + def test_mixed_broadcast(self): + x = 0.2 + y = torch.tensor(0.3) + z = torch.tensor([0.4, 4.0]) + t = Translate(x, y, z) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ], + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 4.0, 1], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_mixed_broadcast_grad(self): + x = 0.2 + y = torch.tensor(0.3, requires_grad=True) + z = torch.tensor([0.4, 4.0], requires_grad=True) + t = Translate(x, y, z) + t._matrix.sum().backward() + self.assertTrue(hasattr(y, "grad")) + self.assertTrue(hasattr(z, "grad")) + y_grad = torch.tensor(2.0) + z_grad = torch.tensor([1.0, 1.0]) + self.assertEqual(y.grad.shape, y_grad.shape) + self.assertEqual(z.grad.shape, z_grad.shape) + self.assertTrue(torch.allclose(y.grad, y_grad)) + self.assertTrue(torch.allclose(z.grad, z_grad)) + + def test_matrix(self): + xyz = torch.tensor([[0.2, 0.3, 0.4], [2.0, 3.0, 4.0]]) + t = Translate(xyz) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [0.2, 0.3, 0.4, 1], + ], + [ + [1.0, 0.0, 0.0, 0], + [0.0, 1.0, 0.0, 0], + [0.0, 0.0, 1.0, 0], + [2.0, 3.0, 4.0, 1], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_matrix_extra_args(self): + xyz = torch.tensor([[0.2, 0.3, 0.4], [2.0, 3.0, 4.0]]) + with self.assertRaises(ValueError): + Translate(xyz, xyz[:, 1], xyz[:, 2]) + + def test_inverse(self): + xyz = torch.tensor([[0.2, 0.3, 0.4], [2.0, 3.0, 4.0]]) + t = Translate(xyz) + im = t.inverse()._matrix + im_2 = t._matrix.inverse() + im_comp = t.get_matrix().inverse() + self.assertTrue(torch.allclose(im, im_comp)) + self.assertTrue(torch.allclose(im, im_2)) + + +class TestScale(unittest.TestCase): + def test_single_python_scalar(self): + t = Scale(0.1) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.1, 0.0, 0.0], + [0.0, 0.0, 0.1, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_single_torch_scalar(self): + t = Scale(torch.tensor(0.1)) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.1, 0.0, 0.0], + [0.0, 0.0, 0.1, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_single_vector(self): + t = Scale(torch.tensor([0.1, 0.2])) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.1, 0.0, 0.0], + [0.0, 0.0, 0.1, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [0.2, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.2, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_single_matrix(self): + xyz = torch.tensor([[0.1, 0.2, 0.3], [1.0, 2.0, 3.0]]) + t = Scale(xyz) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 2.0, 0.0, 0.0], + [0.0, 0.0, 3.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_three_python_scalar(self): + t = Scale(0.1, 0.2, 0.3) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_three_torch_scalar(self): + t = Scale(torch.tensor(0.1), torch.tensor(0.2), torch.tensor(0.3)) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_three_mixed_scalar(self): + t = Scale(torch.tensor(0.1), 0.2, torch.tensor(0.3)) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_three_vector_broadcast(self): + x = torch.tensor([0.1]) + y = torch.tensor([0.2, 2.0]) + z = torch.tensor([0.3, 3.0]) + t = Scale(x, y, z) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 2.0, 0.0, 0.0], + [0.0, 0.0, 3.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_three_mixed_broadcast_grad(self): + x = 0.1 + y = torch.tensor(0.2, requires_grad=True) + z = torch.tensor([0.3, 3.0], requires_grad=True) + t = Scale(x, y, z) + matrix = torch.tensor( + [ + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 0.3, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [0.1, 0.0, 0.0, 0.0], + [0.0, 0.2, 0.0, 0.0], + [0.0, 0.0, 3.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + t._matrix.sum().backward() + self.assertTrue(hasattr(y, "grad")) + self.assertTrue(hasattr(z, "grad")) + y_grad = torch.tensor(2.0) + z_grad = torch.tensor([1.0, 1.0]) + self.assertTrue(torch.allclose(y.grad, y_grad)) + self.assertTrue(torch.allclose(z.grad, z_grad)) + + def test_inverse(self): + x = torch.tensor([0.1]) + y = torch.tensor([0.2, 2.0]) + z = torch.tensor([0.3, 3.0]) + t = Scale(x, y, z) + im = t.inverse()._matrix + im_2 = t._matrix.inverse() + im_comp = t.get_matrix().inverse() + self.assertTrue(torch.allclose(im, im_comp)) + self.assertTrue(torch.allclose(im, im_2)) + + +class TestTransformBroadcast(unittest.TestCase): + def test_broadcast_transform_points(self): + t1 = Scale(0.1, 0.1, 0.1) + N = 10 + P = 7 + M = 20 + x = torch.tensor([0.2] * N) + y = torch.tensor([0.3] * N) + z = torch.tensor([0.4] * N) + tN = Translate(x, y, z) + p1 = t1.transform_points(torch.randn(P, 3)) + self.assertTrue(p1.shape == (P, 3)) + p2 = t1.transform_points(torch.randn(1, P, 3)) + self.assertTrue(p2.shape == (1, P, 3)) + p3 = t1.transform_points(torch.randn(M, P, 3)) + self.assertTrue(p3.shape == (M, P, 3)) + p4 = tN.transform_points(torch.randn(P, 3)) + self.assertTrue(p4.shape == (N, P, 3)) + p5 = tN.transform_points(torch.randn(1, P, 3)) + self.assertTrue(p5.shape == (N, P, 3)) + + def test_broadcast_transform_normals(self): + t1 = Scale(0.1, 0.1, 0.1) + N = 10 + P = 7 + M = 20 + x = torch.tensor([0.2] * N) + y = torch.tensor([0.3] * N) + z = torch.tensor([0.4] * N) + tN = Translate(x, y, z) + p1 = t1.transform_normals(torch.randn(P, 3)) + self.assertTrue(p1.shape == (P, 3)) + p2 = t1.transform_normals(torch.randn(1, P, 3)) + self.assertTrue(p2.shape == (1, P, 3)) + p3 = t1.transform_normals(torch.randn(M, P, 3)) + self.assertTrue(p3.shape == (M, P, 3)) + p4 = tN.transform_normals(torch.randn(P, 3)) + self.assertTrue(p4.shape == (N, P, 3)) + p5 = tN.transform_normals(torch.randn(1, P, 3)) + self.assertTrue(p5.shape == (N, P, 3)) + + def test_broadcast_compose(self): + t1 = Scale(0.1, 0.1, 0.1) + N = 10 + scale_n = torch.tensor([0.3] * N) + tN = Scale(scale_n) + t1N = t1.compose(tN) + self.assertTrue(t1._matrix.shape == (1, 4, 4)) + self.assertTrue(tN._matrix.shape == (N, 4, 4)) + self.assertTrue(t1N.get_matrix().shape == (N, 4, 4)) + t11 = t1.compose(t1) + self.assertTrue(t11.get_matrix().shape == (1, 4, 4)) + + def test_broadcast_compose_fail(self): + # Cannot compose two transforms which have batch dimensions N and M + # other than the case where either N or M is 1 + N = 10 + M = 20 + scale_n = torch.tensor([0.3] * N) + tN = Scale(scale_n) + x = torch.tensor([0.2] * M) + y = torch.tensor([0.3] * M) + z = torch.tensor([0.4] * M) + tM = Translate(x, y, z) + with self.assertRaises(ValueError): + t = tN.compose(tM) + t.get_matrix() + + def test_multiple_broadcast_compose(self): + t1 = Scale(0.1, 0.1, 0.1) + t2 = Scale(0.2, 0.2, 0.2) + N = 10 + scale_n = torch.tensor([0.3] * N) + tN = Scale(scale_n) + t1N2 = t1.compose(tN.compose(t2)) + composed_mat = t1N2.get_matrix() + self.assertTrue(composed_mat.shape == (N, 4, 4)) + expected_mat = torch.eye(3, dtype=torch.float32) * 0.3 * 0.2 * 0.1 + self.assertTrue(torch.allclose(composed_mat[0, :3, :3], expected_mat)) + + +class TestRotate(unittest.TestCase): + def test_single_matrix(self): + R = torch.eye(3) + t = Rotate(R) + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ] + ], + dtype=torch.float32, + ) + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_invalid_dimensions(self): + R = torch.eye(4) + with self.assertRaises(ValueError): + Rotate(R) + + def test_inverse(self, batch_size=5): + device = torch.device("cuda:0") + log_rot = torch.randn( + (batch_size, 3), dtype=torch.float32, device=device + ) + R = so3_exponential_map(log_rot) + t = Rotate(R) + im = t.inverse()._matrix + im_2 = t._matrix.inverse() + im_comp = t.get_matrix().inverse() + self.assertTrue(torch.allclose(im, im_comp, atol=1e-4)) + self.assertTrue(torch.allclose(im, im_2, atol=1e-4)) + + +class TestRotateAxisAngle(unittest.TestCase): + def test_rotate_x_python_scalar(self): + t = RotateAxisAngle(angle=90, axis="X") + # fmt: off + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, -1.0, 0.0], # noqa: E241, E201 + [0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix)) + + def test_rotate_x_torch_scalar(self): + angle = torch.tensor(90.0) + t = RotateAxisAngle(angle=angle, axis="X") + # fmt: off + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, -1.0, 0.0], # noqa: E241, E201 + [0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_x_torch_tensor(self): + angle = torch.tensor([0, 45.0, 90.0]) # (N) + t = RotateAxisAngle(angle=angle, axis="X") + r2_i = 1 / math.sqrt(2) + r2_2 = math.sqrt(2) / 2 + # fmt: off + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, r2_2, -r2_i, 0.0], # noqa: E241, E201 + [0.0, r2_i, r2_2, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ], + [ + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, -1.0, 0.0], # noqa: E241, E201 + [0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + angle = angle[..., None] # (N, 1) + t = RotateAxisAngle(angle=angle, axis="X") + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_y_python_scalar(self): + t = RotateAxisAngle(angle=90, axis="Y") + # fmt: off + matrix = torch.tensor( + [ + [ + [ 0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [-1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_y_torch_scalar(self): + angle = torch.tensor(90.0) + t = RotateAxisAngle(angle=angle, axis="Y") + # fmt: off + matrix = torch.tensor( + [ + [ + [ 0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [-1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_y_torch_tensor(self): + angle = torch.tensor([0, 45.0, 90.0]) + t = RotateAxisAngle(angle=angle, axis="Y") + r2_i = 1 / math.sqrt(2) + r2_2 = math.sqrt(2) / 2 + # fmt: off + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [ r2_2, 0.0, r2_i, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [-r2_i, 0.0, r2_2, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ], + [ + [ 0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [-1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_z_python_scalar(self): + t = RotateAxisAngle(angle=90, axis="Z") + # fmt: off + matrix = torch.tensor( + [ + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_z_torch_scalar(self): + angle = torch.tensor(90.0) + t = RotateAxisAngle(angle=angle, axis="Z") + # fmt: off + matrix = torch.tensor( + [ + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_z_torch_tensor(self): + angle = torch.tensor([0, 45.0, 90.0]) + t = RotateAxisAngle(angle=angle, axis="Z") + r2_i = 1 / math.sqrt(2) + r2_2 = math.sqrt(2) / 2 + # fmt: off + matrix = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], + [0.0, 1.0, 0.0, 0.0], + [0.0, 0.0, 1.0, 0.0], + [0.0, 0.0, 0.0, 1.0], + ], + [ + [r2_2, -r2_i, 0.0, 0.0], # noqa: E241, E201 + [r2_i, r2_2, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ], + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_rotate_compose_x_y_z(self): + angle = torch.tensor(90.0) + t1 = RotateAxisAngle(angle=angle, axis="X") + t2 = RotateAxisAngle(angle=angle, axis="Y") + t3 = RotateAxisAngle(angle=angle, axis="Z") + t = t1.compose(t2, t3) + # fmt: off + matrix1 = torch.tensor( + [ + [ + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, -1.0, 0.0], # noqa: E241, E201 + [0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + matrix2 = torch.tensor( + [ + [ + [ 0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [ 0.0, 1.0, 0.0, 0.0], # noqa: E241, E201 + [-1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [ 0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + matrix3 = torch.tensor( + [ + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + # order of transforms is t1 -> t2 + matrix = torch.matmul(matrix1, torch.matmul(matrix2, matrix3)) + composed_matrix = t.get_matrix() + self.assertTrue(torch.allclose(composed_matrix, matrix, atol=1e-7)) + + def test_rotate_angle_radians(self): + t = RotateAxisAngle(angle=math.pi / 2, degrees=False, axis="Z") + # fmt: off + matrix = torch.tensor( + [ + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_lower_case_axis(self): + t = RotateAxisAngle(angle=90.0, axis="z") + # fmt: off + matrix = torch.tensor( + [ + [ + [0.0, -1.0, 0.0, 0.0], # noqa: E241, E201 + [1.0, 0.0, 0.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 1.0, 0.0], # noqa: E241, E201 + [0.0, 0.0, 0.0, 1.0], # noqa: E241, E201 + ] + ], + dtype=torch.float32, + ) + # fmt: on + self.assertTrue(torch.allclose(t._matrix, matrix, atol=1e-7)) + + def test_axis_fail(self): + with self.assertRaises(ValueError): + RotateAxisAngle(angle=90.0, axis="P") + + def test_rotate_angle_fail(self): + angle = torch.tensor([[0, 45.0, 90.0], [0, 45.0, 90.0]]) + with self.assertRaises(ValueError): + RotateAxisAngle(angle=angle, axis="X") diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 00000000..43330b9e --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +import torch + +from pytorch3d.renderer.utils import TensorProperties + +from common_testing import TestCaseMixin + + +# Example class for testing +class TensorPropertiesTestClass(TensorProperties): + def __init__(self, x=None, y=None, device="cpu"): + super().__init__(device=device, x=x, y=y) + + def clone(self): + other = TensorPropertiesTestClass() + return super().clone(other) + + +class TestTensorProperties(TestCaseMixin, unittest.TestCase): + def test_init(self): + example = TensorPropertiesTestClass(x=10.0, y=(100.0, 200.0)) + # Check kwargs set as attributes + converted to tensors + self.assertTrue(torch.is_tensor(example.x)) + self.assertTrue(torch.is_tensor(example.y)) + # Check broadcasting + self.assertTrue(example.x.shape == (2,)) + self.assertTrue(example.y.shape == (2,)) + self.assertTrue(len(example) == 2) + + def test_to(self): + # Check to method + example = TensorPropertiesTestClass(x=10.0, y=(100.0, 200.0)) + device = torch.device("cuda:0") + new_example = example.to(device=device) + self.assertTrue(new_example.device == device) + + def test_clone(self): + # Check clone method + example = TensorPropertiesTestClass(x=10.0, y=(100.0, 200.0)) + new_example = example.clone() + self.assertSeparate(example.x, new_example.x) + self.assertSeparate(example.y, new_example.y) + + def test_get_set(self): + # Test getitem returns an accessor which can be used to modify + # attributes at a particular index + example = TensorPropertiesTestClass(x=10.0, y=(100.0, 200.0, 300.0)) + + # update y1 + example[1].y = 5.0 + self.assertTrue(example.y[1] == 5.0) + + # Get item and get value + ex0 = example[0] + self.assertTrue(ex0.y == 100.0) + + def test_empty_input(self): + example = TensorPropertiesTestClass(x=(), y=()) + self.assertTrue(len(example) == 0) + self.assertTrue(example.isempty()) diff --git a/tests/test_vert_align.py b/tests/test_vert_align.py new file mode 100644 index 00000000..24c1e1ec --- /dev/null +++ b/tests/test_vert_align.py @@ -0,0 +1,176 @@ +#!/usr/bin/env python3 +# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved. + + +import unittest +import torch +import torch.nn.functional as F + +from pytorch3d.ops.vert_align import vert_align +from pytorch3d.structures.meshes import Meshes + + +class TestVertAlign(unittest.TestCase): + @staticmethod + def vert_align_naive( + feats, + verts_or_meshes, + return_packed: bool = False, + align_corners: bool = True, + ): + """ + Naive implementation of vert_align. + """ + if torch.is_tensor(feats): + feats = [feats] + N = feats[0].shape[0] + + out_feats = [] + # sample every example in the batch separately + for i in range(N): + out_i_feats = [] + for feat in feats: + feats_i = feat[i][None, :, :, :] # (1, C, H, W) + if torch.is_tensor(verts_or_meshes): + grid = verts_or_meshes[i][None, None, :, :2] # (1, 1, V, 2) + elif hasattr(verts_or_meshes, "verts_list"): + grid = verts_or_meshes.verts_list()[i][ + None, None, :, :2 + ] # (1, 1, V, 2) + else: + raise ValueError("verts_or_meshes is invalid") + feat_sampled_i = F.grid_sample( + feats_i, + grid, + mode="bilinear", + padding_mode="zeros", + align_corners=align_corners, + ) # (1, C, 1, V) + feat_sampled_i = feat_sampled_i.squeeze(2).squeeze(0) # (C, V) + feat_sampled_i = feat_sampled_i.transpose(1, 0) # (V, C) + out_i_feats.append(feat_sampled_i) + out_i_feats = torch.cat(out_i_feats, 1) # (V, sum(C)) + out_feats.append(out_i_feats) + + if return_packed: + out_feats = torch.cat(out_feats, 0) # (sum(V), sum(C)) + else: + out_feats = torch.stack(out_feats, 0) # (N, V, sum(C)) + return out_feats + + @staticmethod + def init_meshes( + num_meshes: int = 10, num_verts: int = 1000, num_faces: int = 3000 + ): + device = torch.device("cuda:0") + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = ( + torch.rand((num_verts, 3), dtype=torch.float32, device=device) + * 2.0 + - 1.0 + ) # verts in the space of [-1, 1] + faces = torch.randint( + num_verts, size=(num_faces, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + + return meshes + + @staticmethod + def init_feats( + batch_size: int = 10, num_channels: int = 256, device: str = "cuda" + ): + H, W = [14, 28], [14, 28] + feats = [] + for (h, w) in zip(H, W): + feats.append( + torch.rand((batch_size, num_channels, h, w), device=device) + ) + return feats + + def test_vert_align_with_meshes(self): + """ + Test vert align vs naive implementation with meshes. + """ + meshes = TestVertAlign.init_meshes(10, 1000, 3000) + feats = TestVertAlign.init_feats(10, 256) + + # feats in list + out = vert_align(feats, meshes, return_packed=True) + naive_out = TestVertAlign.vert_align_naive( + feats, meshes, return_packed=True + ) + self.assertTrue(torch.allclose(out, naive_out)) + + # feats as tensor + out = vert_align(feats[0], meshes, return_packed=True) + naive_out = TestVertAlign.vert_align_naive( + feats[0], meshes, return_packed=True + ) + self.assertTrue(torch.allclose(out, naive_out)) + + def test_vert_align_with_verts(self): + """ + Test vert align vs naive implementation with verts as tensor. + """ + feats = TestVertAlign.init_feats(10, 256) + verts = ( + torch.rand( + (10, 100, 3), dtype=torch.float32, device=feats[0].device + ) + * 2.0 + - 1.0 + ) + + # feats in list + out = vert_align(feats, verts, return_packed=True) + naive_out = TestVertAlign.vert_align_naive( + feats, verts, return_packed=True + ) + self.assertTrue(torch.allclose(out, naive_out)) + + # feats as tensor + out = vert_align(feats[0], verts, return_packed=True) + naive_out = TestVertAlign.vert_align_naive( + feats[0], verts, return_packed=True + ) + self.assertTrue(torch.allclose(out, naive_out)) + + out2 = vert_align( + feats[0], verts, return_packed=True, align_corners=False + ) + naive_out2 = TestVertAlign.vert_align_naive( + feats[0], verts, return_packed=True, align_corners=False + ) + self.assertFalse(torch.allclose(out, out2)) + self.assertTrue(torch.allclose(out2, naive_out2)) + + @staticmethod + def vert_align_with_init( + num_meshes: int, num_verts: int, num_faces: int, device: str = "cpu" + ): + device = torch.device(device) + verts_list = [] + faces_list = [] + for _ in range(num_meshes): + verts = torch.rand( + (num_verts, 3), dtype=torch.float32, device=device + ) + faces = torch.randint( + num_verts, size=(num_faces, 3), dtype=torch.int64, device=device + ) + verts_list.append(verts) + faces_list.append(faces) + meshes = Meshes(verts_list, faces_list) + feats = TestVertAlign.init_feats(num_meshes, device=device) + torch.cuda.synchronize() + + def sample_features(): + vert_align(feats, meshes, return_packed=True) + torch.cuda.synchronize() + + return sample_features diff --git a/tests/weights.pt b/tests/weights.pt new file mode 100644 index 00000000..0cd05f98 Binary files /dev/null and b/tests/weights.pt differ