Uploading all files

.dockerignore

@@ -0,0 +1,6 @@
+*.zip
+.git
+datasets/linemod/Linemod_preprocessed
+datasets/ycb/YCB_Video_Dataset
+*.pth
+YCB_Video_toolbox/*

.gitattributes

@@ -1,35 +1,40 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/compare.png filter=lfs diff=lfs merge=lfs -text
+assets/pullfig.png filter=lfs diff=lfs merge=lfs -text
+assets/result_linemod.png filter=lfs diff=lfs merge=lfs -text
+assets/result_ycb.png filter=lfs diff=lfs merge=lfs -text
+lib/knn/knn_pytorch/_knn_pytorch.so filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,10 @@
+datasets/linemod/Linemod_preprocessed
+datasets/ycb/YCB_Video_Dataset
+*.zip
+*__pycache__
+experiments/logs/*
+*.pyc
+lib/knn/knn_pytorch/__pycache__/*
+__init__.*
+*.pth
+YCB_Video_toolbox

Dockerfile

@@ -0,0 +1,33 @@
+FROM nvidia/cudagl:9.0-devel-ubuntu16.04
+
+ARG DEBIAN_FRONTEND=noninteractive
+
+# Essentials: developer tools, build tools, OpenBLAS
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    apt-utils git curl vim unzip openssh-client wget \
+    build-essential cmake \
+    libopenblas-dev \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev
+
+# Python 3.5
+RUN apt-get update && apt-get install -y --no-install-recommends python3.5 python3.5-dev python3-pip python3-tk && \
+    pip3 install --no-cache-dir --upgrade pip setuptools && \
+    echo "alias python='python3'" >> /root/.bash_aliases && \
+    echo "alias pip='pip3'" >> /root/.bash_aliases
+
+# Science libraries and other common packages
+RUN pip3 --no-cache-dir install \
+    numpy scipy pyyaml cffi pyyaml matplotlib Cython requests opencv-python "pillow<7"
+
+# Tensorflow
+RUN pip3 install https://download.pytorch.org/whl/cu90/torch-0.4.1-cp35-cp35m-linux_x86_64.whl && \
+    pip3 install torchvision==0.2.2.post3
+
+# Expose port for TensorBoard
+EXPOSE 6006
+
+# cd to home on login
+RUN echo "cd /root/dense_fusion" >> /root/.bashrc

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Jeremy Wang
+
+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.

README.md

@@ -1,3 +1,199 @@
----
-license: mit
----
+# DenseFusion
+
+<p align="center">
+	<img src ="assets/pullfig.png" width="1000" />
+</p>
+
+## News
+We have released the code and arXiv preprint for our new project [6-PACK](https://sites.google.com/view/6packtracking) which is based on this work and used for category-level 6D pose tracking.
+
+## Table of Content
+- [Overview](#overview)
+- [Requirements](#requirements)
+- [Code Structure](#code-structure)
+- [Datasets](#datasets)
+- [Training](#training)
+- [Evaluation](#evaluation)
+	- [Evaluation on YCB_Video Dataset](#evaluation-on-ycb_video-dataset)
+	- [Evaluation on LineMOD Dataset](#evaluation-on-linemod-dataset)
+- [Results](#results)
+- [Trained Checkpoints](#trained-checkpoints)
+- [Tips for your own dataset](#tips-for-your-own-dataset)
+- [Citations](#citations)
+- [License](#license)
+
+## Overview
+
+This repository is the implementation code of the paper "DenseFusion: 6D Object Pose Estimation by Iterative Dense Fusion"([arXiv](https://arxiv.org/abs/1901.04780), [Project](https://sites.google.com/view/densefusion), [Video](https://www.youtube.com/watch?v=SsE5-FuK5jo)) by Wang et al. at [Stanford Vision and Learning Lab](http://svl.stanford.edu/) and [Stanford People, AI & Robots Group](http://pair.stanford.edu/). The model takes an RGB-D image as input and predicts the 6D pose of the each object in the frame. This network is implemented using [PyTorch](https://pytorch.org/) and the rest of the framework is in Python. Since this project focuses on the 6D pose estimation process, we do not specifically limit the choice of the segmentation models. You can choose your preferred semantic-segmentation/instance-segmentation methods according to your needs. In this repo, we provide our full implementation code of the DenseFusion model, Iterative Refinement model and a vanilla SegNet semantic-segmentation model used in our real-robot grasping experiment. The ROS code of the real robot grasping experiment is not included.
+
+
+## Requirements
+
+* Python 2.7/3.5/3.6 (If you want to use Python2.7 to run this repo, please rebuild the `lib/knn/` (with PyTorch 0.4.1).)
+* [PyTorch 0.4.1](https://pytorch.org/) ([PyTroch 1.0 branch](<https://github.com/j96w/DenseFusion/tree/Pytorch-1.0>))
+* PIL
+* scipy
+* numpy
+* pyyaml
+* logging
+* matplotlib
+* CUDA 7.5/8.0/9.0 (Required. CPU-only will lead to extreme slow training speed because of the loss calculation of the symmetry objects (pixel-wise nearest neighbour loss).)
+
+## Code Structure
+* **datasets**
+	* **datasets/ycb**
+		* **datasets/ycb/dataset.py**: Data loader for YCB_Video dataset.
+		* **datasets/ycb/dataset_config**
+			* **datasets/ycb/dataset_config/classes.txt**: Object list of YCB_Video dataset.
+			* **datasets/ycb/dataset_config/train_data_list.txt**: Training set of YCB_Video dataset.
+			* **datasets/ycb/dataset_config/test_data_list.txt**: Testing set of YCB_Video dataset.
+	* **datasets/linemod**
+		* **datasets/linemod/dataset.py**: Data loader for LineMOD dataset.
+		* **datasets/linemod/dataset_config**: 
+			* **datasets/linemod/dataset_config/models_info.yml**: Object model info of LineMOD dataset.
+* **replace_ycb_toolbox**: Replacement codes for the evaluation with [YCB_Video_toolbox](https://github.com/yuxng/YCB_Video_toolbox).
+* **trained_models**
+	* **trained_models/ycb**: Checkpoints of YCB_Video dataset.
+	* **trained_models/linemod**: Checkpoints of LineMOD dataset.
+* **lib**
+	* **lib/loss.py**: Loss calculation for DenseFusion model.
+	* **lib/loss_refiner.py**: Loss calculation for iterative refinement model.
+	* **lib/transformations.py**: [Transformation Function Library](https://www.lfd.uci.edu/~gohlke/code/transformations.py.html).
+    * **lib/network.py**: Network architecture.
+    * **lib/extractors.py**: Encoder network architecture adapted from [pspnet-pytorch](https://github.com/Lextal/pspnet-pytorch).
+    * **lib/pspnet.py**: Decoder network architecture.
+    * **lib/utils.py**: Logger code.
+    * **lib/knn/**: CUDA K-nearest neighbours library adapted from [pytorch_knn_cuda](https://github.com/chrischoy/pytorch_knn_cuda).
+* **tools**
+	* **tools/_init_paths.py**: Add local path.
+	* **tools/eval_ycb.py**: Evaluation code for YCB_Video dataset.
+	* **tools/eval_linemod.py**: Evaluation code for LineMOD dataset.
+	* **tools/train.py**: Training code for YCB_Video dataset and LineMOD dataset.
+* **experiments**
+	* **experiments/eval_result**
+		* **experiments/eval_result/ycb**
+			* **experiments/eval_result/ycb/Densefusion_wo_refine_result**: Evaluation result on YCB_Video dataset without refinement.
+			* **experiments/eval_result/ycb/Densefusion_iterative_result**: Evaluation result on YCB_Video dataset with iterative refinement.
+		* **experiments/eval_result/linemod**: Evaluation results on LineMOD dataset with iterative refinement.
+	* **experiments/logs/**: Training log files.
+	* **experiments/scripts**
+		* **experiments/scripts/train_ycb.sh**: Training script on the YCB_Video dataset.
+		* **experiments/scripts/train_linemod.sh**: Training script on the LineMOD dataset.
+		* **experiments/scripts/eval_ycb.sh**: Evaluation script on the YCB_Video dataset.
+		* **experiments/scripts/eval_linemod.sh**: Evaluation script on the LineMOD dataset.
+* **download.sh**: Script for downloading YCB_Video Dataset, preprocessed LineMOD dataset and the trained checkpoints.
+
+
+## Datasets
+
+This work is tested on two 6D object pose estimation datasets:
+
+* [YCB_Video Dataset](https://rse-lab.cs.washington.edu/projects/posecnn/): Training and Testing sets follow [PoseCNN](https://arxiv.org/abs/1711.00199). The training set includes 80 training videos 0000-0047 & 0060-0091 (choosen by 7 frame as a gap in our training) and synthetic data 000000-079999. The testing set includes 2949 keyframes from 10 testing videos 0048-0059.
+
+* [LineMOD](http://campar.in.tum.de/Main/StefanHinterstoisser): Download the [preprocessed LineMOD dataset](https://drive.google.com/drive/folders/19ivHpaKm9dOrr12fzC8IDFczWRPFxho7) (including the testing results outputted by the trained vanilla SegNet used for evaluation).
+
+Download YCB_Video Dataset, preprocessed LineMOD dataset and the trained checkpoints (You can modify this script according to your needs.):
+```	
+./download.sh
+```
+
+## Training
+
+* YCB_Video Dataset:
+	After you have downloaded and unzipped the YCB_Video_Dataset.zip and installed all the dependency packages, please run:
+```	
+./experiments/scripts/train_ycb.sh
+```
+* LineMOD Dataset:
+	After you have downloaded and unzipped the Linemod_preprocessed.zip, please run:
+```	
+./experiments/scripts/train_linemod.sh
+```
+**Training Process**: The training process contains two components: (i) Training of the DenseFusion model. (ii) Training of the Iterative Refinement model. In this code, a DenseFusion model will be trained first. When the average testing distance result (ADD for non-symmetry objects, ADD-S for symmetry objects) is smaller than a certain margin, the training of the Iterative Refinement model will start automatically and the DenseFusion model will then be fixed. You can change this margin to have better DenseFusion result without refinement but it's inferior than the final result after the iterative refinement. 
+
+**Checkpoints and Resuming**: After the training of each 1000 batches, a `pose_model_current.pth` / `pose_refine_model_current.pth` checkpoint will be saved. You can use it to resume the training. After each testing epoch, if the average distance result is the best so far, a `pose_model_(epoch)_(best_score).pth` /  `pose_model_refiner_(epoch)_(best_score).pth` checkpoint will be saved. You can use it for the evaluation.
+
+**Notice**: The training of the iterative refinement model takes some time. Please be patient and the improvement will come after about 30 epoches.
+
+
+* vanilla SegNet:
+	Just run:
+```
+cd vanilla_segmentation/
+python train.py --dataset_root=./datasets/ycb/YCB_Video_Dataset
+```
+To make the best use of the training set, several data augementation techniques are used in this code:
+
+(1) A random noise is added to the brightness, contrast and saturation of the input RGB image with the `torchvision.transforms.ColorJitter` function, where we set the function as `torchvision.transforms.ColorJitter(0.2, 0.2, 0.2, 0.05)`.
+
+(2) A random pose translation noise is added to the training set of the pose estimator, where we set the range of the translation noise to 3cm for both datasets.
+
+(3) For the YCB_Video dataset, since the synthetic data is not contain background. We randomly select the real training data as the background. In each frame, we also randomly select two instances segmentation clips from another synthetic training image to mask at the front of the input RGB-D image, so that more occlusion situations can be generated.
+
+## Evaluation
+
+### Evaluation on YCB_Video Dataset
+For fair comparison, we use the same segmentation results of [PoseCNN](https://rse-lab.cs.washington.edu/projects/posecnn/) and compare with their results after ICP refinement.
+Please run:
+```
+./experiments/scripts/eval_ycb.sh
+```
+This script will first download the `YCB_Video_toolbox` to the root folder of this repo and test the selected DenseFusion and Iterative Refinement models on the 2949 keyframes of the 10 testing video in YCB_Video Dataset with the same segmentation result of PoseCNN. The result without refinement is stored in `experiments/eval_result/ycb/Densefusion_wo_refine_result` and the refined result is in `experiments/eval_result/ycb/Densefusion_iterative_result`.
+
+After that, you can add the path of `experiments/eval_result/ycb/Densefusion_wo_refine_result/` and `experiments/eval_result/ycb/Densefusion_iterative_result/` to the code `YCB_Video_toolbox/evaluate_poses_keyframe.m` and run it with [MATLAB](https://www.mathworks.com/products/matlab.html). The code `YCB_Video_toolbox/plot_accuracy_keyframe.m` can show you the comparsion plot result. You can easily make it by copying the adapted codes from the `replace_ycb_toolbox/` folder and replace them in the `YCB_Video_toolbox/` folder. But you might still need to change the path of your `YCB_Video Dataset/` in the `globals.m` and copy two result folders(`Densefusion_wo_refine_result/` and `Densefusion_iterative_result/`) to the `YCB_Video_toolbox/` folder.
+
+
+### Evaluation on LineMOD Dataset
+Just run:
+```
+./experiments/scripts/eval_linemod.sh
+```
+This script will test the models on the testing set of the LineMOD dataset with the masks outputted by the trained vanilla SegNet model. The result will be printed at the end of the execution and saved as a log in `experiments/eval_result/linemod/`.
+
+
+## Results
+
+* YCB_Video Dataset:
+
+Quantitative evaluation result with ADD-S metric compared to other RGB-D methods. `Ours(per-pixel)` is the result of the DenseFusion model without refinement and `Ours(iterative)` is the result with iterative refinement.
+
+<p align="center">
+	<img src ="assets/result_ycb.png" width="600" />
+</p>
+
+**Important!** Before you use these numbers to compare with your methods, please make sure one important issus: One difficulty for testing on the YCB_Video Dataset is how to let the network to tell the difference between the object `051_large_clamp` and `052_extra_large_clamp`. The result of all the approaches in this table uses the same segmentation masks released by PoseCNN without any detection priors, so all of them suffer a performance drop on these two objects because of the poor detection result and this drop is also added to the final overall score. If you have added detection priors to your detector to distinguish these two objects, please clarify or do not copy the overall score for comparsion experiments.
+
+* LineMOD Dataset:
+
+Quantitative evaluation result with ADD metric for non-symmetry objects and ADD-S for symmetry objects(eggbox, glue) compared to other RGB-D methods. High performance RGB methods are also listed for reference.
+
+<p align="center">
+	<img src ="assets/result_linemod.png" width="500" />
+</p>
+
+The qualitative result on the YCB_Video dataset.
+
+<p align="center">
+	<img src ="assets/compare.png" width="600" />
+</p>
+
+## Trained Checkpoints
+You can download the trained DenseFusion and Iterative Refinement checkpoints of both datasets from [Link](https://drive.google.com/drive/folders/19ivHpaKm9dOrr12fzC8IDFczWRPFxho7).
+
+## Tips for your own dataset
+As you can see in this repo, the network code and the hyperparameters (lr and w) remain the same for both datasets. Which means you might not need to adjust too much on the network structure and hyperparameters when you use this repo on your own dataset. Please make sure that the distance metric in your dataset should be converted to meter, otherwise the hyperparameter w need to be adjusted. Several useful tools including [LabelFusion](https://github.com/RobotLocomotion/LabelFusion) and [sixd_toolkit](https://github.com/thodan/sixd_toolkit) has been tested to work well. (Please make sure to turn on the depth image collection in LabelFusion when you use it.)
+
+
+## Citations
+Please cite [DenseFusion](https://sites.google.com/view/densefusion) if you use this repository in your publications:
+```
+@article{wang2019densefusion,
+  title={DenseFusion: 6D Object Pose Estimation by Iterative Dense Fusion},
+  author={Wang, Chen and Xu, Danfei and Zhu, Yuke and Mart{\'\i}n-Mart{\'\i}n, Roberto and Lu, Cewu and Fei-Fei, Li and Savarese, Silvio},
+  booktitle={Computer Vision and Pattern Recognition (CVPR)},
+  year={2019}
+}
+```
+
+## License
+Licensed under the [MIT License](LICENSE)

build.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+#docker build --no-cache -t hri -f Dockerfile .
+docker build -t dense_fusion -f Dockerfile .

datasets/linemod/dataset.py

@@ -0,0 +1,291 @@
+import torch.utils.data as data
+from PIL import Image
+import os
+import os.path
+import errno
+import torch
+import json
+import codecs
+import numpy as np
+import sys
+import torchvision.transforms as transforms
+import argparse
+import json
+import time
+import random
+import numpy.ma as ma
+import copy
+import scipy.misc
+import scipy.io as scio
+import yaml
+import cv2
+
+
+class PoseDataset(data.Dataset):
+    def __init__(self, mode, num, add_noise, root, noise_trans, refine):
+        self.objlist = [1, 2, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15]
+        self.mode = mode
+
+        self.list_rgb = []
+        self.list_depth = []
+        self.list_label = []
+        self.list_obj = []
+        self.list_rank = []
+        self.meta = {}
+        self.pt = {}
+        self.root = root
+        self.noise_trans = noise_trans
+        self.refine = refine
+
+        item_count = 0
+        for item in self.objlist:
+            if self.mode == 'train':
+                input_file = open('{0}/data/{1}/train.txt'.format(self.root, '%02d' % item))
+            else:
+                input_file = open('{0}/data/{1}/test.txt'.format(self.root, '%02d' % item))
+            while 1:
+                item_count += 1
+                input_line = input_file.readline()
+                if self.mode == 'test' and item_count % 10 != 0:
+                    continue
+                if not input_line:
+                    break
+                if input_line[-1:] == '\n':
+                    input_line = input_line[:-1]
+                self.list_rgb.append('{0}/data/{1}/rgb/{2}.png'.format(self.root, '%02d' % item, input_line))
+                self.list_depth.append('{0}/data/{1}/depth/{2}.png'.format(self.root, '%02d' % item, input_line))
+                if self.mode == 'eval':
+                    self.list_label.append('{0}/segnet_results/{1}_label/{2}_label.png'.format(self.root, '%02d' % item, input_line))
+                else:
+                    self.list_label.append('{0}/data/{1}/mask/{2}.png'.format(self.root, '%02d' % item, input_line))
+                
+                self.list_obj.append(item)
+                self.list_rank.append(int(input_line))
+
+            meta_file = open('{0}/data/{1}/gt.yml'.format(self.root, '%02d' % item), 'r')
+            self.meta[item] = yaml.load(meta_file)
+            self.pt[item] = ply_vtx('{0}/models/obj_{1}.ply'.format(self.root, '%02d' % item))
+            
+            print("Object {0} buffer loaded".format(item))
+
+        self.length = len(self.list_rgb)
+
+        self.cam_cx = 325.26110
+        self.cam_cy = 242.04899
+        self.cam_fx = 572.41140
+        self.cam_fy = 573.57043
+
+        self.xmap = np.array([[j for i in range(640)] for j in range(480)])
+        self.ymap = np.array([[i for i in range(640)] for j in range(480)])
+        
+        self.num = num
+        self.add_noise = add_noise
+        self.trancolor = transforms.ColorJitter(0.2, 0.2, 0.2, 0.05)
+        self.norm = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self.border_list = [-1, 40, 80, 120, 160, 200, 240, 280, 320, 360, 400, 440, 480, 520, 560, 600, 640, 680]
+        self.num_pt_mesh_large = 500
+        self.num_pt_mesh_small = 500
+        self.symmetry_obj_idx = [7, 8]
+
+    def __getitem__(self, index):
+        img = Image.open(self.list_rgb[index])
+        ori_img = np.array(img)
+        depth = np.array(Image.open(self.list_depth[index]))
+        label = np.array(Image.open(self.list_label[index]))
+        obj = self.list_obj[index]
+        rank = self.list_rank[index]        
+
+        if obj == 2:
+            for i in range(0, len(self.meta[obj][rank])):
+                if self.meta[obj][rank][i]['obj_id'] == 2:
+                    meta = self.meta[obj][rank][i]
+                    break
+        else:
+            meta = self.meta[obj][rank][0]
+
+        mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0))
+        if self.mode == 'eval':
+            mask_label = ma.getmaskarray(ma.masked_equal(label, np.array(255)))
+        else:
+            mask_label = ma.getmaskarray(ma.masked_equal(label, np.array([255, 255, 255])))[:, :, 0]
+        
+        mask = mask_label * mask_depth
+
+        if self.add_noise:
+            img = self.trancolor(img)
+
+        img = np.array(img)[:, :, :3]
+        img = np.transpose(img, (2, 0, 1))
+        img_masked = img
+
+        if self.mode == 'eval':
+            rmin, rmax, cmin, cmax = get_bbox(mask_to_bbox(mask_label))
+        else:
+            rmin, rmax, cmin, cmax = get_bbox(meta['obj_bb'])
+
+        img_masked = img_masked[:, rmin:rmax, cmin:cmax]
+        #p_img = np.transpose(img_masked, (1, 2, 0))
+        #scipy.misc.imsave('evaluation_result/{0}_input.png'.format(index), p_img)
+
+        target_r = np.resize(np.array(meta['cam_R_m2c']), (3, 3))
+        target_t = np.array(meta['cam_t_m2c'])
+        add_t = np.array([random.uniform(-self.noise_trans, self.noise_trans) for i in range(3)])
+
+        choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0]
+        if len(choose) == 0:
+            cc = torch.LongTensor([0])
+            return(cc, cc, cc, cc, cc, cc)
+
+        if len(choose) > self.num:
+            c_mask = np.zeros(len(choose), dtype=int)
+            c_mask[:self.num] = 1
+            np.random.shuffle(c_mask)
+            choose = choose[c_mask.nonzero()]
+        else:
+            choose = np.pad(choose, (0, self.num - len(choose)), 'wrap')
+        
+        depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        xmap_masked = self.xmap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        ymap_masked = self.ymap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        choose = np.array([choose])
+
+        cam_scale = 1.0
+        pt2 = depth_masked / cam_scale
+        pt0 = (ymap_masked - self.cam_cx) * pt2 / self.cam_fx
+        pt1 = (xmap_masked - self.cam_cy) * pt2 / self.cam_fy
+        cloud = np.concatenate((pt0, pt1, pt2), axis=1)
+        cloud = cloud / 1000.0
+
+        if self.add_noise:
+            cloud = np.add(cloud, add_t)
+
+        #fw = open('evaluation_result/{0}_cld.xyz'.format(index), 'w')
+        #for it in cloud:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        #fw.close()
+
+        model_points = self.pt[obj] / 1000.0
+        dellist = [j for j in range(0, len(model_points))]
+        dellist = random.sample(dellist, len(model_points) - self.num_pt_mesh_small)
+        model_points = np.delete(model_points, dellist, axis=0)
+
+        #fw = open('evaluation_result/{0}_model_points.xyz'.format(index), 'w')
+        #for it in model_points:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        #fw.close()
+
+        target = np.dot(model_points, target_r.T)
+        if self.add_noise:
+            target = np.add(target, target_t / 1000.0 + add_t)
+            out_t = target_t / 1000.0 + add_t
+        else:
+            target = np.add(target, target_t / 1000.0)
+            out_t = target_t / 1000.0
+
+        #fw = open('evaluation_result/{0}_tar.xyz'.format(index), 'w')
+        #for it in target:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        #fw.close()
+
+        return torch.from_numpy(cloud.astype(np.float32)), \
+               torch.LongTensor(choose.astype(np.int32)), \
+               self.norm(torch.from_numpy(img_masked.astype(np.float32))), \
+               torch.from_numpy(target.astype(np.float32)), \
+               torch.from_numpy(model_points.astype(np.float32)), \
+               torch.LongTensor([self.objlist.index(obj)])
+
+    def __len__(self):
+        return self.length
+
+    def get_sym_list(self):
+        return self.symmetry_obj_idx
+
+    def get_num_points_mesh(self):
+        if self.refine:
+            return self.num_pt_mesh_large
+        else:
+            return self.num_pt_mesh_small
+
+
+
+border_list = [-1, 40, 80, 120, 160, 200, 240, 280, 320, 360, 400, 440, 480, 520, 560, 600, 640, 680]
+img_width = 480
+img_length = 640
+
+
+def mask_to_bbox(mask):
+    mask = mask.astype(np.uint8)
+    contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+
+
+    x = 0
+    y = 0
+    w = 0
+    h = 0
+    for contour in contours:
+        tmp_x, tmp_y, tmp_w, tmp_h = cv2.boundingRect(contour)
+        if tmp_w * tmp_h > w * h:
+            x = tmp_x
+            y = tmp_y
+            w = tmp_w
+            h = tmp_h
+    return [x, y, w, h]
+
+
+def get_bbox(bbox):
+    bbx = [bbox[1], bbox[1] + bbox[3], bbox[0], bbox[0] + bbox[2]]
+    if bbx[0] < 0:
+        bbx[0] = 0
+    if bbx[1] >= 480:
+        bbx[1] = 479
+    if bbx[2] < 0:
+        bbx[2] = 0
+    if bbx[3] >= 640:
+        bbx[3] = 639                
+    rmin, rmax, cmin, cmax = bbx[0], bbx[1], bbx[2], bbx[3]
+    r_b = rmax - rmin
+    for tt in range(len(border_list)):
+        if r_b > border_list[tt] and r_b < border_list[tt + 1]:
+            r_b = border_list[tt + 1]
+            break
+    c_b = cmax - cmin
+    for tt in range(len(border_list)):
+        if c_b > border_list[tt] and c_b < border_list[tt + 1]:
+            c_b = border_list[tt + 1]
+            break
+    center = [int((rmin + rmax) / 2), int((cmin + cmax) / 2)]
+    rmin = center[0] - int(r_b / 2)
+    rmax = center[0] + int(r_b / 2)
+    cmin = center[1] - int(c_b / 2)
+    cmax = center[1] + int(c_b / 2)
+    if rmin < 0:
+        delt = -rmin
+        rmin = 0
+        rmax += delt
+    if cmin < 0:
+        delt = -cmin
+        cmin = 0
+        cmax += delt
+    if rmax > 480:
+        delt = rmax - 480
+        rmax = 480
+        rmin -= delt
+    if cmax > 640:
+        delt = cmax - 640
+        cmax = 640
+        cmin -= delt
+    return rmin, rmax, cmin, cmax
+
+
+def ply_vtx(path):
+    f = open(path)
+    assert f.readline().strip() == "ply"
+    f.readline()
+    f.readline()
+    N = int(f.readline().split()[-1])
+    while f.readline().strip() != "end_header":
+        continue
+    pts = []
+    for _ in range(N):
+        pts.append(np.float32(f.readline().split()[:3]))
+    return np.array(pts)

datasets/linemod/dataset_config/models_info.yml

@@ -0,0 +1,15 @@
+1: {diameter: 102.09865663, min_x: -37.93430000, min_y: -38.79960000, min_z: -45.88450000, size_x: 75.86860000, size_y: 77.59920000, size_z: 91.76900000}
+2: {diameter: 247.50624233, min_x: -107.83500000, min_y: -60.92790000, min_z: -109.70500000, size_x: 215.67000000, size_y: 121.85570000, size_z: 219.41000000}
+3: {diameter: 167.35486092, min_x: -83.21620000, min_y: -82.65910000, min_z: -37.23640000, size_x: 166.43240000, size_y: 165.31820000, size_z: 74.47280000}
+4: {diameter: 172.49224865, min_x: -68.32970000, min_y: -71.51510000, min_z: -50.24850000, size_x: 136.65940000, size_y: 143.03020000, size_z: 100.49700000}
+5: {diameter: 201.40358597, min_x: -50.39580000, min_y: -90.89790000, min_z: -96.86700000, size_x: 100.79160000, size_y: 181.79580000, size_z: 193.73400000}
+6: {diameter: 154.54551808, min_x: -33.50540000, min_y: -63.81650000, min_z: -58.72830000, size_x: 67.01070000, size_y: 127.63300000, size_z: 117.45660000}
+7: {diameter: 124.26430816, min_x: -58.78990000, min_y: -45.75560000, min_z: -47.31120000, size_x: 117.57980000, size_y: 91.51120000, size_z: 94.62240000}
+8: {diameter: 261.47178102, min_x: -114.73800000, min_y: -37.73570000, min_z: -104.00100000, size_x: 229.47600000, size_y: 75.47140000, size_z: 208.00200000}
+9: {diameter: 108.99920102, min_x: -52.21460000, min_y: -38.70380000, min_z: -42.84850000, size_x: 104.42920000, size_y: 77.40760000, size_z: 85.69700000}
+10: {diameter: 164.62758848, min_x: -75.09230000, min_y: -53.53750000, min_z: -34.62070000, size_x: 150.18460000, size_y: 107.07500000, size_z: 69.24140000}
+11: {diameter: 175.88933422, min_x: -18.36050000, min_y: -38.93300000, min_z: -86.40790000, size_x: 36.72110000, size_y: 77.86600000, size_z: 172.81580000}
+12: {diameter: 145.54287471, min_x: -50.44390000, min_y: -54.24850000, min_z: -45.40000000, size_x: 100.88780000, size_y: 108.49700000, size_z: 90.80000000}
+13: {diameter: 278.07811733, min_x: -129.11300000, min_y: -59.24100000, min_z: -70.56620000, size_x: 258.22600000, size_y: 118.48210000, size_z: 141.13240000}
+14: {diameter: 282.60129399, min_x: -101.57300000, min_y: -58.87630000, min_z: -106.55800000, size_x: 203.14600000, size_y: 117.75250000, size_z: 213.11600000}
+15: {diameter: 212.35825148, min_x: -46.95910000, min_y: -73.71670000, min_z: -92.37370000, size_x: 93.91810000, size_y: 147.43340000, size_z: 184.74740000}

datasets/ycb/dataset.py

@@ -0,0 +1,289 @@
+import torch.utils.data as data
+from PIL import Image
+import os
+import os.path
+import torch
+import numpy as np
+import torchvision.transforms as transforms
+import argparse
+import time
+import random
+from lib.transformations import quaternion_from_euler, euler_matrix, random_quaternion, quaternion_matrix
+import numpy.ma as ma
+import copy
+import scipy.misc
+import scipy.io as scio
+
+
+class PoseDataset(data.Dataset):
+    def __init__(self, mode, num_pt, add_noise, root, noise_trans, refine):
+        if mode == 'train':
+            self.path = 'datasets/ycb/dataset_config/train_data_list.txt'
+        elif mode == 'test':
+            self.path = 'datasets/ycb/dataset_config/test_data_list.txt'
+        self.num_pt = num_pt
+        self.root = root
+        self.add_noise = add_noise
+        self.noise_trans = noise_trans
+
+        self.list = []
+        self.real = []
+        self.syn = []
+        input_file = open(self.path)
+        while 1:
+            input_line = input_file.readline()
+            if not input_line:
+                break
+            if input_line[-1:] == '\n':
+                input_line = input_line[:-1]
+            if input_line[:5] == 'data/':
+                self.real.append(input_line)
+            else:
+                self.syn.append(input_line)
+            self.list.append(input_line)
+        input_file.close()
+
+        self.length = len(self.list)
+        self.len_real = len(self.real)
+        self.len_syn = len(self.syn)
+
+        class_file = open('datasets/ycb/dataset_config/classes.txt')
+        class_id = 1
+        self.cld = {}
+        while 1:
+            class_input = class_file.readline()
+            if not class_input:
+                break
+
+            input_file = open('{0}/models/{1}/points.xyz'.format(self.root, class_input[:-1]))
+            self.cld[class_id] = []
+            while 1:
+                input_line = input_file.readline()
+                if not input_line:
+                    break
+                input_line = input_line[:-1].split(' ')
+                self.cld[class_id].append([float(input_line[0]), float(input_line[1]), float(input_line[2])])
+            self.cld[class_id] = np.array(self.cld[class_id])
+            input_file.close()
+            
+            class_id += 1
+
+        self.cam_cx_1 = 312.9869
+        self.cam_cy_1 = 241.3109
+        self.cam_fx_1 = 1066.778
+        self.cam_fy_1 = 1067.487
+
+        self.cam_cx_2 = 323.7872
+        self.cam_cy_2 = 279.6921
+        self.cam_fx_2 = 1077.836
+        self.cam_fy_2 = 1078.189
+
+        self.xmap = np.array([[j for i in range(640)] for j in range(480)])
+        self.ymap = np.array([[i for i in range(640)] for j in range(480)])
+        
+        self.trancolor = transforms.ColorJitter(0.2, 0.2, 0.2, 0.05)
+        self.noise_img_loc = 0.0
+        self.noise_img_scale = 7.0
+        self.minimum_num_pt = 50
+        self.norm = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        self.symmetry_obj_idx = [12, 15, 18, 19, 20]
+        self.num_pt_mesh_small = 500
+        self.num_pt_mesh_large = 2600
+        self.refine = refine
+        self.front_num = 2
+
+        print(len(self.list))
+
+    def __getitem__(self, index):
+        img = Image.open('{0}/{1}-color.png'.format(self.root, self.list[index]))
+        depth = np.array(Image.open('{0}/{1}-depth.png'.format(self.root, self.list[index])))
+        label = np.array(Image.open('{0}/{1}-label.png'.format(self.root, self.list[index])))
+        meta = scio.loadmat('{0}/{1}-meta.mat'.format(self.root, self.list[index]))
+
+        if self.list[index][:8] != 'data_syn' and int(self.list[index][5:9]) >= 60:
+            cam_cx = self.cam_cx_2
+            cam_cy = self.cam_cy_2
+            cam_fx = self.cam_fx_2
+            cam_fy = self.cam_fy_2
+        else:
+            cam_cx = self.cam_cx_1
+            cam_cy = self.cam_cy_1
+            cam_fx = self.cam_fx_1
+            cam_fy = self.cam_fy_1
+
+        mask_back = ma.getmaskarray(ma.masked_equal(label, 0))
+
+        add_front = False
+        if self.add_noise:
+            for k in range(5):
+                seed = random.choice(self.syn)
+                front = np.array(self.trancolor(Image.open('{0}/{1}-color.png'.format(self.root, seed)).convert("RGB")))
+                front = np.transpose(front, (2, 0, 1))
+                f_label = np.array(Image.open('{0}/{1}-label.png'.format(self.root, seed)))
+                front_label = np.unique(f_label).tolist()[1:]
+                if len(front_label) < self.front_num:
+                   continue
+                front_label = random.sample(front_label, self.front_num)
+                for f_i in front_label:
+                    mk = ma.getmaskarray(ma.masked_not_equal(f_label, f_i))
+                    if f_i == front_label[0]:
+                        mask_front = mk
+                    else:
+                        mask_front = mask_front * mk
+                t_label = label * mask_front
+                if len(t_label.nonzero()[0]) > 1000:
+                    label = t_label
+                    add_front = True
+                    break
+
+        obj = meta['cls_indexes'].flatten().astype(np.int32)
+
+        while 1:
+            idx = np.random.randint(0, len(obj))
+            mask_depth = ma.getmaskarray(ma.masked_not_equal(depth, 0))
+            mask_label = ma.getmaskarray(ma.masked_equal(label, obj[idx]))
+            mask = mask_label * mask_depth
+            if len(mask.nonzero()[0]) > self.minimum_num_pt:
+                break
+
+        if self.add_noise:
+            img = self.trancolor(img)
+
+        rmin, rmax, cmin, cmax = get_bbox(mask_label)
+        img = np.transpose(np.array(img)[:, :, :3], (2, 0, 1))[:, rmin:rmax, cmin:cmax]
+
+        if self.list[index][:8] == 'data_syn':
+            seed = random.choice(self.real)
+            back = np.array(self.trancolor(Image.open('{0}/{1}-color.png'.format(self.root, seed)).convert("RGB")))
+            back = np.transpose(back, (2, 0, 1))[:, rmin:rmax, cmin:cmax]
+            img_masked = back * mask_back[rmin:rmax, cmin:cmax] + img
+        else:
+            img_masked = img
+
+        if self.add_noise and add_front:
+            img_masked = img_masked * mask_front[rmin:rmax, cmin:cmax] + front[:, rmin:rmax, cmin:cmax] * ~(mask_front[rmin:rmax, cmin:cmax])
+
+        if self.list[index][:8] == 'data_syn':
+            img_masked = img_masked + np.random.normal(loc=0.0, scale=7.0, size=img_masked.shape)
+
+        # p_img = np.transpose(img_masked, (1, 2, 0))
+        # scipy.misc.imsave('temp/{0}_input.png'.format(index), p_img)
+        # scipy.misc.imsave('temp/{0}_label.png'.format(index), mask[rmin:rmax, cmin:cmax].astype(np.int32))
+
+        target_r = meta['poses'][:, :, idx][:, 0:3]
+        target_t = np.array([meta['poses'][:, :, idx][:, 3:4].flatten()])
+        add_t = np.array([random.uniform(-self.noise_trans, self.noise_trans) for i in range(3)])
+
+        choose = mask[rmin:rmax, cmin:cmax].flatten().nonzero()[0]
+        if len(choose) > self.num_pt:
+            c_mask = np.zeros(len(choose), dtype=int)
+            c_mask[:self.num_pt] = 1
+            np.random.shuffle(c_mask)
+            choose = choose[c_mask.nonzero()]
+        else:
+            choose = np.pad(choose, (0, self.num_pt - len(choose)), 'wrap')
+        
+        depth_masked = depth[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        xmap_masked = self.xmap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        ymap_masked = self.ymap[rmin:rmax, cmin:cmax].flatten()[choose][:, np.newaxis].astype(np.float32)
+        choose = np.array([choose])
+
+        cam_scale = meta['factor_depth'][0][0]
+        pt2 = depth_masked / cam_scale
+        pt0 = (ymap_masked - cam_cx) * pt2 / cam_fx
+        pt1 = (xmap_masked - cam_cy) * pt2 / cam_fy
+        cloud = np.concatenate((pt0, pt1, pt2), axis=1)
+        if self.add_noise:
+            cloud = np.add(cloud, add_t)
+
+        # fw = open('temp/{0}_cld.xyz'.format(index), 'w')
+        # for it in cloud:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        # fw.close()
+
+        dellist = [j for j in range(0, len(self.cld[obj[idx]]))]
+        if self.refine:
+            dellist = random.sample(dellist, len(self.cld[obj[idx]]) - self.num_pt_mesh_large)
+        else:
+            dellist = random.sample(dellist, len(self.cld[obj[idx]]) - self.num_pt_mesh_small)
+        model_points = np.delete(self.cld[obj[idx]], dellist, axis=0)
+
+        # fw = open('temp/{0}_model_points.xyz'.format(index), 'w')
+        # for it in model_points:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        # fw.close()
+
+        target = np.dot(model_points, target_r.T)
+        if self.add_noise:
+            target = np.add(target, target_t + add_t)
+        else:
+            target = np.add(target, target_t)
+        
+        # fw = open('temp/{0}_tar.xyz'.format(index), 'w')
+        # for it in target:
+        #    fw.write('{0} {1} {2}\n'.format(it[0], it[1], it[2]))
+        # fw.close()
+        
+        return torch.from_numpy(cloud.astype(np.float32)), \
+               torch.LongTensor(choose.astype(np.int32)), \
+               self.norm(torch.from_numpy(img_masked.astype(np.float32))), \
+               torch.from_numpy(target.astype(np.float32)), \
+               torch.from_numpy(model_points.astype(np.float32)), \
+               torch.LongTensor([int(obj[idx]) - 1])
+
+    def __len__(self):
+        return self.length
+
+    def get_sym_list(self):
+        return self.symmetry_obj_idx
+
+    def get_num_points_mesh(self):
+        if self.refine:
+            return self.num_pt_mesh_large
+        else:
+            return self.num_pt_mesh_small
+
+
+border_list = [-1, 40, 80, 120, 160, 200, 240, 280, 320, 360, 400, 440, 480, 520, 560, 600, 640, 680]
+img_width = 480
+img_length = 640
+
+def get_bbox(label):
+    rows = np.any(label, axis=1)
+    cols = np.any(label, axis=0)
+    rmin, rmax = np.where(rows)[0][[0, -1]]
+    cmin, cmax = np.where(cols)[0][[0, -1]]
+    rmax += 1
+    cmax += 1
+    r_b = rmax - rmin
+    for tt in range(len(border_list)):
+        if r_b > border_list[tt] and r_b < border_list[tt + 1]:
+            r_b = border_list[tt + 1]
+            break
+    c_b = cmax - cmin
+    for tt in range(len(border_list)):
+        if c_b > border_list[tt] and c_b < border_list[tt + 1]:
+            c_b = border_list[tt + 1]
+            break
+    center = [int((rmin + rmax) / 2), int((cmin + cmax) / 2)]
+    rmin = center[0] - int(r_b / 2)
+    rmax = center[0] + int(r_b / 2)
+    cmin = center[1] - int(c_b / 2)
+    cmax = center[1] + int(c_b / 2)
+    if rmin < 0:
+        delt = -rmin
+        rmin = 0
+        rmax += delt
+    if cmin < 0:
+        delt = -cmin
+        cmin = 0
+        cmax += delt
+    if rmax > img_width:
+        delt = rmax - img_width
+        rmax = img_width
+        rmin -= delt
+    if cmax > img_length:
+        delt = cmax - img_length
+        cmax = img_length
+        cmin -= delt
+    return rmin, rmax, cmin, cmax

datasets/ycb/dataset_config/classes.txt

@@ -0,0 +1,21 @@
+002_master_chef_can
+003_cracker_box
+004_sugar_box
+005_tomato_soup_can
+006_mustard_bottle
+007_tuna_fish_can
+008_pudding_box
+009_gelatin_box
+010_potted_meat_can
+011_banana
+019_pitcher_base
+021_bleach_cleanser
+024_bowl
+025_mug
+035_power_drill
+036_wood_block
+037_scissors
+040_large_marker
+051_large_clamp
+052_extra_large_clamp
+061_foam_brick

datasets/ycb/dataset_config/test_data_list.txt

@@ -0,0 +1,2949 @@
+data/0048/000001
+data/0048/000036
+data/0048/000047
+data/0048/000083
+data/0048/000112
+data/0048/000135
+data/0048/000155
+data/0048/000168
+data/0048/000181
+data/0048/000204
+data/0048/000220
+data/0048/000235
+data/0048/000252
+data/0048/000257
+data/0048/000261
+data/0048/000265
+data/0048/000277
+data/0048/000292
+data/0048/000294
+data/0048/000310
+data/0048/000311
+data/0048/000322
+data/0048/000326
+data/0048/000335
+data/0048/000337
+data/0048/000353
+data/0048/000356
+data/0048/000364
+data/0048/000373
+data/0048/000380
+data/0048/000388
+data/0048/000398
+data/0048/000401
+data/0048/000404
+data/0048/000415
+data/0048/000422
+data/0048/000435
+data/0048/000448
+data/0048/000464
+data/0048/000476
+data/0048/000485
+data/0048/000494
+data/0048/000510
+data/0048/000516
+data/0048/000529
+data/0048/000541
+data/0048/000549
+data/0048/000556
+data/0048/000567
+data/0048/000573
+data/0048/000581
+data/0048/000592
+data/0048/000605
+data/0048/000614
+data/0048/000626
+data/0048/000636
+data/0048/000648
+data/0048/000653
+data/0048/000656
+data/0048/000664
+data/0048/000672
+data/0048/000685
+data/0048/000694
+data/0048/000733
+data/0048/000734
+data/0048/000756
+data/0048/000779
+data/0048/000786
+data/0048/000803
+data/0048/000806
+data/0048/000818
+data/0048/000820
+data/0048/000821
+data/0048/000834
+data/0048/000836
+data/0048/000854
+data/0048/000855
+data/0048/000858
+data/0048/000862
+data/0048/000871
+data/0048/000874
+data/0048/000884
+data/0048/000892
+data/0048/000899
+data/0048/000902
+data/0048/000905
+data/0048/000907
+data/0048/000913
+data/0048/000919
+data/0048/000927
+data/0048/000937
+data/0048/000942
+data/0048/000943
+data/0048/000950
+data/0048/000958
+data/0048/000959
+data/0048/000971
+data/0048/000991
+data/0048/000996
+data/0048/001002
+data/0048/001012
+data/0048/001024
+data/0048/001027
+data/0048/001059
+data/0048/001065
+data/0048/001074
+data/0048/001075
+data/0048/001083
+data/0048/001087
+data/0048/001090
+data/0048/001094
+data/0048/001097
+data/0048/001103
+data/0048/001104
+data/0048/001107
+data/0048/001113
+data/0048/001119
+data/0048/001120
+data/0048/001122
+data/0048/001124
+data/0048/001126
+data/0048/001128
+data/0048/001132
+data/0048/001133
+data/0048/001135
+data/0048/001137
+data/0048/001146
+data/0048/001147
+data/0048/001149
+data/0048/001151
+data/0048/001154
+data/0048/001155
+data/0048/001156
+data/0048/001157
+data/0048/001158
+data/0048/001160
+data/0048/001165
+data/0048/001168
+data/0048/001169
+data/0048/001170
+data/0048/001171
+data/0048/001172
+data/0048/001173
+data/0048/001175
+data/0048/001177
+data/0048/001195
+data/0048/001199
+data/0048/001202
+data/0048/001205
+data/0048/001207
+data/0048/001211
+data/0048/001212
+data/0048/001219
+data/0048/001226
+data/0048/001231
+data/0048/001233
+data/0048/001235
+data/0048/001251
+data/0048/001261
+data/0048/001267
+data/0048/001275
+data/0048/001289
+data/0048/001296
+data/0048/001299
+data/0048/001300
+data/0048/001301
+data/0048/001302
+data/0048/001303
+data/0048/001304
+data/0048/001305
+data/0048/001307
+data/0048/001308
+data/0048/001309
+data/0048/001310
+data/0048/001313
+data/0048/001319
+data/0048/001328
+data/0048/001330
+data/0048/001333
+data/0048/001334
+data/0048/001337
+data/0048/001338
+data/0048/001343
+data/0048/001367
+data/0048/001397
+data/0048/001405
+data/0048/001412
+data/0048/001413
+data/0048/001426
+data/0048/001442
+data/0048/001457
+data/0048/001478
+data/0048/001493
+data/0048/001494
+data/0048/001513
+data/0048/001533
+data/0048/001534
+data/0048/001539
+data/0048/001540
+data/0048/001542
+data/0048/001543
+data/0048/001568
+data/0048/001569
+data/0048/001571
+data/0048/001572
+data/0048/001576
+data/0048/001577
+data/0048/001579
+data/0048/001580
+data/0048/001583
+data/0048/001586
+data/0048/001587
+data/0048/001588
+data/0048/001589
+data/0048/001595
+data/0048/001597
+data/0048/001602
+data/0048/001603
+data/0048/001604
+data/0048/001605
+data/0048/001608
+data/0048/001609
+data/0048/001611
+data/0048/001617
+data/0048/001619
+data/0048/001621
+data/0048/001622
+data/0048/001623
+data/0048/001624
+data/0048/001626
+data/0048/001627
+data/0048/001629
+data/0048/001631
+data/0048/001639
+data/0048/001641
+data/0048/001643
+data/0048/001644
+data/0048/001645
+data/0048/001647
+data/0048/001648
+data/0048/001649
+data/0048/001654
+data/0048/001656
+data/0048/001658
+data/0048/001666
+data/0048/001667
+data/0048/001669
+data/0048/001671
+data/0048/001672
+data/0048/001674
+data/0048/001675
+data/0048/001676
+data/0048/001678
+data/0048/001679
+data/0048/001682
+data/0048/001684
+data/0048/001685
+data/0048/001690
+data/0048/001691
+data/0048/001693
+data/0048/001696
+data/0048/001699
+data/0048/001701
+data/0048/001705
+data/0048/001707
+data/0048/001708
+data/0048/001709
+data/0048/001714
+data/0048/001715
+data/0048/001717
+data/0048/001719
+data/0048/001722
+data/0048/001723
+data/0048/001724
+data/0048/001725
+data/0048/001730
+data/0048/001731
+data/0048/001733
+data/0048/001735
+data/0048/001742
+data/0048/001744
+data/0048/001745
+data/0048/001749
+data/0048/001750
+data/0048/001753
+data/0048/001754
+data/0048/001759
+data/0048/001760
+data/0048/001763
+data/0048/001765
+data/0048/001766
+data/0048/001768
+data/0048/001769
+data/0048/001771
+data/0048/001772
+data/0048/001773
+data/0048/001776
+data/0048/001777
+data/0048/001779
+data/0048/001780
+data/0048/001783
+data/0048/001784
+data/0048/001785
+data/0048/001786
+data/0048/001787
+data/0048/001789
+data/0048/001794
+data/0048/001795
+data/0048/001796
+data/0048/001805
+data/0048/001806
+data/0048/001808
+data/0048/001810
+data/0048/001814
+data/0048/001819
+data/0048/001822
+data/0048/001823
+data/0048/001825
+data/0048/001826
+data/0048/001831
+data/0048/001834
+data/0048/001838
+data/0048/001840
+data/0048/001841
+data/0048/001842
+data/0048/001849
+data/0048/001854
+data/0048/001859
+data/0048/001862
+data/0048/001866
+data/0048/001870
+data/0048/001871
+data/0048/001872
+data/0048/001874
+data/0048/001879
+data/0048/001881
+data/0048/001884
+data/0048/001886
+data/0048/001888
+data/0048/001890
+data/0048/001892
+data/0048/001893
+data/0048/001894
+data/0048/001897
+data/0048/001898
+data/0048/001901
+data/0048/001902
+data/0048/001907
+data/0048/001913
+data/0048/001917
+data/0048/001921
+data/0048/001931
+data/0048/001932
+data/0048/001934
+data/0048/001939
+data/0048/001942
+data/0048/001945
+data/0048/001947
+data/0048/001949
+data/0048/001954
+data/0048/001957
+data/0048/001964
+data/0048/001965
+data/0048/001983
+data/0048/001985
+data/0048/001988
+data/0048/001991
+data/0048/001994
+data/0048/002004
+data/0048/002007
+data/0048/002015
+data/0048/002016
+data/0048/002021
+data/0048/002029
+data/0048/002037
+data/0048/002039
+data/0048/002040
+data/0048/002050
+data/0048/002051
+data/0048/002066
+data/0048/002069
+data/0048/002070
+data/0048/002083
+data/0048/002090
+data/0048/002104
+data/0048/002118
+data/0048/002133
+data/0048/002144
+data/0048/002160
+data/0048/002173
+data/0048/002175
+data/0048/002192
+data/0048/002198
+data/0048/002217
+data/0049/000001
+data/0049/000036
+data/0049/000047
+data/0049/000058
+data/0049/000065
+data/0049/000073
+data/0049/000091
+data/0049/000109
+data/0049/000125
+data/0049/000148
+data/0049/000170
+data/0049/000187
+data/0049/000206
+data/0049/000222
+data/0049/000230
+data/0049/000231
+data/0049/000235
+data/0049/000239
+data/0049/000242
+data/0049/000246
+data/0049/000247
+data/0049/000251
+data/0049/000252
+data/0049/000261
+data/0049/000262
+data/0049/000270
+data/0049/000273
+data/0049/000282
+data/0049/000289
+data/0049/000295
+data/0049/000304
+data/0049/000310
+data/0049/000315
+data/0049/000316
+data/0049/000324
+data/0049/000326
+data/0049/000333
+data/0049/000335
+data/0049/000348
+data/0049/000352
+data/0049/000357
+data/0049/000370
+data/0049/000376
+data/0049/000394
+data/0049/000405
+data/0049/000422
+data/0049/000427
+data/0049/000457
+data/0049/000461
+data/0049/000470
+data/0049/000474
+data/0049/000485
+data/0049/000489
+data/0049/000509
+data/0049/000511
+data/0049/000521
+data/0049/000526
+data/0049/000537
+data/0049/000542
+data/0049/000552
+data/0049/000558
+data/0049/000564
+data/0049/000570
+data/0049/000576
+data/0049/000591
+data/0049/000594
+data/0049/000617
+data/0049/000629
+data/0049/000631
+data/0049/000651
+data/0049/000669
+data/0049/000671
+data/0049/000693
+data/0049/000695
+data/0049/000711
+data/0049/000714
+data/0049/000735
+data/0049/000751
+data/0049/000762
+data/0049/000769
+data/0049/000783
+data/0049/000785
+data/0049/000798
+data/0049/000802
+data/0049/000811
+data/0049/000817
+data/0049/000825
+data/0049/000833
+data/0049/000840
+data/0049/000849
+data/0049/000858
+data/0049/000884
+data/0049/000900
+data/0049/000914
+data/0049/000949
+data/0049/000951
+data/0049/000981
+data/0049/000983
+data/0049/001009
+data/0049/001024
+data/0049/001036
+data/0049/001052
+data/0049/001067
+data/0049/001095
+data/0049/001102
+data/0049/001130
+data/0049/001144
+data/0049/001150
+data/0049/001157
+data/0049/001168
+data/0049/001172
+data/0049/001179
+data/0049/001187
+data/0049/001190
+data/0049/001205
+data/0049/001222
+data/0049/001229
+data/0049/001234
+data/0049/001247
+data/0049/001250
+data/0049/001262
+data/0049/001266
+data/0049/001269
+data/0049/001280
+data/0049/001283
+data/0049/001304
+data/0049/001305
+data/0049/001319
+data/0049/001321
+data/0049/001340
+data/0049/001344
+data/0049/001353
+data/0049/001356
+data/0049/001391
+data/0049/001408
+data/0049/001413
+data/0049/001429
+data/0049/001431
+data/0049/001441
+data/0049/001446
+data/0049/001461
+data/0049/001466
+data/0049/001474
+data/0049/001477
+data/0049/001488
+data/0049/001491
+data/0049/001499
+data/0049/001515
+data/0049/001518
+data/0049/001554
+data/0049/001557
+data/0049/001565
+data/0049/001568
+data/0049/001575
+data/0049/001582
+data/0049/001587
+data/0049/001592
+data/0049/001595
+data/0049/001614
+data/0049/001615
+data/0049/001618
+data/0049/001631
+data/0049/001641
+data/0049/001644
+data/0049/001655
+data/0049/001671
+data/0049/001677
+data/0049/001682
+data/0049/001688
+data/0049/001699
+data/0049/001704
+data/0049/001707
+data/0049/001719
+data/0049/001732
+data/0049/001743
+data/0049/001759
+data/0049/001760
+data/0049/001773
+data/0049/001776
+data/0049/001784
+data/0049/001789
+data/0049/001796
+data/0049/001804
+data/0049/001816
+data/0049/001828
+data/0049/001842
+data/0049/001848
+data/0049/001854
+data/0049/001857
+data/0049/001869
+data/0049/001875
+data/0049/001881
+data/0049/001886
+data/0049/001889
+data/0049/001902
+data/0049/001909
+data/0049/001926
+data/0049/001934
+data/0049/001936
+data/0049/001937
+data/0049/001968
+data/0049/001969
+data/0049/001988
+data/0049/001994
+data/0049/002012
+data/0049/002014
+data/0049/002035
+data/0049/002037
+data/0049/002043
+data/0049/002061
+data/0049/002064
+data/0049/002089
+data/0049/002097
+data/0049/002119
+data/0049/002123
+data/0049/002146
+data/0049/002151
+data/0049/002173
+data/0049/002196
+data/0049/002207
+data/0049/002219
+data/0049/002235
+data/0049/002275
+data/0049/002287
+data/0049/002315
+data/0049/002337
+data/0049/002365
+data/0050/000001
+data/0050/000041
+data/0050/000055
+data/0050/000076
+data/0050/000099
+data/0050/000111
+data/0050/000122
+data/0050/000142
+data/0050/000181
+data/0050/000204
+data/0050/000222
+data/0050/000231
+data/0050/000237
+data/0050/000241
+data/0050/000249
+data/0050/000252
+data/0050/000263
+data/0050/000265
+data/0050/000273
+data/0050/000275
+data/0050/000290
+data/0050/000293
+data/0050/000303
+data/0050/000315
+data/0050/000327
+data/0050/000337
+data/0050/000345
+data/0050/000347
+data/0050/000363
+data/0050/000366
+data/0050/000381
+data/0050/000386
+data/0050/000405
+data/0050/000413
+data/0050/000420
+data/0050/000437
+data/0050/000438
+data/0050/000464
+data/0050/000466
+data/0050/000483
+data/0050/000505
+data/0050/000509
+data/0050/000558
+data/0050/000588
+data/0050/000605
+data/0050/000610
+data/0050/000620
+data/0050/000623
+data/0050/000629
+data/0050/000633
+data/0050/000640
+data/0050/000642
+data/0050/000644
+data/0050/000651
+data/0050/000653
+data/0050/000660
+data/0050/000662
+data/0050/000671
+data/0050/000681
+data/0050/000682
+data/0050/000701
+data/0050/000712
+data/0050/000721
+data/0050/000722
+data/0050/000735
+data/0050/000737
+data/0050/000751
+data/0050/000757
+data/0050/000769
+data/0050/000775
+data/0050/000786
+data/0050/000790
+data/0050/000798
+data/0050/000802
+data/0050/000811
+data/0050/000822
+data/0050/000830
+data/0050/000831
+data/0050/000846
+data/0050/000850
+data/0050/000876
+data/0050/000887
+data/0050/000891
+data/0050/000902
+data/0050/000905
+data/0050/000916
+data/0050/000918
+data/0050/000923
+data/0050/000926
+data/0050/000928
+data/0050/000943
+data/0050/000961
+data/0050/000963
+data/0050/000978
+data/0050/000979
+data/0050/000988
+data/0050/000994
+data/0050/001000
+data/0050/001008
+data/0050/001014
+data/0050/001023
+data/0050/001026
+data/0050/001044
+data/0050/001052
+data/0050/001058
+data/0050/001066
+data/0050/001077
+data/0050/001094
+data/0050/001098
+data/0050/001105
+data/0050/001113
+data/0050/001125
+data/0050/001130
+data/0050/001145
+data/0050/001150
+data/0050/001169
+data/0050/001189
+data/0050/001192
+data/0050/001209
+data/0050/001216
+data/0050/001242
+data/0050/001246
+data/0050/001263
+data/0050/001266
+data/0050/001280
+data/0050/001284
+data/0050/001297
+data/0050/001305
+data/0050/001324
+data/0050/001335
+data/0050/001346
+data/0050/001350
+data/0050/001364
+data/0050/001371
+data/0050/001389
+data/0050/001391
+data/0050/001402
+data/0050/001412
+data/0050/001414
+data/0050/001421
+data/0050/001433
+data/0050/001446
+data/0050/001448
+data/0050/001455
+data/0050/001457
+data/0050/001461
+data/0050/001462
+data/0050/001466
+data/0050/001470
+data/0050/001475
+data/0050/001480
+data/0050/001485
+data/0050/001492
+data/0050/001499
+data/0050/001509
+data/0050/001514
+data/0050/001526
+data/0050/001542
+data/0050/001564
+data/0050/001592
+data/0050/001593
+data/0050/001613
+data/0050/001629
+data/0050/001656
+data/0050/001658
+data/0050/001669
+data/0050/001678
+data/0050/001695
+data/0050/001708
+data/0050/001711
+data/0050/001713
+data/0050/001714
+data/0050/001718
+data/0050/001719
+data/0050/001733
+data/0050/001743
+data/0050/001745
+data/0050/001756
+data/0050/001778
+data/0050/001782
+data/0050/001800
+data/0050/001828
+data/0050/001844
+data/0050/001849
+data/0050/001850
+data/0050/001866
+data/0050/001868
+data/0050/001874
+data/0050/001893
+data/0050/001897
+data/0051/000001
+data/0051/000035
+data/0051/000056
+data/0051/000083
+data/0051/000100
+data/0051/000116
+data/0051/000138
+data/0051/000169
+data/0051/000197
+data/0051/000208
+data/0051/000219
+data/0051/000237
+data/0051/000240
+data/0051/000249
+data/0051/000263
+data/0051/000275
+data/0051/000284
+data/0051/000295
+data/0051/000304
+data/0051/000313
+data/0051/000318
+data/0051/000335
+data/0051/000339
+data/0051/000347
+data/0051/000353
+data/0051/000366
+data/0051/000368
+data/0051/000371
+data/0051/000387
+data/0051/000389
+data/0051/000402
+data/0051/000407
+data/0051/000417
+data/0051/000421
+data/0051/000431
+data/0051/000439
+data/0051/000444
+data/0051/000454
+data/0051/000464
+data/0051/000475
+data/0051/000482
+data/0051/000497
+data/0051/000501
+data/0051/000515
+data/0051/000520
+data/0051/000532
+data/0051/000546
+data/0051/000553
+data/0051/000571
+data/0051/000582
+data/0051/000601
+data/0051/000611
+data/0051/000618
+data/0051/000636
+data/0051/000637
+data/0051/000649
+data/0051/000654
+data/0051/000669
+data/0051/000672
+data/0051/000675
+data/0051/000681
+data/0051/000685
+data/0051/000694
+data/0051/000698
+data/0051/000713
+data/0051/000721
+data/0051/000736
+data/0051/000740
+data/0051/000756
+data/0051/000762
+data/0051/000773
+data/0051/000777
+data/0051/000780
+data/0051/000789
+data/0051/000793
+data/0051/000798
+data/0051/000803
+data/0051/000814
+data/0051/000819
+data/0051/000834
+data/0051/000840
+data/0051/000848
+data/0051/000852
+data/0051/000864
+data/0051/000868
+data/0051/000893
+data/0051/000897
+data/0051/000912
+data/0051/000916
+data/0051/000929
+data/0051/000930
+data/0051/000939
+data/0051/000943
+data/0051/000946
+data/0051/000961
+data/0051/000964
+data/0051/000982
+data/0051/000986
+data/0051/000997
+data/0051/001005
+data/0051/001014
+data/0051/001021
+data/0051/001038
+data/0051/001045
+data/0051/001057
+data/0051/001063
+data/0051/001076
+data/0051/001080
+data/0051/001091
+data/0051/001092
+data/0051/001110
+data/0051/001111
+data/0051/001149
+data/0051/001150
+data/0051/001160
+data/0051/001182
+data/0051/001220
+data/0051/001251
+data/0051/001275
+data/0051/001316
+data/0051/001330
+data/0051/001339
+data/0051/001366
+data/0051/001368
+data/0051/001393
+data/0051/001399
+data/0051/001424
+data/0051/001431
+data/0051/001445
+data/0051/001452
+data/0051/001471
+data/0051/001474
+data/0051/001497
+data/0051/001499
+data/0051/001518
+data/0051/001521
+data/0051/001528
+data/0051/001531
+data/0051/001536
+data/0051/001545
+data/0051/001566
+data/0051/001571
+data/0051/001584
+data/0051/001588
+data/0051/001603
+data/0051/001611
+data/0051/001617
+data/0051/001628
+data/0051/001629
+data/0051/001645
+data/0051/001650
+data/0051/001673
+data/0051/001674
+data/0051/001687
+data/0051/001693
+data/0051/001698
+data/0051/001699
+data/0051/001700
+data/0051/001708
+data/0051/001709
+data/0051/001715
+data/0051/001717
+data/0051/001729
+data/0051/001734
+data/0051/001749
+data/0051/001753
+data/0051/001767
+data/0051/001780
+data/0051/001788
+data/0051/001803
+data/0051/001819
+data/0051/001833
+data/0051/001867
+data/0051/001883
+data/0051/001914
+data/0051/001924
+data/0051/001927
+data/0051/001932
+data/0051/001968
+data/0051/001990
+data/0051/001996
+data/0052/000001
+data/0052/000021
+data/0052/000034
+data/0052/000039
+data/0052/000048
+data/0052/000052
+data/0052/000057
+data/0052/000061
+data/0052/000065
+data/0052/000071
+data/0052/000080
+data/0052/000081
+data/0052/000084
+data/0052/000088
+data/0052/000092
+data/0052/000097
+data/0052/000098
+data/0052/000114
+data/0052/000116
+data/0052/000121
+data/0052/000127
+data/0052/000132
+data/0052/000136
+data/0052/000143
+data/0052/000150
+data/0052/000156
+data/0052/000164
+data/0052/000165
+data/0052/000167
+data/0052/000169
+data/0052/000170
+data/0052/000171
+data/0052/000173
+data/0052/000175
+data/0052/000178
+data/0052/000179
+data/0052/000190
+data/0052/000195
+data/0052/000202
+data/0052/000213
+data/0052/000214
+data/0052/000227
+data/0052/000236
+data/0052/000245
+data/0052/000256
+data/0052/000257
+data/0052/000259
+data/0052/000265
+data/0052/000266
+data/0052/000272
+data/0052/000275
+data/0052/000282
+data/0052/000292
+data/0052/000293
+data/0052/000304
+data/0052/000313
+data/0052/000325
+data/0052/000341
+data/0052/000343
+data/0052/000357
+data/0052/000361
+data/0052/000365
+data/0052/000385
+data/0052/000388
+data/0052/000389
+data/0052/000396
+data/0052/000403
+data/0052/000407
+data/0052/000413
+data/0052/000414
+data/0052/000418
+data/0052/000426
+data/0052/000432
+data/0052/000434
+data/0052/000442
+data/0052/000448
+data/0052/000451
+data/0052/000483
+data/0052/000484
+data/0052/000493
+data/0052/000494
+data/0052/000502
+data/0052/000511
+data/0052/000516
+data/0052/000520
+data/0052/000524
+data/0052/000526
+data/0052/000527
+data/0052/000532
+data/0052/000537
+data/0052/000539
+data/0052/000543
+data/0052/000544
+data/0052/000550
+data/0052/000556
+data/0052/000561
+data/0052/000567
+data/0052/000574
+data/0052/000575
+data/0052/000582
+data/0052/000587
+data/0052/000589
+data/0052/000593
+data/0052/000594
+data/0052/000604
+data/0052/000608
+data/0052/000622
+data/0052/000625
+data/0052/000632
+data/0052/000638
+data/0052/000643
+data/0052/000650
+data/0052/000653
+data/0052/000656
+data/0052/000662
+data/0052/000666
+data/0052/000669
+data/0052/000678
+data/0052/000688
+data/0052/000694
+data/0052/000699
+data/0052/000707
+data/0052/000714
+data/0052/000720
+data/0052/000722
+data/0052/000725
+data/0052/000732
+data/0052/000733
+data/0052/000741
+data/0052/000742
+data/0052/000745
+data/0052/000747
+data/0052/000750
+data/0052/000751
+data/0052/000752
+data/0052/000756
+data/0052/000758
+data/0052/000759
+data/0052/000760
+data/0052/000763
+data/0052/000765
+data/0052/000770
+data/0052/000771
+data/0052/000774
+data/0052/000777
+data/0052/000790
+data/0052/000799
+data/0052/000806
+data/0052/000810
+data/0052/000813
+data/0052/000815
+data/0052/000817
+data/0052/000820
+data/0052/000823
+data/0052/000825
+data/0052/000826
+data/0052/000833
+data/0052/000844
+data/0052/000853
+data/0052/000855
+data/0052/000860
+data/0052/000875
+data/0052/000880
+data/0052/000885
+data/0052/000886
+data/0052/000892
+data/0052/000897
+data/0053/000001
+data/0053/000014
+data/0053/000033
+data/0053/000043
+data/0053/000052
+data/0053/000061
+data/0053/000075
+data/0053/000084
+data/0053/000093
+data/0053/000103
+data/0053/000111
+data/0053/000118
+data/0053/000123
+data/0053/000126
+data/0053/000131
+data/0053/000135
+data/0053/000138
+data/0053/000139
+data/0053/000142
+data/0053/000145
+data/0053/000147
+data/0053/000152
+data/0053/000153
+data/0053/000155
+data/0053/000158
+data/0053/000162
+data/0053/000164
+data/0053/000165
+data/0053/000167
+data/0053/000168
+data/0053/000171
+data/0053/000176
+data/0053/000179
+data/0053/000183
+data/0053/000187
+data/0053/000190
+data/0053/000193
+data/0053/000196
+data/0053/000199
+data/0053/000204
+data/0053/000207
+data/0053/000210
+data/0053/000213
+data/0053/000216
+data/0053/000219
+data/0053/000221
+data/0053/000225
+data/0053/000227
+data/0053/000230
+data/0053/000243
+data/0053/000247
+data/0053/000250
+data/0053/000254
+data/0053/000256
+data/0053/000260
+data/0053/000263
+data/0053/000268
+data/0053/000272
+data/0053/000274
+data/0053/000281
+data/0053/000285
+data/0053/000289
+data/0053/000293
+data/0053/000295
+data/0053/000299
+data/0053/000301
+data/0053/000303
+data/0053/000308
+data/0053/000309
+data/0053/000314
+data/0053/000315
+data/0053/000316
+data/0053/000318
+data/0053/000319
+data/0053/000324
+data/0053/000328
+data/0053/000330
+data/0053/000340
+data/0053/000341
+data/0053/000345
+data/0053/000348
+data/0053/000356
+data/0053/000357
+data/0053/000364
+data/0053/000366
+data/0053/000367
+data/0053/000373
+data/0053/000374
+data/0053/000407
+data/0053/000414
+data/0053/000421
+data/0053/000425
+data/0053/000430
+data/0053/000434
+data/0053/000435
+data/0053/000439
+data/0053/000441
+data/0053/000443
+data/0053/000449
+data/0053/000452
+data/0053/000454
+data/0053/000455
+data/0053/000457
+data/0053/000458
+data/0053/000459
+data/0053/000460
+data/0053/000463
+data/0053/000467
+data/0053/000468
+data/0053/000469
+data/0053/000471
+data/0053/000472
+data/0053/000474
+data/0053/000476
+data/0053/000477
+data/0053/000479
+data/0053/000483
+data/0053/000484
+data/0053/000486
+data/0053/000490
+data/0053/000501
+data/0053/000505
+data/0053/000508
+data/0053/000509
+data/0053/000513
+data/0053/000519
+data/0053/000523
+data/0053/000526
+data/0053/000533
+data/0053/000534
+data/0053/000538
+data/0053/000539
+data/0053/000542
+data/0053/000545
+data/0053/000547
+data/0053/000550
+data/0053/000551
+data/0053/000552
+data/0053/000555
+data/0053/000556
+data/0053/000567
+data/0053/000569
+data/0053/000576
+data/0053/000579
+data/0053/000583
+data/0053/000587
+data/0053/000591
+data/0053/000592
+data/0053/000602
+data/0053/000604
+data/0053/000610
+data/0053/000616
+data/0053/000628
+data/0053/000638
+data/0053/000647
+data/0053/000655
+data/0053/000665
+data/0053/000677
+data/0053/000686
+data/0053/000687
+data/0053/000692
+data/0053/000700
+data/0053/000708
+data/0053/000716
+data/0053/000722
+data/0053/000730
+data/0053/000732
+data/0053/000735
+data/0053/000738
+data/0053/000740
+data/0053/000742
+data/0053/000752
+data/0053/000768
+data/0053/000779
+data/0053/000789
+data/0053/000797
+data/0053/000802
+data/0053/000817
+data/0053/000834
+data/0054/000001
+data/0054/000022
+data/0054/000032
+data/0054/000038
+data/0054/000043
+data/0054/000050
+data/0054/000056
+data/0054/000063
+data/0054/000069
+data/0054/000081
+data/0054/000086
+data/0054/000090
+data/0054/000092
+data/0054/000098
+data/0054/000099
+data/0054/000101
+data/0054/000105
+data/0054/000110
+data/0054/000114
+data/0054/000118
+data/0054/000121
+data/0054/000124
+data/0054/000126
+data/0054/000127
+data/0054/000130
+data/0054/000132
+data/0054/000133
+data/0054/000134
+data/0054/000135
+data/0054/000136
+data/0054/000137
+data/0054/000139
+data/0054/000140
+data/0054/000142
+data/0054/000143
+data/0054/000146
+data/0054/000147
+data/0054/000152
+data/0054/000153
+data/0054/000159
+data/0054/000161
+data/0054/000173
+data/0054/000175
+data/0054/000184
+data/0054/000186
+data/0054/000191
+data/0054/000195
+data/0054/000196
+data/0054/000202
+data/0054/000204
+data/0054/000209
+data/0054/000214
+data/0054/000223
+data/0054/000232
+data/0054/000236
+data/0054/000244
+data/0054/000249
+data/0054/000255
+data/0054/000259
+data/0054/000266
+data/0054/000269
+data/0054/000313
+data/0054/000334
+data/0054/000345
+data/0054/000350
+data/0054/000359
+data/0054/000365
+data/0054/000366
+data/0054/000376
+data/0054/000378
+data/0054/000385
+data/0054/000387
+data/0054/000390
+data/0054/000393
+data/0054/000398
+data/0054/000405
+data/0054/000411
+data/0054/000413
+data/0054/000414
+data/0054/000420
+data/0054/000423
+data/0054/000426
+data/0054/000433
+data/0054/000437
+data/0054/000445
+data/0054/000447
+data/0054/000457
+data/0054/000460
+data/0054/000470
+data/0054/000473
+data/0054/000479
+data/0054/000480
+data/0054/000483
+data/0054/000491
+data/0054/000495
+data/0054/000501
+data/0054/000504
+data/0054/000511
+data/0054/000514
+data/0054/000520
+data/0054/000524
+data/0054/000530
+data/0054/000537
+data/0054/000543
+data/0054/000560
+data/0054/000561
+data/0054/000568
+data/0054/000577
+data/0054/000583
+data/0054/000588
+data/0054/000589
+data/0054/000595
+data/0054/000598
+data/0054/000603
+data/0054/000604
+data/0054/000609
+data/0054/000611
+data/0054/000615
+data/0054/000619
+data/0054/000620
+data/0054/000624
+data/0054/000626
+data/0054/000628
+data/0054/000634
+data/0054/000636
+data/0054/000642
+data/0054/000644
+data/0054/000649
+data/0054/000653
+data/0054/000656
+data/0054/000661
+data/0054/000666
+data/0054/000672
+data/0054/000673
+data/0054/000679
+data/0054/000681
+data/0054/000687
+data/0054/000689
+data/0054/000693
+data/0054/000697
+data/0054/000701
+data/0054/000705
+data/0054/000707
+data/0054/000711
+data/0054/000715
+data/0054/000719
+data/0054/000721
+data/0054/000724
+data/0054/000725
+data/0054/000730
+data/0054/000731
+data/0054/000736
+data/0054/000741
+data/0054/000746
+data/0054/000748
+data/0054/000752
+data/0054/000756
+data/0054/000766
+data/0054/000777
+data/0054/000786
+data/0054/000800
+data/0054/000802
+data/0054/000817
+data/0054/000819
+data/0054/000830
+data/0054/000831
+data/0054/000848
+data/0054/000857
+data/0054/000866
+data/0054/000868
+data/0054/000875
+data/0054/000877
+data/0054/000902
+data/0054/000915
+data/0054/000920
+data/0054/000923
+data/0054/000932
+data/0054/000934
+data/0054/000952
+data/0054/000956
+data/0054/000975
+data/0054/000983
+data/0054/000988
+data/0054/000993
+data/0054/000998
+data/0054/001002
+data/0054/001006
+data/0054/001008
+data/0054/001011
+data/0054/001012
+data/0054/001015
+data/0054/001016
+data/0054/001017
+data/0054/001019
+data/0054/001020
+data/0054/001024
+data/0054/001025
+data/0054/001028
+data/0054/001029
+data/0054/001032
+data/0054/001033
+data/0054/001039
+data/0054/001042
+data/0054/001063
+data/0054/001068
+data/0054/001080
+data/0054/001083
+data/0054/001089
+data/0054/001096
+data/0054/001106
+data/0054/001110
+data/0054/001111
+data/0054/001123
+data/0054/001129
+data/0054/001134
+data/0054/001135
+data/0054/001139
+data/0054/001144
+data/0054/001145
+data/0054/001152
+data/0054/001153
+data/0054/001159
+data/0054/001160
+data/0054/001162
+data/0054/001166
+data/0054/001168
+data/0054/001169
+data/0054/001174
+data/0054/001175
+data/0054/001178
+data/0054/001183
+data/0054/001184
+data/0054/001191
+data/0054/001194
+data/0054/001210
+data/0054/001215
+data/0054/001232
+data/0054/001246
+data/0054/001257
+data/0054/001266
+data/0054/001277
+data/0054/001284
+data/0054/001302
+data/0054/001307
+data/0054/001313
+data/0054/001317
+data/0054/001321
+data/0054/001333
+data/0054/001348
+data/0054/001352
+data/0054/001355
+data/0054/001359
+data/0054/001361
+data/0054/001365
+data/0054/001369
+data/0054/001371
+data/0054/001385
+data/0054/001389
+data/0054/001407
+data/0054/001413
+data/0054/001438
+data/0054/001439
+data/0054/001451
+data/0054/001466
+data/0054/001491
+data/0054/001494
+data/0054/001509
+data/0054/001513
+data/0054/001515
+data/0054/001521
+data/0054/001526
+data/0054/001531
+data/0054/001539
+data/0054/001543
+data/0054/001547
+data/0054/001550
+data/0054/001557
+data/0054/001559
+data/0054/001568
+data/0054/001573
+data/0054/001580
+data/0054/001585
+data/0054/001595
+data/0054/001597
+data/0054/001605
+data/0054/001613
+data/0054/001619
+data/0054/001625
+data/0054/001631
+data/0054/001636
+data/0054/001649
+data/0054/001652
+data/0054/001661
+data/0054/001663
+data/0054/001668
+data/0054/001674
+data/0054/001681
+data/0054/001686
+data/0054/001699
+data/0054/001711
+data/0054/001717
+data/0054/001730
+data/0054/001731
+data/0054/001749
+data/0054/001753
+data/0054/001765
+data/0054/001774
+data/0054/001789
+data/0054/001801
+data/0054/001821
+data/0054/001842
+data/0054/001844
+data/0054/001854
+data/0054/001872
+data/0054/001882
+data/0054/001888
+data/0054/001900
+data/0054/001918
+data/0055/000001
+data/0055/000011
+data/0055/000018
+data/0055/000022
+data/0055/000032
+data/0055/000042
+data/0055/000049
+data/0055/000062
+data/0055/000078
+data/0055/000089
+data/0055/000094
+data/0055/000100
+data/0055/000107
+data/0055/000122
+data/0055/000128
+data/0055/000155
+data/0055/000179
+data/0055/000204
+data/0055/000205
+data/0055/000218
+data/0055/000219
+data/0055/000229
+data/0055/000231
+data/0055/000240
+data/0055/000245
+data/0055/000255
+data/0055/000259
+data/0055/000271
+data/0055/000273
+data/0055/000278
+data/0055/000289
+data/0055/000303
+data/0055/000305
+data/0055/000320
+data/0055/000346
+data/0055/000348
+data/0055/000352
+data/0055/000354
+data/0055/000355
+data/0055/000356
+data/0055/000358
+data/0055/000359
+data/0055/000360
+data/0055/000363
+data/0055/000369
+data/0055/000371
+data/0055/000376
+data/0055/000381
+data/0055/000385
+data/0055/000389
+data/0055/000391
+data/0055/000395
+data/0055/000398
+data/0055/000404
+data/0055/000407
+data/0055/000411
+data/0055/000415
+data/0055/000425
+data/0055/000434
+data/0055/000436
+data/0055/000446
+data/0055/000448
+data/0055/000454
+data/0055/000461
+data/0055/000464
+data/0055/000471
+data/0055/000479
+data/0055/000488
+data/0055/000495
+data/0055/000502
+data/0055/000512
+data/0055/000513
+data/0055/000526
+data/0055/000530
+data/0055/000546
+data/0055/000562
+data/0055/000563
+data/0055/000588
+data/0055/000598
+data/0055/000603
+data/0055/000610
+data/0055/000612
+data/0055/000618
+data/0055/000621
+data/0055/000622
+data/0055/000638
+data/0055/000641
+data/0055/000649
+data/0055/000654
+data/0055/000663
+data/0055/000668
+data/0055/000686
+data/0055/000687
+data/0055/000702
+data/0055/000710
+data/0055/000715
+data/0055/000724
+data/0055/000732
+data/0055/000739
+data/0055/000746
+data/0055/000747
+data/0055/000759
+data/0055/000761
+data/0055/000772
+data/0055/000785
+data/0055/000793
+data/0055/000813
+data/0055/000820
+data/0055/000829
+data/0055/000839
+data/0055/000846
+data/0055/000856
+data/0055/000859
+data/0055/000864
+data/0055/000869
+data/0055/000873
+data/0055/000879
+data/0055/000884
+data/0055/000890
+data/0055/000893
+data/0055/000901
+data/0055/000904
+data/0055/000905
+data/0055/000906
+data/0055/000908
+data/0055/000910
+data/0055/000912
+data/0055/000915
+data/0055/000920
+data/0055/000927
+data/0055/000937
+data/0055/000944
+data/0055/000951
+data/0055/000958
+data/0055/000968
+data/0055/000983
+data/0055/000989
+data/0055/000997
+data/0055/001009
+data/0055/001019
+data/0055/001025
+data/0055/001038
+data/0055/001040
+data/0055/001041
+data/0055/001042
+data/0055/001044
+data/0055/001046
+data/0055/001048
+data/0055/001049
+data/0055/001053
+data/0055/001055
+data/0055/001064
+data/0055/001068
+data/0055/001088
+data/0055/001100
+data/0055/001103
+data/0055/001115
+data/0055/001120
+data/0055/001132
+data/0055/001136
+data/0055/001147
+data/0055/001151
+data/0055/001161
+data/0055/001164
+data/0055/001176
+data/0055/001177
+data/0055/001187
+data/0055/001188
+data/0055/001189
+data/0055/001200
+data/0055/001202
+data/0055/001215
+data/0055/001216
+data/0055/001229
+data/0055/001237
+data/0055/001244
+data/0055/001252
+data/0055/001265
+data/0055/001266
+data/0055/001276
+data/0055/001283
+data/0055/001291
+data/0055/001298
+data/0055/001307
+data/0055/001308
+data/0055/001317
+data/0055/001327
+data/0055/001330
+data/0055/001336
+data/0055/001341
+data/0055/001347
+data/0055/001351
+data/0055/001355
+data/0055/001358
+data/0055/001359
+data/0055/001362
+data/0055/001366
+data/0055/001367
+data/0055/001369
+data/0055/001372
+data/0055/001374
+data/0055/001381
+data/0055/001390
+data/0055/001400
+data/0055/001407
+data/0055/001419
+data/0055/001426
+data/0055/001439
+data/0055/001453
+data/0055/001468
+data/0055/001478
+data/0055/001481
+data/0055/001489
+data/0055/001492
+data/0055/001503
+data/0055/001505
+data/0055/001520
+data/0055/001522
+data/0055/001532
+data/0055/001543
+data/0055/001563
+data/0055/001567
+data/0055/001585
+data/0055/001592
+data/0055/001603
+data/0055/001604
+data/0055/001609
+data/0055/001612
+data/0055/001625
+data/0055/001632
+data/0055/001643
+data/0055/001666
+data/0055/001691
+data/0055/001708
+data/0055/001717
+data/0055/001721
+data/0055/001746
+data/0055/001773
+data/0055/001785
+data/0055/001801
+data/0055/001811
+data/0055/001824
+data/0056/000001
+data/0056/000024
+data/0056/000032
+data/0056/000039
+data/0056/000046
+data/0056/000053
+data/0056/000062
+data/0056/000075
+data/0056/000085
+data/0056/000098
+data/0056/000104
+data/0056/000107
+data/0056/000116
+data/0056/000119
+data/0056/000128
+data/0056/000132
+data/0056/000140
+data/0056/000143
+data/0056/000150
+data/0056/000163
+data/0056/000170
+data/0056/000175
+data/0056/000190
+data/0056/000200
+data/0056/000207
+data/0056/000217
+data/0056/000232
+data/0056/000236
+data/0056/000246
+data/0056/000249
+data/0056/000254
+data/0056/000257
+data/0056/000260
+data/0056/000265
+data/0056/000267
+data/0056/000290
+data/0056/000293
+data/0056/000303
+data/0056/000314
+data/0056/000324
+data/0056/000329
+data/0056/000331
+data/0056/000333
+data/0056/000337
+data/0056/000342
+data/0056/000347
+data/0056/000348
+data/0056/000354
+data/0056/000355
+data/0056/000357
+data/0056/000375
+data/0056/000376
+data/0056/000381
+data/0056/000383
+data/0056/000414
+data/0056/000415
+data/0056/000425
+data/0056/000434
+data/0056/000436
+data/0056/000441
+data/0056/000444
+data/0056/000447
+data/0056/000451
+data/0056/000453
+data/0056/000458
+data/0056/000461
+data/0056/000468
+data/0056/000473
+data/0056/000479
+data/0056/000493
+data/0056/000497
+data/0056/000498
+data/0056/000500
+data/0056/000504
+data/0056/000509
+data/0056/000515
+data/0056/000517
+data/0056/000522
+data/0056/000527
+data/0056/000535
+data/0056/000538
+data/0056/000551
+data/0056/000553
+data/0056/000559
+data/0056/000563
+data/0056/000567
+data/0056/000570
+data/0056/000575
+data/0056/000578
+data/0056/000587
+data/0056/000589
+data/0056/000596
+data/0056/000598
+data/0056/000601
+data/0056/000603
+data/0056/000604
+data/0056/000608
+data/0056/000628
+data/0056/000631
+data/0056/000634
+data/0056/000644
+data/0056/000653
+data/0056/000664
+data/0056/000671
+data/0056/000676
+data/0056/000680
+data/0056/000685
+data/0056/000686
+data/0056/000697
+data/0056/000703
+data/0056/000715
+data/0056/000724
+data/0056/000730
+data/0056/000734
+data/0056/000746
+data/0056/000748
+data/0056/000751
+data/0056/000753
+data/0056/000754
+data/0056/000761
+data/0056/000764
+data/0056/000775
+data/0056/000793
+data/0056/000797
+data/0056/000805
+data/0056/000810
+data/0056/000814
+data/0056/000826
+data/0056/000834
+data/0056/000835
+data/0056/000840
+data/0056/000845
+data/0056/000846
+data/0056/000851
+data/0056/000858
+data/0056/000869
+data/0056/000878
+data/0056/000883
+data/0056/000886
+data/0056/000887
+data/0056/000894
+data/0056/000905
+data/0056/000936
+data/0056/000938
+data/0056/000952
+data/0056/000953
+data/0056/000956
+data/0056/000959
+data/0056/000960
+data/0056/000966
+data/0056/000968
+data/0056/000973
+data/0056/000977
+data/0056/000981
+data/0056/000986
+data/0056/000988
+data/0056/000990
+data/0056/000996
+data/0056/001001
+data/0056/001002
+data/0056/001014
+data/0056/001025
+data/0056/001028
+data/0056/001036
+data/0056/001037
+data/0056/001044
+data/0056/001046
+data/0056/001047
+data/0056/001048
+data/0056/001049
+data/0056/001054
+data/0056/001062
+data/0056/001064
+data/0056/001070
+data/0056/001071
+data/0056/001078
+data/0056/001087
+data/0056/001097
+data/0056/001108
+data/0056/001116
+data/0056/001124
+data/0056/001135
+data/0056/001146
+data/0056/001158
+data/0056/001171
+data/0056/001186
+data/0056/001197
+data/0056/001202
+data/0056/001220
+data/0057/000001
+data/0057/000024
+data/0057/000038
+data/0057/000049
+data/0057/000061
+data/0057/000074
+data/0057/000081
+data/0057/000088
+data/0057/000103
+data/0057/000117
+data/0057/000119
+data/0057/000123
+data/0057/000129
+data/0057/000136
+data/0057/000139
+data/0057/000148
+data/0057/000149
+data/0057/000157
+data/0057/000159
+data/0057/000166
+data/0057/000168
+data/0057/000181
+data/0057/000183
+data/0057/000187
+data/0057/000195
+data/0057/000201
+data/0057/000214
+data/0057/000217
+data/0057/000235
+data/0057/000240
+data/0057/000246
+data/0057/000252
+data/0057/000255
+data/0057/000265
+data/0057/000269
+data/0057/000277
+data/0057/000283
+data/0057/000324
+data/0057/000354
+data/0057/000386
+data/0057/000388
+data/0057/000397
+data/0057/000400
+data/0057/000408
+data/0057/000414
+data/0057/000424
+data/0057/000440
+data/0057/000445
+data/0057/000453
+data/0057/000456
+data/0057/000469
+data/0057/000473
+data/0057/000483
+data/0057/000486
+data/0057/000498
+data/0057/000499
+data/0057/000503
+data/0057/000518
+data/0057/000526
+data/0057/000528
+data/0057/000537
+data/0057/000541
+data/0057/000553
+data/0057/000554
+data/0057/000565
+data/0057/000574
+data/0057/000575
+data/0057/000584
+data/0057/000592
+data/0057/000597
+data/0057/000606
+data/0057/000610
+data/0057/000613
+data/0057/000618
+data/0057/000621
+data/0057/000622
+data/0057/000634
+data/0057/000638
+data/0057/000644
+data/0057/000645
+data/0057/000653
+data/0057/000654
+data/0057/000664
+data/0057/000665
+data/0057/000671
+data/0057/000674
+data/0057/000689
+data/0057/000696
+data/0057/000711
+data/0057/000712
+data/0057/000717
+data/0057/000735
+data/0057/000747
+data/0057/000768
+data/0057/000779
+data/0057/000780
+data/0057/000790
+data/0057/000791
+data/0057/000795
+data/0057/000801
+data/0057/000803
+data/0057/000809
+data/0057/000811
+data/0057/000818
+data/0057/000819
+data/0057/000824
+data/0057/000825
+data/0057/000827
+data/0057/000829
+data/0057/000830
+data/0057/000833
+data/0057/000836
+data/0057/000837
+data/0057/000839
+data/0057/000840
+data/0057/000841
+data/0057/000842
+data/0057/000844
+data/0057/000845
+data/0057/000847
+data/0057/000849
+data/0057/000851
+data/0057/000870
+data/0057/000877
+data/0057/000890
+data/0057/000897
+data/0057/000907
+data/0057/000928
+data/0057/000934
+data/0057/000935
+data/0057/000940
+data/0057/000942
+data/0057/000946
+data/0057/000951
+data/0057/000953
+data/0057/000958
+data/0057/000959
+data/0057/000964
+data/0057/000965
+data/0057/000971
+data/0057/000973
+data/0057/000978
+data/0057/000982
+data/0057/000983
+data/0057/000986
+data/0057/000990
+data/0057/000991
+data/0057/000998
+data/0057/001012
+data/0057/001026
+data/0057/001028
+data/0057/001035
+data/0057/001040
+data/0057/001046
+data/0057/001054
+data/0057/001057
+data/0057/001066
+data/0057/001071
+data/0057/001073
+data/0057/001076
+data/0057/001078
+data/0057/001081
+data/0057/001082
+data/0057/001083
+data/0057/001086
+data/0057/001087
+data/0057/001092
+data/0057/001093
+data/0057/001099
+data/0057/001101
+data/0057/001108
+data/0057/001116
+data/0057/001118
+data/0057/001131
+data/0057/001132
+data/0057/001135
+data/0057/001138
+data/0057/001141
+data/0057/001144
+data/0057/001148
+data/0057/001153
+data/0057/001158
+data/0057/001159
+data/0057/001161
+data/0057/001164
+data/0057/001166
+data/0057/001170
+data/0057/001173
+data/0057/001176
+data/0057/001181
+data/0057/001185
+data/0057/001190
+data/0057/001215
+data/0057/001245
+data/0057/001250
+data/0057/001257
+data/0057/001258
+data/0057/001268
+data/0057/001269
+data/0057/001275
+data/0057/001276
+data/0057/001282
+data/0057/001290
+data/0057/001292
+data/0057/001306
+data/0057/001313
+data/0057/001322
+data/0057/001325
+data/0057/001331
+data/0057/001336
+data/0057/001340
+data/0057/001347
+data/0057/001360
+data/0057/001361
+data/0057/001369
+data/0057/001381
+data/0057/001407
+data/0057/001422
+data/0057/001428
+data/0057/001434
+data/0057/001435
+data/0057/001440
+data/0057/001441
+data/0057/001442
+data/0057/001447
+data/0057/001458
+data/0057/001464
+data/0057/001465
+data/0057/001469
+data/0057/001471
+data/0057/001474
+data/0057/001476
+data/0057/001480
+data/0057/001482
+data/0057/001483
+data/0057/001490
+data/0057/001492
+data/0057/001498
+data/0057/001500
+data/0057/001511
+data/0057/001518
+data/0057/001527
+data/0057/001530
+data/0057/001531
+data/0057/001538
+data/0057/001539
+data/0057/001549
+data/0057/001560
+data/0057/001563
+data/0057/001566
+data/0057/001570
+data/0057/001585
+data/0057/001589
+data/0057/001593
+data/0057/001602
+data/0057/001612
+data/0057/001621
+data/0057/001628
+data/0057/001637
+data/0057/001647
+data/0057/001671
+data/0057/001681
+data/0057/001691
+data/0057/001700
+data/0057/001703
+data/0057/001705
+data/0057/001708
+data/0057/001709
+data/0057/001712
+data/0057/001713
+data/0057/001714
+data/0057/001722
+data/0057/001734
+data/0057/001737
+data/0057/001739
+data/0057/001740
+data/0057/001741
+data/0057/001742
+data/0057/001745
+data/0057/001747
+data/0057/001748
+data/0057/001752
+data/0057/001759
+data/0057/001774
+data/0057/001789
+data/0057/001814
+data/0057/001827
+data/0057/001835
+data/0058/000001
+data/0058/000021
+data/0058/000030
+data/0058/000040
+data/0058/000048
+data/0058/000061
+data/0058/000068
+data/0058/000077
+data/0058/000086
+data/0058/000094
+data/0058/000102
+data/0058/000103
+data/0058/000107
+data/0058/000109
+data/0058/000114
+data/0058/000116
+data/0058/000121
+data/0058/000124
+data/0058/000135
+data/0058/000137
+data/0058/000149
+data/0058/000154
+data/0058/000163
+data/0058/000166
+data/0058/000180
+data/0058/000181
+data/0058/000197
+data/0058/000201
+data/0058/000211
+data/0058/000215
+data/0058/000217
+data/0058/000221
+data/0058/000226
+data/0058/000237
+data/0058/000242
+data/0058/000247
+data/0058/000249
+data/0058/000255
+data/0058/000257
+data/0058/000262
+data/0058/000269
+data/0058/000278
+data/0058/000279
+data/0058/000287
+data/0058/000288
+data/0058/000300
+data/0058/000301
+data/0058/000313
+data/0058/000317
+data/0058/000319
+data/0058/000329
+data/0058/000332
+data/0058/000342
+data/0058/000354
+data/0058/000361
+data/0058/000369
+data/0058/000372
+data/0058/000382
+data/0058/000390
+data/0058/000395
+data/0058/000402
+data/0058/000404
+data/0058/000410
+data/0058/000414
+data/0058/000422
+data/0058/000423
+data/0058/000434
+data/0058/000443
+data/0058/000444
+data/0058/000445
+data/0058/000456
+data/0058/000460
+data/0058/000469
+data/0058/000472
+data/0058/000476
+data/0058/000484
+data/0058/000488
+data/0058/000495
+data/0058/000498
+data/0058/000505
+data/0058/000508
+data/0058/000516
+data/0058/000519
+data/0058/000529
+data/0058/000531
+data/0058/000541
+data/0058/000553
+data/0058/000561
+data/0058/000562
+data/0058/000574
+data/0058/000576
+data/0058/000583
+data/0058/000588
+data/0058/000596
+data/0058/000603
+data/0058/000610
+data/0058/000617
+data/0058/000631
+data/0058/000635
+data/0058/000642
+data/0058/000646
+data/0058/000653
+data/0058/000655
+data/0058/000660
+data/0058/000662
+data/0058/000670
+data/0058/000677
+data/0058/000688
+data/0058/000691
+data/0058/000694
+data/0058/000703
+data/0058/000712
+data/0058/000725
+data/0058/000730
+data/0058/000737
+data/0058/000743
+data/0058/000759
+data/0058/000763
+data/0058/000772
+data/0058/000776
+data/0058/000783
+data/0058/000785
+data/0058/000793
+data/0058/000794
+data/0058/000802
+data/0058/000813
+data/0058/000815
+data/0058/000824
+data/0058/000826
+data/0058/000838
+data/0058/000839
+data/0058/000849
+data/0058/000850
+data/0058/000857
+data/0058/000858
+data/0058/000866
+data/0058/000867
+data/0058/000874
+data/0058/000878
+data/0058/000891
+data/0058/000897
+data/0058/000905
+data/0058/000909
+data/0058/000920
+data/0058/000921
+data/0058/000931
+data/0058/000932
+data/0058/000940
+data/0058/000943
+data/0058/000952
+data/0058/000958
+data/0058/000967
+data/0058/000971
+data/0058/000983
+data/0058/000985
+data/0058/000999
+data/0058/001000
+data/0058/001012
+data/0058/001013
+data/0058/001023
+data/0058/001035
+data/0058/001036
+data/0058/001051
+data/0058/001068
+data/0058/001072
+data/0058/001082
+data/0058/001084
+data/0058/001094
+data/0058/001097
+data/0058/001113
+data/0058/001129
+data/0058/001144
+data/0058/001146
+data/0058/001164
+data/0058/001167
+data/0058/001177
+data/0058/001180
+data/0058/001196
+data/0058/001199
+data/0058/001216
+data/0058/001217
+data/0058/001248
+data/0058/001253
+data/0058/001274
+data/0058/001278
+data/0058/001289
+data/0058/001293
+data/0058/001301
+data/0058/001305
+data/0058/001324
+data/0058/001330
+data/0058/001393
+data/0058/001395
+data/0058/001416
+data/0058/001420
+data/0058/001426
+data/0058/001427
+data/0058/001434
+data/0058/001436
+data/0058/001447
+data/0058/001451
+data/0058/001467
+data/0058/001480
+data/0058/001504
+data/0058/001511
+data/0058/001529
+data/0058/001549
+data/0058/001584
+data/0058/001599
+data/0058/001614
+data/0058/001639
+data/0058/001669
+data/0058/001672
+data/0058/001684
+data/0059/000001
+data/0059/000029
+data/0059/000037
+data/0059/000055
+data/0059/000061
+data/0059/000068
+data/0059/000080
+data/0059/000088
+data/0059/000099
+data/0059/000114
+data/0059/000120
+data/0059/000126
+data/0059/000127
+data/0059/000132
+data/0059/000139
+data/0059/000142
+data/0059/000145
+data/0059/000148
+data/0059/000150
+data/0059/000151
+data/0059/000153
+data/0059/000154
+data/0059/000156
+data/0059/000158
+data/0059/000159
+data/0059/000160
+data/0059/000162
+data/0059/000163
+data/0059/000164
+data/0059/000165
+data/0059/000167
+data/0059/000169
+data/0059/000171
+data/0059/000176
+data/0059/000190
+data/0059/000196
+data/0059/000206
+data/0059/000210
+data/0059/000215
+data/0059/000224
+data/0059/000231
+data/0059/000232
+data/0059/000234
+data/0059/000236
+data/0059/000238
+data/0059/000239
+data/0059/000240
+data/0059/000241
+data/0059/000242
+data/0059/000243
+data/0059/000244
+data/0059/000245
+data/0059/000246
+data/0059/000248
+data/0059/000250
+data/0059/000252
+data/0059/000253
+data/0059/000255
+data/0059/000256
+data/0059/000260
+data/0059/000262
+data/0059/000265
+data/0059/000266
+data/0059/000268
+data/0059/000270
+data/0059/000274
+data/0059/000275
+data/0059/000279
+data/0059/000280
+data/0059/000284
+data/0059/000290
+data/0059/000294
+data/0059/000295
+data/0059/000299
+data/0059/000300
+data/0059/000304
+data/0059/000305
+data/0059/000309
+data/0059/000310
+data/0059/000315
+data/0059/000316
+data/0059/000320
+data/0059/000321
+data/0059/000323
+data/0059/000333
+data/0059/000346
+data/0059/000352
+data/0059/000358
+data/0059/000364
+data/0059/000376
+data/0059/000384
+data/0059/000391
+data/0059/000392
+data/0059/000395
+data/0059/000396
+data/0059/000400
+data/0059/000402
+data/0059/000403
+data/0059/000408
+data/0059/000412
+data/0059/000416
+data/0059/000419
+data/0059/000420
+data/0059/000422
+data/0059/000423
+data/0059/000425
+data/0059/000426
+data/0059/000427
+data/0059/000428
+data/0059/000429
+data/0059/000430
+data/0059/000431
+data/0059/000434
+data/0059/000435
+data/0059/000438
+data/0059/000439
+data/0059/000442
+data/0059/000444
+data/0059/000447
+data/0059/000451
+data/0059/000455
+data/0059/000459
+data/0059/000463
+data/0059/000467
+data/0059/000471
+data/0059/000475
+data/0059/000479
+data/0059/000480
+data/0059/000483
+data/0059/000484
+data/0059/000488
+data/0059/000492
+data/0059/000495
+data/0059/000496
+data/0059/000499
+data/0059/000503
+data/0059/000505
+data/0059/000506
+data/0059/000509
+data/0059/000510
+data/0059/000514
+data/0059/000515
+data/0059/000523
+data/0059/000525
+data/0059/000530
+data/0059/000535
+data/0059/000545
+data/0059/000561
+data/0059/000567
+data/0059/000615
+data/0059/000629
+data/0059/000636
+data/0059/000637
+data/0059/000648
+data/0059/000650
+data/0059/000656
+data/0059/000657
+data/0059/000661
+data/0059/000662
+data/0059/000669
+data/0059/000670
+data/0059/000675
+data/0059/000676
+data/0059/000687
+data/0059/000689
+data/0059/000692
+data/0059/000698
+data/0059/000699
+data/0059/000701
+data/0059/000703
+data/0059/000704
+data/0059/000708
+data/0059/000710
+data/0059/000712
+data/0059/000717
+data/0059/000721
+data/0059/000726
+data/0059/000729
+data/0059/000733
+data/0059/000736
+data/0059/000745
+data/0059/000748
+data/0059/000755
+data/0059/000764
+data/0059/000769
+data/0059/000772
+data/0059/000775
+data/0059/000777
+data/0059/000781
+data/0059/000788
+data/0059/000795
+data/0059/000799
+data/0059/000801
+data/0059/000802
+data/0059/000806
+data/0059/000809
+data/0059/000816
+data/0059/000822
+data/0059/000833
+data/0059/000835
+data/0059/000839
+data/0059/000842
+data/0059/000845
+data/0059/000848
+data/0059/000851
+data/0059/000856
+data/0059/000863
+data/0059/000868
+data/0059/000872
+data/0059/000875
+data/0059/000879
+data/0059/000904
+data/0059/000908
+data/0059/000910
+data/0059/000915
+data/0059/000918
+data/0059/000943
+data/0059/000957
+data/0059/000991
+data/0059/001001
+data/0059/001008
+data/0059/001017
+data/0059/001022
+data/0059/001026
+data/0059/001027
+data/0059/001032
+data/0059/001034
+data/0059/001039
+data/0059/001044
+data/0059/001048
+data/0059/001054
+data/0059/001060
+data/0059/001063
+data/0059/001064
+data/0059/001068
+data/0059/001070
+data/0059/001071
+data/0059/001073
+data/0059/001074
+data/0059/001075
+data/0059/001076
+data/0059/001078
+data/0059/001081
+data/0059/001090
+data/0059/001093
+data/0059/001103
+data/0059/001110
+data/0059/001124
+data/0059/001129
+data/0059/001131
+data/0059/001132
+data/0059/001148
+data/0059/001152
+data/0059/001165
+data/0059/001170
+data/0059/001184
+data/0059/001199
+data/0059/001209
+data/0059/001214
+data/0059/001251
+data/0059/001259
+data/0059/001264
+data/0059/001271
+data/0059/001278
+data/0059/001295
+data/0059/001299
+data/0059/001308
+data/0059/001311
+data/0059/001313
+data/0059/001318
+data/0059/001320
+data/0059/001327
+data/0059/001334
+data/0059/001335
+data/0059/001349
+data/0059/001351
+data/0059/001360
+data/0059/001368
+data/0059/001374
+data/0059/001379
+data/0059/001385
+data/0059/001391
+data/0059/001399
+data/0059/001414
+data/0059/001428
+data/0059/001445
+data/0059/001458
+data/0059/001474
+data/0059/001483
+data/0059/001486
+data/0059/001487
+data/0059/001490
+data/0059/001491
+data/0059/001495
+data/0059/001498
+data/0059/001500
+data/0059/001509
+data/0059/001510
+data/0059/001514
+data/0059/001516
+data/0059/001520
+data/0059/001521
+data/0059/001523
+data/0059/001524
+data/0059/001528
+data/0059/001529
+data/0059/001539
+data/0059/001541
+data/0059/001544
+data/0059/001546
+data/0059/001553
+data/0059/001555
+data/0059/001559
+data/0059/001564
+data/0059/001565
+data/0059/001567
+data/0059/001574
+data/0059/001576
+data/0059/001581
+data/0059/001583
+data/0059/001585
+data/0059/001606
+data/0059/001612
+data/0059/001613
+data/0059/001621
+data/0059/001628
+data/0059/001637
+data/0059/001647
+data/0059/001661
+data/0059/001662
+data/0059/001669
+data/0059/001670
+data/0059/001677
+data/0059/001678
+data/0059/001682
+data/0059/001683
+data/0059/001690
+data/0059/001692
+data/0059/001696
+data/0059/001698
+data/0059/001699
+data/0059/001704
+data/0059/001707
+data/0059/001734
+data/0059/001747
+data/0059/001777
+data/0059/001782
+data/0059/001787
+data/0059/001800
+data/0059/001803
+data/0059/001806
+data/0059/001809
+data/0059/001812
+data/0059/001817
+data/0059/001819
+data/0059/001820
+data/0059/001821
+data/0059/001822
+data/0059/001824
+data/0059/001857

download.sh

@@ -0,0 +1,29 @@
+# Download the datasets and checkpoints
+
+if [ ! -d datasets/ycb/YCB_Video_Dataset ];then
+echo 'Downloading the YCB-Video Dataset'
+wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1if4VoEXNx9W3XCn0Y7Fp15B4GpcYbyYi' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1if4VoEXNx9W3XCn0Y7Fp15B4GpcYbyYi" -O YCB_Video_Dataset.zip && rm -rf /tmp/cookies.txt \
+&& unzip YCB_Video_Dataset.zip \
+&& mv YCB_Video_Dataset/ datasets/ycb/ \
+&& rm YCB_Video_Dataset.zip
+fi
+
+if [ ! -d datasets/linemod/Linemod_preprocessed ];then
+echo 'Downloading the preprocessed LineMOD dataset'
+wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1YFUra533pxS_IHsb9tB87lLoxbcHYXt8' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1YFUra533pxS_IHsb9tB87lLoxbcHYXt8" -O Linemod_preprocessed.zip && rm -rf /tmp/cookies.txt \
+&& unzip Linemod_preprocessed.zip \
+&& mv Linemod_preprocessed/ datasets/linemod/ \
+&& rm Linemod_preprocessed.zip
+fi
+
+if [ ! -d trained_checkpoints ];then
+echo 'Downloading the trained checkpoints...'
+wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=1bQ9H-fyZplQoNt1qRwdIUX5_3_1pj6US' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=1bQ9H-fyZplQoNt1qRwdIUX5_3_1pj6US" -O trained_checkpoints.zip && rm -rf /tmp/cookies.txt \
+&& unzip trained_checkpoints.zip -x "__MACOSX/*" "*.DS_Store" "*.gitignore" -d trained_checkpoints \
+&& mv trained_checkpoints/trained*/ycb trained_checkpoints/ycb \
+&& mv trained_checkpoints/trained*/linemod trained_checkpoints/linemod \
+&& rm -r trained_checkpoints/trained*/ \
+&& rm trained_checkpoints.zip
+fi
+
+echo 'done'

experiments/eval_result/linemod/.gitignore

@@ -0,0 +1 @@
+*.txt

experiments/eval_result/ycb/Densefusion_iterative_result/.gitignore

@@ -0,0 +1 @@
+*.mat

experiments/eval_result/ycb/Densefusion_wo_refine_result/.gitignore

@@ -0,0 +1 @@
+*.mat

experiments/logs/linemod/.gitignore

@@ -0,0 +1 @@
+*.txt

experiments/logs/ycb/.gitignore

@@ -0,0 +1 @@
+*.txt

experiments/scripts/eval_linemod.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -x
+set -e
+
+export PYTHONUNBUFFERED="True"
+export CUDA_VISIBLE_DEVICES=0
+
+python3 ./tools/eval_linemod.py --dataset_root ./datasets/linemod/Linemod_preprocessed\
+  --model trained_checkpoints/linemod/pose_model_9_0.01310166542980859.pth\
+  --refine_model trained_checkpoints/linemod/pose_refine_model_493_0.006761023565178073.pth

experiments/scripts/eval_ycb.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -x
+set -e
+
+export PYTHONUNBUFFERED="True"
+export CUDA_VISIBLE_DEVICES=0
+
+if [ ! -d YCB_Video_toolbox ];then
+    echo 'Downloading the YCB_Video_toolbox...'
+    git clone https://github.com/yuxng/YCB_Video_toolbox.git
+    cd YCB_Video_toolbox
+    unzip results_PoseCNN_RSS2018.zip
+    cd ..
+    cp replace_ycb_toolbox/*.m YCB_Video_toolbox/
+fi
+
+python3 ./tools/eval_ycb.py --dataset_root ./datasets/ycb/YCB_Video_Dataset\
+  --model trained_checkpoints/ycb/pose_model_26_0.012863246640872631.pth\
+  --refine_model trained_checkpoints/ycb/pose_refine_model_69_0.009449292959118935.pth

experiments/scripts/train_linemod.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -x
+set -e
+
+export PYTHONUNBUFFERED="True"
+export CUDA_VISIBLE_DEVICES=0
+
+python3 ./tools/train.py --dataset linemod\
+  --dataset_root ./datasets/linemod/Linemod_preprocessed

experiments/scripts/train_ycb.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+set -x
+set -e
+
+export PYTHONUNBUFFERED="True"
+export CUDA_VISIBLE_DEVICES=0
+
+python3 ./tools/train.py --dataset ycb\
+  --dataset_root ./datasets/ycb/YCB_Video_Dataset

lib/extractors.py

@@ -0,0 +1,145 @@
+from collections import OrderedDict
+import math
+import random
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+def load_weights_sequential(target, source_state):
+    new_dict = OrderedDict()
+    for (k1, v1), (k2, v2) in zip(target.state_dict().items(), source_state.items()):
+        new_dict[k1] = v2
+    target.load_state_dict(new_dict)
+
+def conv3x3(in_planes, out_planes, stride=1, dilation=1):
+    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
+                     padding=dilation, dilation=dilation, bias=False)
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = conv3x3(inplanes, planes, stride=stride, dilation=dilation)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes, stride=1, dilation=dilation)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+    def __init__(self, inplanes, planes, stride=1, downsample=None, dilation=1):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, dilation=dilation,
+                               padding=dilation, bias=False)
+        self.conv3 = nn.Conv2d(planes, planes * 4, kernel_size=1, bias=False)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+
+    def forward(self, x):
+        residual = x
+
+        out = self.conv1(x)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+
+        if self.downsample is not None:
+            residual = self.downsample(x)
+
+        out += residual
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+    def __init__(self, block, layers=(3, 4, 23, 3)):
+        self.inplanes = 64
+        super(ResNet, self).__init__()
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
+                               bias=False)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+                m.weight.data.normal_(0, math.sqrt(2. / n))
+            elif isinstance(m, nn.BatchNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+    def _make_layer(self, block, planes, blocks, stride=1, dilation=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion,
+                          kernel_size=1, stride=stride, bias=False)
+            )
+
+        layers = [block(self.inplanes, planes, stride, downsample)]
+        self.inplanes = planes * block.expansion
+        for i in range(1, blocks):
+            layers.append(block(self.inplanes, planes, dilation=dilation))
+
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x_3 = self.layer3(x)
+        x = self.layer4(x_3)
+
+        return x, x_3
+
+
+def resnet18(pretrained=False):
+    model = ResNet(BasicBlock, [2, 2, 2, 2])
+    return model
+
+def resnet34(pretrained=False):
+    model = ResNet(BasicBlock, [3, 4, 6, 3])
+    return model
+
+def resnet50(pretrained=False):
+    model = ResNet(Bottleneck, [3, 4, 6, 3])
+    return model
+
+def resnet101(pretrained=False):
+    model = ResNet(Bottleneck, [3, 4, 23, 3])
+    return model
+
+def resnet152(pretrained=False):
+    model = ResNet(Bottleneck, [3, 8, 36, 3])
+    return model

lib/knn/Makefile

@@ -0,0 +1,39 @@
+# Unix commands.
+PYTHON := python3
+NVCC_COMPILE := nvcc -c -o
+RM_RF := rm -rf
+
+# Library compilation rules.
+NVCC_FLAGS := -x cu -Xcompiler -fPIC -shared
+
+# File structure.
+BUILD_DIR := build
+INCLUDE_DIRS := src
+TORCH_FFI_BUILD := build_ffi.py
+KNN_KERNEL := $(BUILD_DIR)/knn_cuda_kernel.so
+TORCH_FFI_TARGET := $(BUILD_DIR)/knn_pytorch/_knn_pytorch.so
+
+INCLUDE_FLAGS := $(foreach d, $(INCLUDE_DIRS), -I$d)
+
+DEBUB := 0
+
+# Debugging
+ifeq ($(DEBUG), 1)
+  COMMON_FLAGS += -DDEBUG -g -O0
+  NVCC_FLAGS += -G
+else
+  COMMON_FLAGS += -DNDEBUG -O2
+endif
+
+all: $(TORCH_FFI_TARGET)
+
+$(TORCH_FFI_TARGET): $(KNN_KERNEL) $(TORCH_FFI_BUILD)
+	$(PYTHON) $(TORCH_FFI_BUILD)
+
+$(BUILD_DIR)/%.so: src/%.cu
+	@ mkdir -p $(BUILD_DIR)
+	# Separate cpp shared library that will be loaded to the extern C ffi
+	$(NVCC_COMPILE) $@ $? $(NVCC_FLAGS) $(INCLUDE_FLAGS)
+
+clean:
+	$(RM_RF) $(BUILD_DIR) $(KNN_KERNEL)

lib/knn/__init__.py

@@ -0,0 +1,45 @@
+import unittest
+import gc
+import operator as op
+import functools
+import torch
+from torch.autograd import Variable, Function
+from lib.knn import knn_pytorch as knn_pytorch
+
+class KNearestNeighbor(Function):
+  """ Compute k nearest neighbors for each query point.
+  """
+  def __init__(self, k):
+    self.k = k
+
+  def forward(self, ref, query):
+    ref = ref.float().cuda()
+    query = query.float().cuda()
+
+    inds = torch.empty(query.shape[0], self.k, query.shape[2]).long().cuda()
+
+    knn_pytorch.knn(ref, query, inds)
+
+    return inds
+
+
+class TestKNearestNeighbor(unittest.TestCase):
+
+  def test_forward(self):
+    knn = KNearestNeighbor(2)
+    while(1):
+        D, N, M = 128, 100, 1000
+        ref = Variable(torch.rand(2, D, N))
+        query = Variable(torch.rand(2, D, M))
+
+        inds = knn(ref, query)
+        for obj in gc.get_objects():
+            if torch.is_tensor(obj):
+                print(functools.reduce(op.mul, obj.size()) if len(obj.size()) > 0 else 0, type(obj), obj.size())
+        #ref = ref.cpu()
+        #query = query.cpu()
+        print(inds)
+
+
+if __name__ == '__main__':
+  unittest.main()

lib/knn/build_ffi.py

@@ -0,0 +1,25 @@
+# https://gist.github.com/tonyseek/7821993
+import glob
+import torch
+from os import path as osp
+from torch.utils.ffi import create_extension
+
+abs_path = osp.dirname(osp.realpath(__file__))
+extra_objects = [osp.join(abs_path, 'build/knn_cuda_kernel.so')]
+extra_objects += glob.glob('/usr/local/cuda/lib64/*.a')
+
+ffi = create_extension(
+    'knn_pytorch',
+    headers=['src/knn_pytorch.h'],
+    sources=['src/knn_pytorch.c'],
+    define_macros=[('WITH_CUDA', None)],
+    relative_to=__file__,
+    with_cuda=True,
+    extra_objects=extra_objects,
+    include_dirs=[osp.join(abs_path, 'include')]
+)
+
+
+if __name__ == '__main__':
+    assert torch.cuda.is_available(), 'Please install CUDA for GPU support.'
+    ffi.build()

lib/knn/knn_pytorch/__init__.py

@@ -0,0 +1,15 @@
+
+from torch.utils.ffi import _wrap_function
+from ._knn_pytorch import lib as _lib, ffi as _ffi
+
+__all__ = []
+def _import_symbols(locals):
+    for symbol in dir(_lib):
+        fn = getattr(_lib, symbol)
+        if callable(fn):
+            locals[symbol] = _wrap_function(fn, _ffi)
+        else:
+            locals[symbol] = fn
+        __all__.append(symbol)
+
+_import_symbols(locals())

lib/knn/knn_pytorch/_knn_pytorch.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bb7f7f35106cf880621799eb248771672bed927fe68cd63d8742d5a91ac851f
+size 616800

lib/knn/src/knn_cuda_kernel.cu

@@ -0,0 +1,259 @@
+/** Modifed version of knn-CUDA from https://github.com/vincentfpgarcia/kNN-CUDA
+ * The modifications are
+ *      removed texture memory usage
+ *      removed split query KNN computation
+ *      added feature extraction with bilinear interpolation
+ *
+ * Last modified by Christopher B. Choy <[email protected]> 12/23/2016
+ */
+
+// Includes
+#include <cstdio>
+#include "cuda.h"
+
+#include "knn_cuda_kernel.h"
+
+// Constants used by the program
+#define BLOCK_DIM                      16
+#define DEBUG                          0
+
+/**
+  * Computes the distance between two matrix A (reference points) and
+  * B (query points) containing respectively wA and wB points.
+  *
+  * @param A     pointer on the matrix A
+  * @param wA    width of the matrix A = number of points in A
+  * @param B     pointer on the matrix B
+  * @param wB    width of the matrix B = number of points in B
+  * @param dim   dimension of points = height of matrices A and B
+  * @param AB    pointer on the matrix containing the wA*wB distances computed
+  */
+__global__ void cuComputeDistanceGlobal( float* A, int wA,
+    float* B, int wB, int dim, float* AB){
+
+  // Declaration of the shared memory arrays As and Bs used to store the sub-matrix of A and B
+  __shared__ float shared_A[BLOCK_DIM][BLOCK_DIM];
+  __shared__ float shared_B[BLOCK_DIM][BLOCK_DIM];
+
+  // Sub-matrix of A (begin, step, end) and Sub-matrix of B (begin, step)
+  __shared__ int begin_A;
+  __shared__ int begin_B;
+  __shared__ int step_A;
+  __shared__ int step_B;
+  __shared__ int end_A;
+
+  // Thread index
+  int tx = threadIdx.x;
+  int ty = threadIdx.y;
+
+  // Other variables
+  float tmp;
+  float ssd = 0;
+
+  // Loop parameters
+  begin_A = BLOCK_DIM * blockIdx.y;
+  begin_B = BLOCK_DIM * blockIdx.x;
+  step_A  = BLOCK_DIM * wA;
+  step_B  = BLOCK_DIM * wB;
+  end_A   = begin_A + (dim-1) * wA;
+
+    // Conditions
+  int cond0 = (begin_A + tx < wA); // used to write in shared memory
+  int cond1 = (begin_B + tx < wB); // used to write in shared memory & to computations and to write in output matrix
+  int cond2 = (begin_A + ty < wA); // used to computations and to write in output matrix
+
+  // Loop over all the sub-matrices of A and B required to compute the block sub-matrix
+  for (int a = begin_A, b = begin_B; a <= end_A; a += step_A, b += step_B) {
+    // Load the matrices from device memory to shared memory; each thread loads one element of each matrix
+    if (a/wA + ty < dim){
+      shared_A[ty][tx] = (cond0)? A[a + wA * ty + tx] : 0;
+      shared_B[ty][tx] = (cond1)? B[b + wB * ty + tx] : 0;
+    }
+    else{
+      shared_A[ty][tx] = 0;
+      shared_B[ty][tx] = 0;
+    }
+
+    // Synchronize to make sure the matrices are loaded
+    __syncthreads();
+
+    // Compute the difference between the two matrixes; each thread computes one element of the block sub-matrix
+    if (cond2 && cond1){
+      for (int k = 0; k < BLOCK_DIM; ++k){
+        tmp = shared_A[k][ty] - shared_B[k][tx];
+        ssd += tmp*tmp;
+      }
+    }
+
+    // Synchronize to make sure that the preceding computation is done before loading two new sub-matrices of A and B in the next iteration
+    __syncthreads();
+  }
+
+  // Write the block sub-matrix to device memory; each thread writes one element
+  if (cond2 && cond1)
+    AB[(begin_A + ty) * wB + begin_B + tx] = ssd;
+}
+
+
+/**
+  * Gathers k-th smallest distances for each column of the distance matrix in the top.
+  *
+  * @param dist        distance matrix
+  * @param ind         index matrix
+  * @param width       width of the distance matrix and of the index matrix
+  * @param height      height of the distance matrix and of the index matrix
+  * @param k           number of neighbors to consider
+  */
+__global__ void cuInsertionSort(float *dist, long *ind, int width, int height, int k){
+
+  // Variables
+  int l, i, j;
+  float *p_dist;
+  long  *p_ind;
+  float curr_dist, max_dist;
+  long  curr_row,  max_row;
+  unsigned int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+
+  if (xIndex<width){
+    // Pointer shift, initialization, and max value
+    p_dist   = dist + xIndex;
+    p_ind    = ind  + xIndex;
+    max_dist = p_dist[0];
+    p_ind[0] = 1;
+
+    // Part 1 : sort kth firt elementZ
+    for (l=1; l<k; l++){
+      curr_row  = l * width;
+      curr_dist = p_dist[curr_row];
+      if (curr_dist<max_dist){
+        i=l-1;
+        for (int a=0; a<l-1; a++){
+          if (p_dist[a*width]>curr_dist){
+            i=a;
+            break;
+          }
+        }
+        for (j=l; j>i; j--){
+          p_dist[j*width] = p_dist[(j-1)*width];
+          p_ind[j*width]   = p_ind[(j-1)*width];
+        }
+        p_dist[i*width] = curr_dist;
+        p_ind[i*width]   = l+1;
+      } else {
+        p_ind[l*width] = l+1;
+      }
+      max_dist = p_dist[curr_row];
+    }
+
+    // Part 2 : insert element in the k-th first lines
+    max_row = (k-1)*width;
+    for (l=k; l<height; l++){
+      curr_dist = p_dist[l*width];
+      if (curr_dist<max_dist){
+        i=k-1;
+        for (int a=0; a<k-1; a++){
+          if (p_dist[a*width]>curr_dist){
+            i=a;
+            break;
+          }
+        }
+        for (j=k-1; j>i; j--){
+          p_dist[j*width] = p_dist[(j-1)*width];
+          p_ind[j*width]   = p_ind[(j-1)*width];
+        }
+        p_dist[i*width] = curr_dist;
+        p_ind[i*width]   = l+1;
+        max_dist             = p_dist[max_row];
+      }
+    }
+  }
+}
+
+
+/**
+  * Computes the square root of the first line (width-th first element)
+  * of the distance matrix.
+  *
+  * @param dist    distance matrix
+  * @param width   width of the distance matrix
+  * @param k       number of neighbors to consider
+  */
+__global__ void cuParallelSqrt(float *dist, int width, int k){
+    unsigned int xIndex = blockIdx.x * blockDim.x + threadIdx.x;
+    unsigned int yIndex = blockIdx.y * blockDim.y + threadIdx.y;
+  if (xIndex<width && yIndex<k)
+    dist[yIndex*width + xIndex] = sqrt(dist[yIndex*width + xIndex]);
+}
+
+
+//-----------------------------------------------------------------------------------------------//
+//                                   K-th NEAREST NEIGHBORS                                      //
+//-----------------------------------------------------------------------------------------------//
+
+/**
+  * K nearest neighbor algorithm
+  * - Initialize CUDA
+  * - Allocate device memory
+  * - Copy point sets (reference and query points) from host to device memory
+  * - Compute the distances + indexes to the k nearest neighbors for each query point
+  * - Copy distances from device to host memory
+  *
+  * @param ref_host      reference points ; pointer to linear matrix
+  * @param ref_nb        number of reference points ; width of the matrix
+  * @param query_host    query points ; pointer to linear matrix
+  * @param query_nb      number of query points ; width of the matrix
+  * @param dim           dimension of points ; height of the matrices
+  * @param k             number of neighbor to consider
+  * @param dist_host     distances to k nearest neighbors ; pointer to linear matrix
+  * @param dist_host     indexes of the k nearest neighbors ; pointer to linear matrix
+  *
+  */
+void knn_device(float* ref_dev, int ref_nb, float* query_dev, int query_nb,
+    int dim, int k, float* dist_dev, long* ind_dev, cudaStream_t stream){
+
+  // Grids and threads
+  dim3 g_16x16(query_nb/16, ref_nb/16, 1);
+  dim3 t_16x16(16, 16, 1);
+  if (query_nb%16 != 0) g_16x16.x += 1;
+  if (ref_nb  %16 != 0) g_16x16.y += 1;
+  //
+  dim3 g_256x1(query_nb/256, 1, 1);
+  dim3 t_256x1(256, 1, 1);
+  if (query_nb%256 != 0) g_256x1.x += 1;
+
+  dim3 g_k_16x16(query_nb/16, k/16, 1);
+  dim3 t_k_16x16(16, 16, 1);
+  if (query_nb%16 != 0) g_k_16x16.x += 1;
+  if (k  %16 != 0) g_k_16x16.y += 1;
+
+  // Kernel 1: Compute all the distances
+  cuComputeDistanceGlobal<<<g_16x16, t_16x16, 0, stream>>>(ref_dev, ref_nb,
+      query_dev, query_nb, dim, dist_dev);
+
+  // Kernel 2: Sort each column
+  cuInsertionSort<<<g_256x1, t_256x1, 0, stream>>>(dist_dev, ind_dev,
+      query_nb, ref_nb, k);
+
+  // Kernel 3: Compute square root of k first elements
+  // cuParallelSqrt<<<g_k_16x16,t_k_16x16, 0, stream>>>(dist_dev, query_nb, k);
+
+#if DEBUG
+  unsigned int  size_of_float = sizeof(float);
+  unsigned long size_of_long  = sizeof(long);
+
+  float* dist_host = new float[query_nb * k];
+  long*  idx_host  = new long[query_nb * k];
+
+  // Memory copy of output from device to host
+  cudaMemcpy(&dist_host[0], dist_dev,
+      query_nb * k *size_of_float, cudaMemcpyDeviceToHost);
+
+  cudaMemcpy(&idx_host[0], ind_dev,
+      query_nb * k * size_of_long, cudaMemcpyDeviceToHost);
+
+  int i = 0;
+  for(i = 0; i < 100; i++){
+    printf("IDX[%d]: %d\n", i, (int)idx_host[i]);
+  }
+#endif
+}

lib/knn/src/knn_cuda_kernel.h

@@ -0,0 +1,22 @@
+#ifndef _MATHUTIL_CUDA_KERNEL
+#define _MATHUTIL_CUDA_KERNEL
+
+#define IDX2D(i, j, dj) (dj * i + j)
+#define IDX3D(i, j, k, dj, dk) (IDX2D(IDX2D(i, j, dj), k, dk))
+
+#define BLOCK 512
+#define MAX_STREAMS 512
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void knn_device(float* ref_dev, int ref_width,
+    float* query_dev, int query_width,
+    int height, int k, float* dist_dev, long* ind_dev, cudaStream_t stream);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/knn/src/knn_pytorch.c

@@ -0,0 +1,48 @@
+#include <THC/THC.h>
+#include "knn_cuda_kernel.h"
+
+extern THCState *state;
+ 
+int knn(THCudaTensor *ref_tensor, THCudaTensor *query_tensor,
+    THCudaLongTensor *idx_tensor) {
+
+  THCAssertSameGPU(THCudaTensor_checkGPU(state, 3, idx_tensor, ref_tensor, query_tensor));
+  long batch, ref_nb, query_nb, dim, k;
+  THArgCheck(THCudaTensor_nDimension(state, ref_tensor) == 3 , 0, "ref_tensor: 3D Tensor expected");
+  THArgCheck(THCudaTensor_nDimension(state, query_tensor) == 3 , 1, "query_tensor: 3D Tensor expected");
+  THArgCheck(THCudaLongTensor_nDimension(state, idx_tensor) == 3 , 3, "idx_tensor: 3D Tensor expected");
+  THArgCheck(THCudaTensor_size(state, ref_tensor, 0) == THCudaTensor_size(state, query_tensor,0), 0, "input sizes must match");
+  THArgCheck(THCudaTensor_size(state, ref_tensor, 1) == THCudaTensor_size(state, query_tensor,1), 0, "input sizes must match");
+  THArgCheck(THCudaTensor_size(state, idx_tensor, 2) == THCudaTensor_size(state, query_tensor,2), 0, "input sizes must match");
+
+  //ref_tensor = THCudaTensor_newContiguous(state, ref_tensor);
+  //query_tensor = THCudaTensor_newContiguous(state, query_tensor);
+
+  batch = THCudaLongTensor_size(state, ref_tensor, 0);
+  dim = THCudaTensor_size(state, ref_tensor, 1);
+  k = THCudaLongTensor_size(state, idx_tensor, 1);
+  ref_nb = THCudaTensor_size(state, ref_tensor, 2);
+  query_nb = THCudaTensor_size(state, query_tensor, 2);
+
+  float *ref_dev = THCudaTensor_data(state, ref_tensor);
+  float *query_dev = THCudaTensor_data(state, query_tensor);
+  long *idx_dev = THCudaLongTensor_data(state, idx_tensor);
+  // scratch buffer for distances
+  float *dist_dev = (float*)THCudaMalloc(state, ref_nb * query_nb * sizeof(float));
+  
+  for (int b = 0; b < batch; b++) {
+    knn_device(ref_dev + b * dim * ref_nb, ref_nb, query_dev + b * dim * query_nb, query_nb, dim, k, 
+      dist_dev, idx_dev + b * k * query_nb, THCState_getCurrentStream(state));
+  }
+  // free buffer
+  THCudaFree(state, dist_dev);
+  //printf("aaaaa\n");
+  // check for errors
+  cudaError_t err = cudaGetLastError();
+  if (err != cudaSuccess) {
+    printf("error in knn: %s\n", cudaGetErrorString(err));
+    THError("aborting");
+  }
+
+  return 1;
+}

lib/knn/src/knn_pytorch.h

@@ -0,0 +1,2 @@
+int knn(THCudaTensor *ref_tensor, THCudaTensor *query_tensor,
+    THCudaLongTensor *idx_tensor);

lib/loss.py

@@ -0,0 +1,83 @@
+from torch.nn.modules.loss import _Loss
+from torch.autograd import Variable
+import torch
+import time
+import numpy as np
+import torch.nn as nn
+import random
+import torch.backends.cudnn as cudnn
+from lib.knn.__init__ import KNearestNeighbor
+
+
+def loss_calculation(pred_r, pred_t, pred_c, target, model_points, idx, points, w, refine, num_point_mesh, sym_list):
+    knn = KNearestNeighbor(1)
+    bs, num_p, _ = pred_c.size()
+
+    pred_r = pred_r / (torch.norm(pred_r, dim=2).view(bs, num_p, 1))
+    
+    base = torch.cat(((1.0 - 2.0*(pred_r[:, :, 2]**2 + pred_r[:, :, 3]**2)).view(bs, num_p, 1),\
+                      (2.0*pred_r[:, :, 1]*pred_r[:, :, 2] - 2.0*pred_r[:, :, 0]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 0]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 1]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 1]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 3]*pred_r[:, :, 0]).view(bs, num_p, 1), \
+                      (1.0 - 2.0*(pred_r[:, :, 1]**2 + pred_r[:, :, 3]**2)).view(bs, num_p, 1), \
+                      (-2.0*pred_r[:, :, 0]*pred_r[:, :, 1] + 2.0*pred_r[:, :, 2]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (-2.0*pred_r[:, :, 0]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 1]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 0]*pred_r[:, :, 1] + 2.0*pred_r[:, :, 2]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (1.0 - 2.0*(pred_r[:, :, 1]**2 + pred_r[:, :, 2]**2)).view(bs, num_p, 1)), dim=2).contiguous().view(bs * num_p, 3, 3)
+
+    ori_base = base
+    base = base.contiguous().transpose(2, 1).contiguous()
+    model_points = model_points.view(bs, 1, num_point_mesh, 3).repeat(1, num_p, 1, 1).view(bs * num_p, num_point_mesh, 3)
+    target = target.view(bs, 1, num_point_mesh, 3).repeat(1, num_p, 1, 1).view(bs * num_p, num_point_mesh, 3)
+    ori_target = target
+    pred_t = pred_t.contiguous().view(bs * num_p, 1, 3)
+    ori_t = pred_t
+    points = points.contiguous().view(bs * num_p, 1, 3)
+    pred_c = pred_c.contiguous().view(bs * num_p)
+
+    pred = torch.add(torch.bmm(model_points, base), points + pred_t)
+
+    if not refine:
+        if idx[0].item() in sym_list:
+            target = target[0].transpose(1, 0).contiguous().view(3, -1)
+            pred = pred.permute(2, 0, 1).contiguous().view(3, -1)
+            inds = knn(target.unsqueeze(0), pred.unsqueeze(0))
+            target = torch.index_select(target, 1, inds.view(-1) - 1)
+            target = target.view(3, bs * num_p, num_point_mesh).permute(1, 2, 0).contiguous()
+            pred = pred.view(3, bs * num_p, num_point_mesh).permute(1, 2, 0).contiguous()
+
+    dis = torch.mean(torch.norm((pred - target), dim=2), dim=1)
+    loss = torch.mean((dis * pred_c - w * torch.log(pred_c)), dim=0)
+    
+
+    pred_c = pred_c.view(bs, num_p)
+    how_max, which_max = torch.max(pred_c, 1)
+    dis = dis.view(bs, num_p)
+
+
+    t = ori_t[which_max[0]] + points[which_max[0]]
+    points = points.view(1, bs * num_p, 3)
+
+    ori_base = ori_base[which_max[0]].view(1, 3, 3).contiguous()
+    ori_t = t.repeat(bs * num_p, 1).contiguous().view(1, bs * num_p, 3)
+    new_points = torch.bmm((points - ori_t), ori_base).contiguous()
+
+    new_target = ori_target[0].view(1, num_point_mesh, 3).contiguous()
+    ori_t = t.repeat(num_point_mesh, 1).contiguous().view(1, num_point_mesh, 3)
+    new_target = torch.bmm((new_target - ori_t), ori_base).contiguous()
+
+    # print('------------> ', dis[0][which_max[0]].item(), pred_c[0][which_max[0]].item(), idx[0].item())
+    del knn
+    return loss, dis[0][which_max[0]], new_points.detach(), new_target.detach()
+
+
+class Loss(_Loss):
+
+    def __init__(self, num_points_mesh, sym_list):
+        super(Loss, self).__init__(True)
+        self.num_pt_mesh = num_points_mesh
+        self.sym_list = sym_list
+
+    def forward(self, pred_r, pred_t, pred_c, target, model_points, idx, points, w, refine):
+
+        return loss_calculation(pred_r, pred_t, pred_c, target, model_points, idx, points, w, refine, self.num_pt_mesh, self.sym_list)

lib/loss_refiner.py

@@ -0,0 +1,76 @@
+from torch.nn.modules.loss import _Loss
+from torch.autograd import Variable
+import torch
+import time
+import numpy as np
+import torch.nn as nn
+import random
+import torch.backends.cudnn as cudnn
+from lib.knn.__init__ import KNearestNeighbor
+
+
+def loss_calculation(pred_r, pred_t, target, model_points, idx, points, num_point_mesh, sym_list):
+    knn = KNearestNeighbor(1)
+    pred_r = pred_r.view(1, 1, -1)
+    pred_t = pred_t.view(1, 1, -1)
+    bs, num_p, _ = pred_r.size()
+    num_input_points = len(points[0])
+
+    pred_r = pred_r / (torch.norm(pred_r, dim=2).view(bs, num_p, 1))
+    
+    base = torch.cat(((1.0 - 2.0*(pred_r[:, :, 2]**2 + pred_r[:, :, 3]**2)).view(bs, num_p, 1),\
+                      (2.0*pred_r[:, :, 1]*pred_r[:, :, 2] - 2.0*pred_r[:, :, 0]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 0]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 1]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 1]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 3]*pred_r[:, :, 0]).view(bs, num_p, 1), \
+                      (1.0 - 2.0*(pred_r[:, :, 1]**2 + pred_r[:, :, 3]**2)).view(bs, num_p, 1), \
+                      (-2.0*pred_r[:, :, 0]*pred_r[:, :, 1] + 2.0*pred_r[:, :, 2]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (-2.0*pred_r[:, :, 0]*pred_r[:, :, 2] + 2.0*pred_r[:, :, 1]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (2.0*pred_r[:, :, 0]*pred_r[:, :, 1] + 2.0*pred_r[:, :, 2]*pred_r[:, :, 3]).view(bs, num_p, 1), \
+                      (1.0 - 2.0*(pred_r[:, :, 1]**2 + pred_r[:, :, 2]**2)).view(bs, num_p, 1)), dim=2).contiguous().view(bs * num_p, 3, 3)
+    
+    ori_base = base
+    base = base.contiguous().transpose(2, 1).contiguous()
+    model_points = model_points.view(bs, 1, num_point_mesh, 3).repeat(1, num_p, 1, 1).view(bs * num_p, num_point_mesh, 3)
+    target = target.view(bs, 1, num_point_mesh, 3).repeat(1, num_p, 1, 1).view(bs * num_p, num_point_mesh, 3)
+    ori_target = target
+    pred_t = pred_t.contiguous().view(bs * num_p, 1, 3)
+    ori_t = pred_t
+
+    pred = torch.add(torch.bmm(model_points, base), pred_t)
+
+    if idx[0].item() in sym_list:
+        target = target[0].transpose(1, 0).contiguous().view(3, -1)
+        pred = pred.permute(2, 0, 1).contiguous().view(3, -1)
+        inds = knn(target.unsqueeze(0), pred.unsqueeze(0))
+        target = torch.index_select(target, 1, inds.view(-1) - 1)
+        target = target.view(3, bs * num_p, num_point_mesh).permute(1, 2, 0).contiguous()
+        pred = pred.view(3, bs * num_p, num_point_mesh).permute(1, 2, 0).contiguous()
+
+    dis = torch.mean(torch.norm((pred - target), dim=2), dim=1)
+
+    t = ori_t[0]
+    points = points.view(1, num_input_points, 3)
+
+    ori_base = ori_base[0].view(1, 3, 3).contiguous()
+    ori_t = t.repeat(bs * num_input_points, 1).contiguous().view(1, bs * num_input_points, 3)
+    new_points = torch.bmm((points - ori_t), ori_base).contiguous()
+
+    new_target = ori_target[0].view(1, num_point_mesh, 3).contiguous()
+    ori_t = t.repeat(num_point_mesh, 1).contiguous().view(1, num_point_mesh, 3)
+    new_target = torch.bmm((new_target - ori_t), ori_base).contiguous()
+
+    # print('------------> ', dis.item(), idx[0].item())
+    del knn
+    return dis, new_points.detach(), new_target.detach()
+
+
+class Loss_refine(_Loss):
+
+    def __init__(self, num_points_mesh, sym_list):
+        super(Loss_refine, self).__init__(True)
+        self.num_pt_mesh = num_points_mesh
+        self.sym_list = sym_list
+
+
+    def forward(self, pred_r, pred_t, target, model_points, idx, points):
+        return loss_calculation(pred_r, pred_t, target, model_points, idx, points, self.num_pt_mesh, self.sym_list)

lib/network.py

@@ -0,0 +1,206 @@
+import argparse
+import os
+import random
+import torch
+import torch.nn as nn
+import torch.nn.parallel
+import torch.backends.cudnn as cudnn
+import torch.optim as optim
+import torch.utils.data
+import torchvision.transforms as transforms
+import torchvision.utils as vutils
+from torch.autograd import Variable
+from PIL import Image
+import numpy as np
+import pdb
+import torch.nn.functional as F
+from lib.pspnet import PSPNet
+
+psp_models = {
+    'resnet18': lambda: PSPNet(sizes=(1, 2, 3, 6), psp_size=512, deep_features_size=256, backend='resnet18'),
+    'resnet34': lambda: PSPNet(sizes=(1, 2, 3, 6), psp_size=512, deep_features_size=256, backend='resnet34'),
+    'resnet50': lambda: PSPNet(sizes=(1, 2, 3, 6), psp_size=2048, deep_features_size=1024, backend='resnet50'),
+    'resnet101': lambda: PSPNet(sizes=(1, 2, 3, 6), psp_size=2048, deep_features_size=1024, backend='resnet101'),
+    'resnet152': lambda: PSPNet(sizes=(1, 2, 3, 6), psp_size=2048, deep_features_size=1024, backend='resnet152')
+}
+
+class ModifiedResnet(nn.Module):
+
+    def __init__(self, usegpu=True):
+        super(ModifiedResnet, self).__init__()
+
+        self.model = psp_models['resnet18'.lower()]()
+        self.model = nn.DataParallel(self.model)
+
+    def forward(self, x):
+        x = self.model(x)
+        return x
+
+class PoseNetFeat(nn.Module):
+    def __init__(self, num_points):
+        super(PoseNetFeat, self).__init__()
+        self.conv1 = torch.nn.Conv1d(3, 64, 1)
+        self.conv2 = torch.nn.Conv1d(64, 128, 1)
+
+        self.e_conv1 = torch.nn.Conv1d(32, 64, 1)
+        self.e_conv2 = torch.nn.Conv1d(64, 128, 1)
+
+        self.conv5 = torch.nn.Conv1d(256, 512, 1)
+        self.conv6 = torch.nn.Conv1d(512, 1024, 1)
+
+        self.ap1 = torch.nn.AvgPool1d(num_points)
+        self.num_points = num_points
+    def forward(self, x, emb):
+        x = F.relu(self.conv1(x))
+        emb = F.relu(self.e_conv1(emb))
+        pointfeat_1 = torch.cat((x, emb), dim=1)
+
+        x = F.relu(self.conv2(x))
+        emb = F.relu(self.e_conv2(emb))
+        pointfeat_2 = torch.cat((x, emb), dim=1)
+
+        x = F.relu(self.conv5(pointfeat_2))
+        x = F.relu(self.conv6(x))
+
+        ap_x = self.ap1(x)
+
+        ap_x = ap_x.view(-1, 1024, 1).repeat(1, 1, self.num_points)
+        return torch.cat([pointfeat_1, pointfeat_2, ap_x], 1) #128 + 256 + 1024
+
+class PoseNet(nn.Module):
+    def __init__(self, num_points, num_obj):
+        super(PoseNet, self).__init__()
+        self.num_points = num_points
+        self.cnn = ModifiedResnet()
+        self.feat = PoseNetFeat(num_points)
+        
+        self.conv1_r = torch.nn.Conv1d(1408, 640, 1)
+        self.conv1_t = torch.nn.Conv1d(1408, 640, 1)
+        self.conv1_c = torch.nn.Conv1d(1408, 640, 1)
+
+        self.conv2_r = torch.nn.Conv1d(640, 256, 1)
+        self.conv2_t = torch.nn.Conv1d(640, 256, 1)
+        self.conv2_c = torch.nn.Conv1d(640, 256, 1)
+
+        self.conv3_r = torch.nn.Conv1d(256, 128, 1)
+        self.conv3_t = torch.nn.Conv1d(256, 128, 1)
+        self.conv3_c = torch.nn.Conv1d(256, 128, 1)
+
+        self.conv4_r = torch.nn.Conv1d(128, num_obj*4, 1) #quaternion
+        self.conv4_t = torch.nn.Conv1d(128, num_obj*3, 1) #translation
+        self.conv4_c = torch.nn.Conv1d(128, num_obj*1, 1) #confidence
+
+        self.num_obj = num_obj
+
+    def forward(self, img, x, choose, obj):
+        out_img = self.cnn(img)
+        
+        bs, di, _, _ = out_img.size()
+
+        emb = out_img.view(bs, di, -1)
+        choose = choose.repeat(1, di, 1)
+        emb = torch.gather(emb, 2, choose).contiguous()
+        
+        x = x.transpose(2, 1).contiguous()
+        ap_x = self.feat(x, emb)
+
+        rx = F.relu(self.conv1_r(ap_x))
+        tx = F.relu(self.conv1_t(ap_x))
+        cx = F.relu(self.conv1_c(ap_x))      
+
+        rx = F.relu(self.conv2_r(rx))
+        tx = F.relu(self.conv2_t(tx))
+        cx = F.relu(self.conv2_c(cx))
+
+        rx = F.relu(self.conv3_r(rx))
+        tx = F.relu(self.conv3_t(tx))
+        cx = F.relu(self.conv3_c(cx))
+
+        rx = self.conv4_r(rx).view(bs, self.num_obj, 4, self.num_points)
+        tx = self.conv4_t(tx).view(bs, self.num_obj, 3, self.num_points)
+        cx = torch.sigmoid(self.conv4_c(cx)).view(bs, self.num_obj, 1, self.num_points)
+        
+        b = 0
+        out_rx = torch.index_select(rx[b], 0, obj[b])
+        out_tx = torch.index_select(tx[b], 0, obj[b])
+        out_cx = torch.index_select(cx[b], 0, obj[b])
+        
+        out_rx = out_rx.contiguous().transpose(2, 1).contiguous()
+        out_cx = out_cx.contiguous().transpose(2, 1).contiguous()
+        out_tx = out_tx.contiguous().transpose(2, 1).contiguous()
+        
+        return out_rx, out_tx, out_cx, emb.detach()
+ 
+
+
+class PoseRefineNetFeat(nn.Module):
+    def __init__(self, num_points):
+        super(PoseRefineNetFeat, self).__init__()
+        self.conv1 = torch.nn.Conv1d(3, 64, 1)
+        self.conv2 = torch.nn.Conv1d(64, 128, 1)
+
+        self.e_conv1 = torch.nn.Conv1d(32, 64, 1)
+        self.e_conv2 = torch.nn.Conv1d(64, 128, 1)
+
+        self.conv5 = torch.nn.Conv1d(384, 512, 1)
+        self.conv6 = torch.nn.Conv1d(512, 1024, 1)
+
+        self.ap1 = torch.nn.AvgPool1d(num_points)
+        self.num_points = num_points
+
+    def forward(self, x, emb):
+        x = F.relu(self.conv1(x))
+        emb = F.relu(self.e_conv1(emb))
+        pointfeat_1 = torch.cat([x, emb], dim=1)
+
+        x = F.relu(self.conv2(x))
+        emb = F.relu(self.e_conv2(emb))
+        pointfeat_2 = torch.cat([x, emb], dim=1)
+
+        pointfeat_3 = torch.cat([pointfeat_1, pointfeat_2], dim=1)
+
+        x = F.relu(self.conv5(pointfeat_3))
+        x = F.relu(self.conv6(x))
+
+        ap_x = self.ap1(x)
+
+        ap_x = ap_x.view(-1, 1024)
+        return ap_x
+
+class PoseRefineNet(nn.Module):
+    def __init__(self, num_points, num_obj):
+        super(PoseRefineNet, self).__init__()
+        self.num_points = num_points
+        self.feat = PoseRefineNetFeat(num_points)
+        
+        self.conv1_r = torch.nn.Linear(1024, 512)
+        self.conv1_t = torch.nn.Linear(1024, 512)
+
+        self.conv2_r = torch.nn.Linear(512, 128)
+        self.conv2_t = torch.nn.Linear(512, 128)
+
+        self.conv3_r = torch.nn.Linear(128, num_obj*4) #quaternion
+        self.conv3_t = torch.nn.Linear(128, num_obj*3) #translation
+
+        self.num_obj = num_obj
+
+    def forward(self, x, emb, obj):
+        bs = x.size()[0]
+        
+        x = x.transpose(2, 1).contiguous()
+        ap_x = self.feat(x, emb)
+
+        rx = F.relu(self.conv1_r(ap_x))
+        tx = F.relu(self.conv1_t(ap_x))   
+
+        rx = F.relu(self.conv2_r(rx))
+        tx = F.relu(self.conv2_t(tx))
+
+        rx = self.conv3_r(rx).view(bs, self.num_obj, 4)
+        tx = self.conv3_t(tx).view(bs, self.num_obj, 3)
+
+        b = 0
+        out_rx = torch.index_select(rx[b], 0, obj[b])
+        out_tx = torch.index_select(tx[b], 0, obj[b])
+
+        return out_rx, out_tx

lib/pspnet.py

@@ -0,0 +1,77 @@
+import torch
+from torch import nn
+from torch.nn import functional as F
+import lib.extractors as extractors
+
+
+class PSPModule(nn.Module):
+    def __init__(self, features, out_features=1024, sizes=(1, 2, 3, 6)):
+        super(PSPModule, self).__init__()
+        self.stages = []
+        self.stages = nn.ModuleList([self._make_stage(features, size) for size in sizes])
+        self.bottleneck = nn.Conv2d(features * (len(sizes) + 1), out_features, kernel_size=1)
+        self.relu = nn.ReLU()
+
+    def _make_stage(self, features, size):
+        prior = nn.AdaptiveAvgPool2d(output_size=(size, size))
+        conv = nn.Conv2d(features, features, kernel_size=1, bias=False)
+        return nn.Sequential(prior, conv)
+
+    def forward(self, feats):
+        h, w = feats.size(2), feats.size(3)
+        priors = [F.upsample(input=stage(feats), size=(h, w), mode='bilinear') for stage in self.stages] + [feats]
+        bottle = self.bottleneck(torch.cat(priors, 1))
+        return self.relu(bottle)
+
+
+class PSPUpsample(nn.Module):
+    def __init__(self, in_channels, out_channels):
+        super(PSPUpsample, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True),
+            nn.Conv2d(in_channels, out_channels, 3, padding=1),
+            nn.PReLU()
+        )
+
+    def forward(self, x):
+        return self.conv(x)
+
+
+class PSPNet(nn.Module):
+    def __init__(self, n_classes=21, sizes=(1, 2, 3, 6), psp_size=2048, deep_features_size=1024, backend='resnet18',
+                 pretrained=False):
+        super(PSPNet, self).__init__()
+        self.feats = getattr(extractors, backend)(pretrained)
+        self.psp = PSPModule(psp_size, 1024, sizes)
+        self.drop_1 = nn.Dropout2d(p=0.3)
+
+        self.up_1 = PSPUpsample(1024, 256)
+        self.up_2 = PSPUpsample(256, 64)
+        self.up_3 = PSPUpsample(64, 64)
+
+        self.drop_2 = nn.Dropout2d(p=0.15)
+        self.final = nn.Sequential(
+            nn.Conv2d(64, 32, kernel_size=1),
+            nn.LogSoftmax()
+        )
+
+        self.classifier = nn.Sequential(
+            nn.Linear(deep_features_size, 256),
+            nn.ReLU(),
+            nn.Linear(256, n_classes)
+        )
+
+    def forward(self, x):
+        f, class_f = self.feats(x) 
+        p = self.psp(f)
+        p = self.drop_1(p)
+
+        p = self.up_1(p)
+        p = self.drop_2(p)
+
+        p = self.up_2(p)
+        p = self.drop_2(p)
+
+        p = self.up_3(p)
+        
+        return self.final(p)

lib/transformations.py

@@ -0,0 +1,1935 @@
+# -*- coding: utf-8 -*-
+# transformations.py
+
+# Copyright (c) 2006-2018, Christoph Gohlke
+# Copyright (c) 2006-2018, The Regents of the University of California
+# Produced at the Laboratory for Fluorescence Dynamics
+# 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 of the copyright holders nor the names of any
+#   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 OWNER 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.
+
+"""Homogeneous Transformation Matrices and Quaternions.
+
+A library for calculating 4x4 matrices for translating, rotating, reflecting,
+scaling, shearing, projecting, orthogonalizing, and superimposing arrays of
+3D homogeneous coordinates as well as for converting between rotation matrices,
+Euler angles, and quaternions. Also includes an Arcball control object and
+functions to decompose transformation matrices.
+
+:Author:
+  `Christoph Gohlke <https://www.lfd.uci.edu/~gohlke/>`_
+
+:Organization:
+  Laboratory for Fluorescence Dynamics, University of California, Irvine
+
+:Version: 2018.02.08
+
+Requirements
+------------
+* `CPython 2.7 or 3.6 <http://www.python.org>`_
+* `Numpy 1.13 <http://www.numpy.org>`_
+* `Transformations.c 2018.02.08 <https://www.lfd.uci.edu/~gohlke/>`_
+  (recommended for speedup of some functions)
+
+Notes
+-----
+The API is not stable yet and is expected to change between revisions.
+
+This Python code is not optimized for speed. Refer to the transformations.c
+module for a faster implementation of some functions.
+
+Documentation in HTML format can be generated with epydoc.
+
+Matrices (M) can be inverted using numpy.linalg.inv(M), be concatenated using
+numpy.dot(M0, M1), or transform homogeneous coordinate arrays (v) using
+numpy.dot(M, v) for shape (4, \*) column vectors, respectively
+numpy.dot(v, M.T) for shape (\*, 4) row vectors ("array of points").
+
+This module follows the "column vectors on the right" and "row major storage"
+(C contiguous) conventions. The translation components are in the right column
+of the transformation matrix, i.e. M[:3, 3].
+The transpose of the transformation matrices may have to be used to interface
+with other graphics systems, e.g. with OpenGL's glMultMatrixd(). See also [16].
+
+Calculations are carried out with numpy.float64 precision.
+
+Vector, point, quaternion, and matrix function arguments are expected to be
+"array like", i.e. tuple, list, or numpy arrays.
+
+Return types are numpy arrays unless specified otherwise.
+
+Angles are in radians unless specified otherwise.
+
+Quaternions w+ix+jy+kz are represented as [w, x, y, z].
+
+A triple of Euler angles can be applied/interpreted in 24 ways, which can
+be specified using a 4 character string or encoded 4-tuple:
+
+  *Axes 4-string*: e.g. 'sxyz' or 'ryxy'
+
+  - first character : rotations are applied to 's'tatic or 'r'otating frame
+  - remaining characters : successive rotation axis 'x', 'y', or 'z'
+
+  *Axes 4-tuple*: e.g. (0, 0, 0, 0) or (1, 1, 1, 1)
+
+  - inner axis: code of axis ('x':0, 'y':1, 'z':2) of rightmost matrix.
+  - parity : even (0) if inner axis 'x' is followed by 'y', 'y' is followed
+    by 'z', or 'z' is followed by 'x'. Otherwise odd (1).
+  - repetition : first and last axis are same (1) or different (0).
+  - frame : rotations are applied to static (0) or rotating (1) frame.
+
+Other Python packages and modules for 3D transformations and quaternions:
+
+* `Transforms3d <https://pypi.python.org/pypi/transforms3d>`_
+   includes most code of this module.
+* `Blender.mathutils <http://www.blender.org/api/blender_python_api>`_
+* `numpy-dtypes <https://github.com/numpy/numpy-dtypes>`_
+
+References
+----------
+(1)  Matrices and transformations. Ronald Goldman.
+     In "Graphics Gems I", pp 472-475. Morgan Kaufmann, 1990.
+(2)  More matrices and transformations: shear and pseudo-perspective.
+     Ronald Goldman. In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991.
+(3)  Decomposing a matrix into simple transformations. Spencer Thomas.
+     In "Graphics Gems II", pp 320-323. Morgan Kaufmann, 1991.
+(4)  Recovering the data from the transformation matrix. Ronald Goldman.
+     In "Graphics Gems II", pp 324-331. Morgan Kaufmann, 1991.
+(5)  Euler angle conversion. Ken Shoemake.
+     In "Graphics Gems IV", pp 222-229. Morgan Kaufmann, 1994.
+(6)  Arcball rotation control. Ken Shoemake.
+     In "Graphics Gems IV", pp 175-192. Morgan Kaufmann, 1994.
+(7)  Representing attitude: Euler angles, unit quaternions, and rotation
+     vectors. James Diebel. 2006.
+(8)  A discussion of the solution for the best rotation to relate two sets
+     of vectors. W Kabsch. Acta Cryst. 1978. A34, 827-828.
+(9)  Closed-form solution of absolute orientation using unit quaternions.
+     BKP Horn. J Opt Soc Am A. 1987. 4(4):629-642.
+(10) Quaternions. Ken Shoemake.
+     http://www.sfu.ca/~jwa3/cmpt461/files/quatut.pdf
+(11) From quaternion to matrix and back. JMP van Waveren. 2005.
+     http://www.intel.com/cd/ids/developer/asmo-na/eng/293748.htm
+(12) Uniform random rotations. Ken Shoemake.
+     In "Graphics Gems III", pp 124-132. Morgan Kaufmann, 1992.
+(13) Quaternion in molecular modeling. CFF Karney.
+     J Mol Graph Mod, 25(5):595-604
+(14) New method for extracting the quaternion from a rotation matrix.
+     Itzhack Y Bar-Itzhack, J Guid Contr Dynam. 2000. 23(6): 1085-1087.
+(15) Multiple View Geometry in Computer Vision. Hartley and Zissermann.
+     Cambridge University Press; 2nd Ed. 2004. Chapter 4, Algorithm 4.7, p 130.
+(16) Column Vectors vs. Row Vectors.
+     http://steve.hollasch.net/cgindex/math/matrix/column-vec.html
+
+Examples
+--------
+>>> alpha, beta, gamma = 0.123, -1.234, 2.345
+>>> origin, xaxis, yaxis, zaxis = [0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]
+>>> I = identity_matrix()
+>>> Rx = rotation_matrix(alpha, xaxis)
+>>> Ry = rotation_matrix(beta, yaxis)
+>>> Rz = rotation_matrix(gamma, zaxis)
+>>> R = concatenate_matrices(Rx, Ry, Rz)
+>>> euler = euler_from_matrix(R, 'rxyz')
+>>> numpy.allclose([alpha, beta, gamma], euler)
+True
+>>> Re = euler_matrix(alpha, beta, gamma, 'rxyz')
+>>> is_same_transform(R, Re)
+True
+>>> al, be, ga = euler_from_matrix(Re, 'rxyz')
+>>> is_same_transform(Re, euler_matrix(al, be, ga, 'rxyz'))
+True
+>>> qx = quaternion_about_axis(alpha, xaxis)
+>>> qy = quaternion_about_axis(beta, yaxis)
+>>> qz = quaternion_about_axis(gamma, zaxis)
+>>> q = quaternion_multiply(qx, qy)
+>>> q = quaternion_multiply(q, qz)
+>>> Rq = quaternion_matrix(q)
+>>> is_same_transform(R, Rq)
+True
+>>> S = scale_matrix(1.23, origin)
+>>> T = translation_matrix([1, 2, 3])
+>>> Z = shear_matrix(beta, xaxis, origin, zaxis)
+>>> R = random_rotation_matrix(numpy.random.rand(3))
+>>> M = concatenate_matrices(T, R, Z, S)
+>>> scale, shear, angles, trans, persp = decompose_matrix(M)
+>>> numpy.allclose(scale, 1.23)
+True
+>>> numpy.allclose(trans, [1, 2, 3])
+True
+>>> numpy.allclose(shear, [0, math.tan(beta), 0])
+True
+>>> is_same_transform(R, euler_matrix(axes='sxyz', *angles))
+True
+>>> M1 = compose_matrix(scale, shear, angles, trans, persp)
+>>> is_same_transform(M, M1)
+True
+>>> v0, v1 = random_vector(3), random_vector(3)
+>>> M = rotation_matrix(angle_between_vectors(v0, v1), vector_product(v0, v1))
+>>> v2 = numpy.dot(v0, M[:3,:3].T)
+>>> numpy.allclose(unit_vector(v1), unit_vector(v2))
+True
+
+"""
+
+from __future__ import division, print_function
+
+import math
+
+import numpy
+
+__version__ = '2018.02.08'
+__docformat__ = 'restructuredtext en'
+__all__ = ()
+
+
+def identity_matrix():
+    """Return 4x4 identity/unit matrix.
+
+    >>> I = identity_matrix()
+    >>> numpy.allclose(I, numpy.dot(I, I))
+    True
+    >>> numpy.sum(I), numpy.trace(I)
+    (4.0, 4.0)
+    >>> numpy.allclose(I, numpy.identity(4))
+    True
+
+    """
+    return numpy.identity(4)
+
+
+def translation_matrix(direction):
+    """Return matrix to translate by direction vector.
+
+    >>> v = numpy.random.random(3) - 0.5
+    >>> numpy.allclose(v, translation_matrix(v)[:3, 3])
+    True
+
+    """
+    M = numpy.identity(4)
+    M[:3, 3] = direction[:3]
+    return M
+
+
+def translation_from_matrix(matrix):
+    """Return translation vector from translation matrix.
+
+    >>> v0 = numpy.random.random(3) - 0.5
+    >>> v1 = translation_from_matrix(translation_matrix(v0))
+    >>> numpy.allclose(v0, v1)
+    True
+
+    """
+    return numpy.array(matrix, copy=False)[:3, 3].copy()
+
+
+def reflection_matrix(point, normal):
+    """Return matrix to mirror at plane defined by point and normal vector.
+
+    >>> v0 = numpy.random.random(4) - 0.5
+    >>> v0[3] = 1.
+    >>> v1 = numpy.random.random(3) - 0.5
+    >>> R = reflection_matrix(v0, v1)
+    >>> numpy.allclose(2, numpy.trace(R))
+    True
+    >>> numpy.allclose(v0, numpy.dot(R, v0))
+    True
+    >>> v2 = v0.copy()
+    >>> v2[:3] += v1
+    >>> v3 = v0.copy()
+    >>> v2[:3] -= v1
+    >>> numpy.allclose(v2, numpy.dot(R, v3))
+    True
+
+    """
+    normal = unit_vector(normal[:3])
+    M = numpy.identity(4)
+    M[:3, :3] -= 2.0 * numpy.outer(normal, normal)
+    M[:3, 3] = (2.0 * numpy.dot(point[:3], normal)) * normal
+    return M
+
+
+def reflection_from_matrix(matrix):
+    """Return mirror plane point and normal vector from reflection matrix.
+
+    >>> v0 = numpy.random.random(3) - 0.5
+    >>> v1 = numpy.random.random(3) - 0.5
+    >>> M0 = reflection_matrix(v0, v1)
+    >>> point, normal = reflection_from_matrix(M0)
+    >>> M1 = reflection_matrix(point, normal)
+    >>> is_same_transform(M0, M1)
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    # normal: unit eigenvector corresponding to eigenvalue -1
+    w, V = numpy.linalg.eig(M[:3, :3])
+    i = numpy.where(abs(numpy.real(w) + 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no unit eigenvector corresponding to eigenvalue -1')
+    normal = numpy.real(V[:, i[0]]).squeeze()
+    # point: any unit eigenvector corresponding to eigenvalue 1
+    w, V = numpy.linalg.eig(M)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no unit eigenvector corresponding to eigenvalue 1')
+    point = numpy.real(V[:, i[-1]]).squeeze()
+    point /= point[3]
+    return point, normal
+
+
+def rotation_matrix(angle, direction, point=None):
+    """Return matrix to rotate about axis defined by point and direction.
+
+    >>> R = rotation_matrix(math.pi/2, [0, 0, 1], [1, 0, 0])
+    >>> numpy.allclose(numpy.dot(R, [0, 0, 0, 1]), [1, -1, 0, 1])
+    True
+    >>> angle = (random.random() - 0.5) * (2*math.pi)
+    >>> direc = numpy.random.random(3) - 0.5
+    >>> point = numpy.random.random(3) - 0.5
+    >>> R0 = rotation_matrix(angle, direc, point)
+    >>> R1 = rotation_matrix(angle-2*math.pi, direc, point)
+    >>> is_same_transform(R0, R1)
+    True
+    >>> R0 = rotation_matrix(angle, direc, point)
+    >>> R1 = rotation_matrix(-angle, -direc, point)
+    >>> is_same_transform(R0, R1)
+    True
+    >>> I = numpy.identity(4, numpy.float64)
+    >>> numpy.allclose(I, rotation_matrix(math.pi*2, direc))
+    True
+    >>> numpy.allclose(2, numpy.trace(rotation_matrix(math.pi/2,
+    ...                                               direc, point)))
+    True
+
+    """
+    sina = math.sin(angle)
+    cosa = math.cos(angle)
+    direction = unit_vector(direction[:3])
+    # rotation matrix around unit vector
+    R = numpy.diag([cosa, cosa, cosa])
+    R += numpy.outer(direction, direction) * (1.0 - cosa)
+    direction *= sina
+    R += numpy.array([[ 0.0,         -direction[2],  direction[1]],
+                      [ direction[2], 0.0,          -direction[0]],
+                      [-direction[1], direction[0],  0.0]])
+    M = numpy.identity(4)
+    M[:3, :3] = R
+    if point is not None:
+        # rotation not around origin
+        point = numpy.array(point[:3], dtype=numpy.float64, copy=False)
+        M[:3, 3] = point - numpy.dot(R, point)
+    return M
+
+
+def rotation_from_matrix(matrix):
+    """Return rotation angle and axis from rotation matrix.
+
+    >>> angle = (random.random() - 0.5) * (2*math.pi)
+    >>> direc = numpy.random.random(3) - 0.5
+    >>> point = numpy.random.random(3) - 0.5
+    >>> R0 = rotation_matrix(angle, direc, point)
+    >>> angle, direc, point = rotation_from_matrix(R0)
+    >>> R1 = rotation_matrix(angle, direc, point)
+    >>> is_same_transform(R0, R1)
+    True
+
+    """
+    R = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    R33 = R[:3, :3]
+    # direction: unit eigenvector of R33 corresponding to eigenvalue of 1
+    w, W = numpy.linalg.eig(R33.T)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no unit eigenvector corresponding to eigenvalue 1')
+    direction = numpy.real(W[:, i[-1]]).squeeze()
+    # point: unit eigenvector of R33 corresponding to eigenvalue of 1
+    w, Q = numpy.linalg.eig(R)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no unit eigenvector corresponding to eigenvalue 1')
+    point = numpy.real(Q[:, i[-1]]).squeeze()
+    point /= point[3]
+    # rotation angle depending on direction
+    cosa = (numpy.trace(R33) - 1.0) / 2.0
+    if abs(direction[2]) > 1e-8:
+        sina = (R[1, 0] + (cosa-1.0)*direction[0]*direction[1]) / direction[2]
+    elif abs(direction[1]) > 1e-8:
+        sina = (R[0, 2] + (cosa-1.0)*direction[0]*direction[2]) / direction[1]
+    else:
+        sina = (R[2, 1] + (cosa-1.0)*direction[1]*direction[2]) / direction[0]
+    angle = math.atan2(sina, cosa)
+    return angle, direction, point
+
+
+def scale_matrix(factor, origin=None, direction=None):
+    """Return matrix to scale by factor around origin in direction.
+
+    Use factor -1 for point symmetry.
+
+    >>> v = (numpy.random.rand(4, 5) - 0.5) * 20
+    >>> v[3] = 1
+    >>> S = scale_matrix(-1.234)
+    >>> numpy.allclose(numpy.dot(S, v)[:3], -1.234*v[:3])
+    True
+    >>> factor = random.random() * 10 - 5
+    >>> origin = numpy.random.random(3) - 0.5
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> S = scale_matrix(factor, origin)
+    >>> S = scale_matrix(factor, origin, direct)
+
+    """
+    if direction is None:
+        # uniform scaling
+        M = numpy.diag([factor, factor, factor, 1.0])
+        if origin is not None:
+            M[:3, 3] = origin[:3]
+            M[:3, 3] *= 1.0 - factor
+    else:
+        # nonuniform scaling
+        direction = unit_vector(direction[:3])
+        factor = 1.0 - factor
+        M = numpy.identity(4)
+        M[:3, :3] -= factor * numpy.outer(direction, direction)
+        if origin is not None:
+            M[:3, 3] = (factor * numpy.dot(origin[:3], direction)) * direction
+    return M
+
+
+def scale_from_matrix(matrix):
+    """Return scaling factor, origin and direction from scaling matrix.
+
+    >>> factor = random.random() * 10 - 5
+    >>> origin = numpy.random.random(3) - 0.5
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> S0 = scale_matrix(factor, origin)
+    >>> factor, origin, direction = scale_from_matrix(S0)
+    >>> S1 = scale_matrix(factor, origin, direction)
+    >>> is_same_transform(S0, S1)
+    True
+    >>> S0 = scale_matrix(factor, origin, direct)
+    >>> factor, origin, direction = scale_from_matrix(S0)
+    >>> S1 = scale_matrix(factor, origin, direction)
+    >>> is_same_transform(S0, S1)
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M33 = M[:3, :3]
+    factor = numpy.trace(M33) - 2.0
+    try:
+        # direction: unit eigenvector corresponding to eigenvalue factor
+        w, V = numpy.linalg.eig(M33)
+        i = numpy.where(abs(numpy.real(w) - factor) < 1e-8)[0][0]
+        direction = numpy.real(V[:, i]).squeeze()
+        direction /= vector_norm(direction)
+    except IndexError:
+        # uniform scaling
+        factor = (factor + 2.0) / 3.0
+        direction = None
+    # origin: any eigenvector corresponding to eigenvalue 1
+    w, V = numpy.linalg.eig(M)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no eigenvector corresponding to eigenvalue 1')
+    origin = numpy.real(V[:, i[-1]]).squeeze()
+    origin /= origin[3]
+    return factor, origin, direction
+
+
+def projection_matrix(point, normal, direction=None,
+                      perspective=None, pseudo=False):
+    """Return matrix to project onto plane defined by point and normal.
+
+    Using either perspective point, projection direction, or none of both.
+
+    If pseudo is True, perspective projections will preserve relative depth
+    such that Perspective = dot(Orthogonal, PseudoPerspective).
+
+    >>> P = projection_matrix([0, 0, 0], [1, 0, 0])
+    >>> numpy.allclose(P[1:, 1:], numpy.identity(4)[1:, 1:])
+    True
+    >>> point = numpy.random.random(3) - 0.5
+    >>> normal = numpy.random.random(3) - 0.5
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> persp = numpy.random.random(3) - 0.5
+    >>> P0 = projection_matrix(point, normal)
+    >>> P1 = projection_matrix(point, normal, direction=direct)
+    >>> P2 = projection_matrix(point, normal, perspective=persp)
+    >>> P3 = projection_matrix(point, normal, perspective=persp, pseudo=True)
+    >>> is_same_transform(P2, numpy.dot(P0, P3))
+    True
+    >>> P = projection_matrix([3, 0, 0], [1, 1, 0], [1, 0, 0])
+    >>> v0 = (numpy.random.rand(4, 5) - 0.5) * 20
+    >>> v0[3] = 1
+    >>> v1 = numpy.dot(P, v0)
+    >>> numpy.allclose(v1[1], v0[1])
+    True
+    >>> numpy.allclose(v1[0], 3-v1[1])
+    True
+
+    """
+    M = numpy.identity(4)
+    point = numpy.array(point[:3], dtype=numpy.float64, copy=False)
+    normal = unit_vector(normal[:3])
+    if perspective is not None:
+        # perspective projection
+        perspective = numpy.array(perspective[:3], dtype=numpy.float64,
+                                  copy=False)
+        M[0, 0] = M[1, 1] = M[2, 2] = numpy.dot(perspective-point, normal)
+        M[:3, :3] -= numpy.outer(perspective, normal)
+        if pseudo:
+            # preserve relative depth
+            M[:3, :3] -= numpy.outer(normal, normal)
+            M[:3, 3] = numpy.dot(point, normal) * (perspective+normal)
+        else:
+            M[:3, 3] = numpy.dot(point, normal) * perspective
+        M[3, :3] = -normal
+        M[3, 3] = numpy.dot(perspective, normal)
+    elif direction is not None:
+        # parallel projection
+        direction = numpy.array(direction[:3], dtype=numpy.float64, copy=False)
+        scale = numpy.dot(direction, normal)
+        M[:3, :3] -= numpy.outer(direction, normal) / scale
+        M[:3, 3] = direction * (numpy.dot(point, normal) / scale)
+    else:
+        # orthogonal projection
+        M[:3, :3] -= numpy.outer(normal, normal)
+        M[:3, 3] = numpy.dot(point, normal) * normal
+    return M
+
+
+def projection_from_matrix(matrix, pseudo=False):
+    """Return projection plane and perspective point from projection matrix.
+
+    Return values are same as arguments for projection_matrix function:
+    point, normal, direction, perspective, and pseudo.
+
+    >>> point = numpy.random.random(3) - 0.5
+    >>> normal = numpy.random.random(3) - 0.5
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> persp = numpy.random.random(3) - 0.5
+    >>> P0 = projection_matrix(point, normal)
+    >>> result = projection_from_matrix(P0)
+    >>> P1 = projection_matrix(*result)
+    >>> is_same_transform(P0, P1)
+    True
+    >>> P0 = projection_matrix(point, normal, direct)
+    >>> result = projection_from_matrix(P0)
+    >>> P1 = projection_matrix(*result)
+    >>> is_same_transform(P0, P1)
+    True
+    >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=False)
+    >>> result = projection_from_matrix(P0, pseudo=False)
+    >>> P1 = projection_matrix(*result)
+    >>> is_same_transform(P0, P1)
+    True
+    >>> P0 = projection_matrix(point, normal, perspective=persp, pseudo=True)
+    >>> result = projection_from_matrix(P0, pseudo=True)
+    >>> P1 = projection_matrix(*result)
+    >>> is_same_transform(P0, P1)
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M33 = M[:3, :3]
+    w, V = numpy.linalg.eig(M)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not pseudo and len(i):
+        # point: any eigenvector corresponding to eigenvalue 1
+        point = numpy.real(V[:, i[-1]]).squeeze()
+        point /= point[3]
+        # direction: unit eigenvector corresponding to eigenvalue 0
+        w, V = numpy.linalg.eig(M33)
+        i = numpy.where(abs(numpy.real(w)) < 1e-8)[0]
+        if not len(i):
+            raise ValueError('no eigenvector corresponding to eigenvalue 0')
+        direction = numpy.real(V[:, i[0]]).squeeze()
+        direction /= vector_norm(direction)
+        # normal: unit eigenvector of M33.T corresponding to eigenvalue 0
+        w, V = numpy.linalg.eig(M33.T)
+        i = numpy.where(abs(numpy.real(w)) < 1e-8)[0]
+        if len(i):
+            # parallel projection
+            normal = numpy.real(V[:, i[0]]).squeeze()
+            normal /= vector_norm(normal)
+            return point, normal, direction, None, False
+        else:
+            # orthogonal projection, where normal equals direction vector
+            return point, direction, None, None, False
+    else:
+        # perspective projection
+        i = numpy.where(abs(numpy.real(w)) > 1e-8)[0]
+        if not len(i):
+            raise ValueError(
+                'no eigenvector not corresponding to eigenvalue 0')
+        point = numpy.real(V[:, i[-1]]).squeeze()
+        point /= point[3]
+        normal = - M[3, :3]
+        perspective = M[:3, 3] / numpy.dot(point[:3], normal)
+        if pseudo:
+            perspective -= normal
+        return point, normal, None, perspective, pseudo
+
+
+def clip_matrix(left, right, bottom, top, near, far, perspective=False):
+    """Return matrix to obtain normalized device coordinates from frustum.
+
+    The frustum bounds are axis-aligned along x (left, right),
+    y (bottom, top) and z (near, far).
+
+    Normalized device coordinates are in range [-1, 1] if coordinates are
+    inside the frustum.
+
+    If perspective is True the frustum is a truncated pyramid with the
+    perspective point at origin and direction along z axis, otherwise an
+    orthographic canonical view volume (a box).
+
+    Homogeneous coordinates transformed by the perspective clip matrix
+    need to be dehomogenized (divided by w coordinate).
+
+    >>> frustum = numpy.random.rand(6)
+    >>> frustum[1] += frustum[0]
+    >>> frustum[3] += frustum[2]
+    >>> frustum[5] += frustum[4]
+    >>> M = clip_matrix(perspective=False, *frustum)
+    >>> numpy.dot(M, [frustum[0], frustum[2], frustum[4], 1])
+    array([-1., -1., -1.,  1.])
+    >>> numpy.dot(M, [frustum[1], frustum[3], frustum[5], 1])
+    array([ 1.,  1.,  1.,  1.])
+    >>> M = clip_matrix(perspective=True, *frustum)
+    >>> v = numpy.dot(M, [frustum[0], frustum[2], frustum[4], 1])
+    >>> v / v[3]
+    array([-1., -1., -1.,  1.])
+    >>> v = numpy.dot(M, [frustum[1], frustum[3], frustum[4], 1])
+    >>> v / v[3]
+    array([ 1.,  1., -1.,  1.])
+
+    """
+    if left >= right or bottom >= top or near >= far:
+        raise ValueError('invalid frustum')
+    if perspective:
+        if near <= _EPS:
+            raise ValueError('invalid frustum: near <= 0')
+        t = 2.0 * near
+        M = [[t/(left-right), 0.0, (right+left)/(right-left), 0.0],
+             [0.0, t/(bottom-top), (top+bottom)/(top-bottom), 0.0],
+             [0.0, 0.0, (far+near)/(near-far), t*far/(far-near)],
+             [0.0, 0.0, -1.0, 0.0]]
+    else:
+        M = [[2.0/(right-left), 0.0, 0.0, (right+left)/(left-right)],
+             [0.0, 2.0/(top-bottom), 0.0, (top+bottom)/(bottom-top)],
+             [0.0, 0.0, 2.0/(far-near), (far+near)/(near-far)],
+             [0.0, 0.0, 0.0, 1.0]]
+    return numpy.array(M)
+
+
+def shear_matrix(angle, direction, point, normal):
+    """Return matrix to shear by angle along direction vector on shear plane.
+
+    The shear plane is defined by a point and normal vector. The direction
+    vector must be orthogonal to the plane's normal vector.
+
+    A point P is transformed by the shear matrix into P" such that
+    the vector P-P" is parallel to the direction vector and its extent is
+    given by the angle of P-P'-P", where P' is the orthogonal projection
+    of P onto the shear plane.
+
+    >>> angle = (random.random() - 0.5) * 4*math.pi
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> point = numpy.random.random(3) - 0.5
+    >>> normal = numpy.cross(direct, numpy.random.random(3))
+    >>> S = shear_matrix(angle, direct, point, normal)
+    >>> numpy.allclose(1, numpy.linalg.det(S))
+    True
+
+    """
+    normal = unit_vector(normal[:3])
+    direction = unit_vector(direction[:3])
+    if abs(numpy.dot(normal, direction)) > 1e-6:
+        raise ValueError('direction and normal vectors are not orthogonal')
+    angle = math.tan(angle)
+    M = numpy.identity(4)
+    M[:3, :3] += angle * numpy.outer(direction, normal)
+    M[:3, 3] = -angle * numpy.dot(point[:3], normal) * direction
+    return M
+
+
+def shear_from_matrix(matrix):
+    """Return shear angle, direction and plane from shear matrix.
+
+    >>> angle = (random.random() - 0.5) * 4*math.pi
+    >>> direct = numpy.random.random(3) - 0.5
+    >>> point = numpy.random.random(3) - 0.5
+    >>> normal = numpy.cross(direct, numpy.random.random(3))
+    >>> S0 = shear_matrix(angle, direct, point, normal)
+    >>> angle, direct, point, normal = shear_from_matrix(S0)
+    >>> S1 = shear_matrix(angle, direct, point, normal)
+    >>> is_same_transform(S0, S1)
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)
+    M33 = M[:3, :3]
+    # normal: cross independent eigenvectors corresponding to the eigenvalue 1
+    w, V = numpy.linalg.eig(M33)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-4)[0]
+    if len(i) < 2:
+        raise ValueError('no two linear independent eigenvectors found %s' % w)
+    V = numpy.real(V[:, i]).squeeze().T
+    lenorm = -1.0
+    for i0, i1 in ((0, 1), (0, 2), (1, 2)):
+        n = numpy.cross(V[i0], V[i1])
+        w = vector_norm(n)
+        if w > lenorm:
+            lenorm = w
+            normal = n
+    normal /= lenorm
+    # direction and angle
+    direction = numpy.dot(M33 - numpy.identity(3), normal)
+    angle = vector_norm(direction)
+    direction /= angle
+    angle = math.atan(angle)
+    # point: eigenvector corresponding to eigenvalue 1
+    w, V = numpy.linalg.eig(M)
+    i = numpy.where(abs(numpy.real(w) - 1.0) < 1e-8)[0]
+    if not len(i):
+        raise ValueError('no eigenvector corresponding to eigenvalue 1')
+    point = numpy.real(V[:, i[-1]]).squeeze()
+    point /= point[3]
+    return angle, direction, point, normal
+
+
+def decompose_matrix(matrix):
+    """Return sequence of transformations from transformation matrix.
+
+    matrix : array_like
+        Non-degenerative homogeneous transformation matrix
+
+    Return tuple of:
+        scale : vector of 3 scaling factors
+        shear : list of shear factors for x-y, x-z, y-z axes
+        angles : list of Euler angles about static x, y, z axes
+        translate : translation vector along x, y, z axes
+        perspective : perspective partition of matrix
+
+    Raise ValueError if matrix is of wrong type or degenerative.
+
+    >>> T0 = translation_matrix([1, 2, 3])
+    >>> scale, shear, angles, trans, persp = decompose_matrix(T0)
+    >>> T1 = translation_matrix(trans)
+    >>> numpy.allclose(T0, T1)
+    True
+    >>> S = scale_matrix(0.123)
+    >>> scale, shear, angles, trans, persp = decompose_matrix(S)
+    >>> scale[0]
+    0.123
+    >>> R0 = euler_matrix(1, 2, 3)
+    >>> scale, shear, angles, trans, persp = decompose_matrix(R0)
+    >>> R1 = euler_matrix(*angles)
+    >>> numpy.allclose(R0, R1)
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=True).T
+    if abs(M[3, 3]) < _EPS:
+        raise ValueError('M[3, 3] is zero')
+    M /= M[3, 3]
+    P = M.copy()
+    P[:, 3] = 0.0, 0.0, 0.0, 1.0
+    if not numpy.linalg.det(P):
+        raise ValueError('matrix is singular')
+
+    scale = numpy.zeros((3, ))
+    shear = [0.0, 0.0, 0.0]
+    angles = [0.0, 0.0, 0.0]
+
+    if any(abs(M[:3, 3]) > _EPS):
+        perspective = numpy.dot(M[:, 3], numpy.linalg.inv(P.T))
+        M[:, 3] = 0.0, 0.0, 0.0, 1.0
+    else:
+        perspective = numpy.array([0.0, 0.0, 0.0, 1.0])
+
+    translate = M[3, :3].copy()
+    M[3, :3] = 0.0
+
+    row = M[:3, :3].copy()
+    scale[0] = vector_norm(row[0])
+    row[0] /= scale[0]
+    shear[0] = numpy.dot(row[0], row[1])
+    row[1] -= row[0] * shear[0]
+    scale[1] = vector_norm(row[1])
+    row[1] /= scale[1]
+    shear[0] /= scale[1]
+    shear[1] = numpy.dot(row[0], row[2])
+    row[2] -= row[0] * shear[1]
+    shear[2] = numpy.dot(row[1], row[2])
+    row[2] -= row[1] * shear[2]
+    scale[2] = vector_norm(row[2])
+    row[2] /= scale[2]
+    shear[1:] /= scale[2]
+
+    if numpy.dot(row[0], numpy.cross(row[1], row[2])) < 0:
+        numpy.negative(scale, scale)
+        numpy.negative(row, row)
+
+    angles[1] = math.asin(-row[0, 2])
+    if math.cos(angles[1]):
+        angles[0] = math.atan2(row[1, 2], row[2, 2])
+        angles[2] = math.atan2(row[0, 1], row[0, 0])
+    else:
+        # angles[0] = math.atan2(row[1, 0], row[1, 1])
+        angles[0] = math.atan2(-row[2, 1], row[1, 1])
+        angles[2] = 0.0
+
+    return scale, shear, angles, translate, perspective
+
+
+def compose_matrix(scale=None, shear=None, angles=None, translate=None,
+                   perspective=None):
+    """Return transformation matrix from sequence of transformations.
+
+    This is the inverse of the decompose_matrix function.
+
+    Sequence of transformations:
+        scale : vector of 3 scaling factors
+        shear : list of shear factors for x-y, x-z, y-z axes
+        angles : list of Euler angles about static x, y, z axes
+        translate : translation vector along x, y, z axes
+        perspective : perspective partition of matrix
+
+    >>> scale = numpy.random.random(3) - 0.5
+    >>> shear = numpy.random.random(3) - 0.5
+    >>> angles = (numpy.random.random(3) - 0.5) * (2*math.pi)
+    >>> trans = numpy.random.random(3) - 0.5
+    >>> persp = numpy.random.random(4) - 0.5
+    >>> M0 = compose_matrix(scale, shear, angles, trans, persp)
+    >>> result = decompose_matrix(M0)
+    >>> M1 = compose_matrix(*result)
+    >>> is_same_transform(M0, M1)
+    True
+
+    """
+    M = numpy.identity(4)
+    if perspective is not None:
+        P = numpy.identity(4)
+        P[3, :] = perspective[:4]
+        M = numpy.dot(M, P)
+    if translate is not None:
+        T = numpy.identity(4)
+        T[:3, 3] = translate[:3]
+        M = numpy.dot(M, T)
+    if angles is not None:
+        R = euler_matrix(angles[0], angles[1], angles[2], 'sxyz')
+        M = numpy.dot(M, R)
+    if shear is not None:
+        Z = numpy.identity(4)
+        Z[1, 2] = shear[2]
+        Z[0, 2] = shear[1]
+        Z[0, 1] = shear[0]
+        M = numpy.dot(M, Z)
+    if scale is not None:
+        S = numpy.identity(4)
+        S[0, 0] = scale[0]
+        S[1, 1] = scale[1]
+        S[2, 2] = scale[2]
+        M = numpy.dot(M, S)
+    M /= M[3, 3]
+    return M
+
+
+def orthogonalization_matrix(lengths, angles):
+    """Return orthogonalization matrix for crystallographic cell coordinates.
+
+    Angles are expected in degrees.
+
+    The de-orthogonalization matrix is the inverse.
+
+    >>> O = orthogonalization_matrix([10, 10, 10], [90, 90, 90])
+    >>> numpy.allclose(O[:3, :3], numpy.identity(3, float) * 10)
+    True
+    >>> O = orthogonalization_matrix([9.8, 12.0, 15.5], [87.2, 80.7, 69.7])
+    >>> numpy.allclose(numpy.sum(O), 43.063229)
+    True
+
+    """
+    a, b, c = lengths
+    angles = numpy.radians(angles)
+    sina, sinb, _ = numpy.sin(angles)
+    cosa, cosb, cosg = numpy.cos(angles)
+    co = (cosa * cosb - cosg) / (sina * sinb)
+    return numpy.array([
+        [ a*sinb*math.sqrt(1.0-co*co),  0.0,    0.0, 0.0],
+        [-a*sinb*co,                    b*sina, 0.0, 0.0],
+        [ a*cosb,                       b*cosa, c,   0.0],
+        [ 0.0,                          0.0,    0.0, 1.0]])
+
+
+def affine_matrix_from_points(v0, v1, shear=True, scale=True, usesvd=True):
+    """Return affine transform matrix to register two point sets.
+
+    v0 and v1 are shape (ndims, \*) arrays of at least ndims non-homogeneous
+    coordinates, where ndims is the dimensionality of the coordinate space.
+
+    If shear is False, a similarity transformation matrix is returned.
+    If also scale is False, a rigid/Euclidean transformation matrix
+    is returned.
+
+    By default the algorithm by Hartley and Zissermann [15] is used.
+    If usesvd is True, similarity and Euclidean transformation matrices
+    are calculated by minimizing the weighted sum of squared deviations
+    (RMSD) according to the algorithm by Kabsch [8].
+    Otherwise, and if ndims is 3, the quaternion based algorithm by Horn [9]
+    is used, which is slower when using this Python implementation.
+
+    The returned matrix performs rotation, translation and uniform scaling
+    (if specified).
+
+    >>> v0 = [[0, 1031, 1031, 0], [0, 0, 1600, 1600]]
+    >>> v1 = [[675, 826, 826, 677], [55, 52, 281, 277]]
+    >>> affine_matrix_from_points(v0, v1)
+    array([[   0.14549,    0.00062,  675.50008],
+           [   0.00048,    0.14094,   53.24971],
+           [   0.     ,    0.     ,    1.     ]])
+    >>> T = translation_matrix(numpy.random.random(3)-0.5)
+    >>> R = random_rotation_matrix(numpy.random.random(3))
+    >>> S = scale_matrix(random.random())
+    >>> M = concatenate_matrices(T, R, S)
+    >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20
+    >>> v0[3] = 1
+    >>> v1 = numpy.dot(M, v0)
+    >>> v0[:3] += numpy.random.normal(0, 1e-8, 300).reshape(3, -1)
+    >>> M = affine_matrix_from_points(v0[:3], v1[:3])
+    >>> numpy.allclose(v1, numpy.dot(M, v0))
+    True
+
+    More examples in superimposition_matrix()
+
+    """
+    v0 = numpy.array(v0, dtype=numpy.float64, copy=True)
+    v1 = numpy.array(v1, dtype=numpy.float64, copy=True)
+
+    ndims = v0.shape[0]
+    if ndims < 2 or v0.shape[1] < ndims or v0.shape != v1.shape:
+        raise ValueError('input arrays are of wrong shape or type')
+
+    # move centroids to origin
+    t0 = -numpy.mean(v0, axis=1)
+    M0 = numpy.identity(ndims+1)
+    M0[:ndims, ndims] = t0
+    v0 += t0.reshape(ndims, 1)
+    t1 = -numpy.mean(v1, axis=1)
+    M1 = numpy.identity(ndims+1)
+    M1[:ndims, ndims] = t1
+    v1 += t1.reshape(ndims, 1)
+
+    if shear:
+        # Affine transformation
+        A = numpy.concatenate((v0, v1), axis=0)
+        u, s, vh = numpy.linalg.svd(A.T)
+        vh = vh[:ndims].T
+        B = vh[:ndims]
+        C = vh[ndims:2*ndims]
+        t = numpy.dot(C, numpy.linalg.pinv(B))
+        t = numpy.concatenate((t, numpy.zeros((ndims, 1))), axis=1)
+        M = numpy.vstack((t, ((0.0,)*ndims) + (1.0,)))
+    elif usesvd or ndims != 3:
+        # Rigid transformation via SVD of covariance matrix
+        u, s, vh = numpy.linalg.svd(numpy.dot(v1, v0.T))
+        # rotation matrix from SVD orthonormal bases
+        R = numpy.dot(u, vh)
+        if numpy.linalg.det(R) < 0.0:
+            # R does not constitute right handed system
+            R -= numpy.outer(u[:, ndims-1], vh[ndims-1, :]*2.0)
+            s[-1] *= -1.0
+        # homogeneous transformation matrix
+        M = numpy.identity(ndims+1)
+        M[:ndims, :ndims] = R
+    else:
+        # Rigid transformation matrix via quaternion
+        # compute symmetric matrix N
+        xx, yy, zz = numpy.sum(v0 * v1, axis=1)
+        xy, yz, zx = numpy.sum(v0 * numpy.roll(v1, -1, axis=0), axis=1)
+        xz, yx, zy = numpy.sum(v0 * numpy.roll(v1, -2, axis=0), axis=1)
+        N = [[xx+yy+zz, 0.0,      0.0,      0.0],
+             [yz-zy,    xx-yy-zz, 0.0,      0.0],
+             [zx-xz,    xy+yx,    yy-xx-zz, 0.0],
+             [xy-yx,    zx+xz,    yz+zy,    zz-xx-yy]]
+        # quaternion: eigenvector corresponding to most positive eigenvalue
+        w, V = numpy.linalg.eigh(N)
+        q = V[:, numpy.argmax(w)]
+        q /= vector_norm(q)  # unit quaternion
+        # homogeneous transformation matrix
+        M = quaternion_matrix(q)
+
+    if scale and not shear:
+        # Affine transformation; scale is ratio of RMS deviations from centroid
+        v0 *= v0
+        v1 *= v1
+        M[:ndims, :ndims] *= math.sqrt(numpy.sum(v1) / numpy.sum(v0))
+
+    # move centroids back
+    M = numpy.dot(numpy.linalg.inv(M1), numpy.dot(M, M0))
+    M /= M[ndims, ndims]
+    return M
+
+
+def superimposition_matrix(v0, v1, scale=False, usesvd=True):
+    """Return matrix to transform given 3D point set into second point set.
+
+    v0 and v1 are shape (3, \*) or (4, \*) arrays of at least 3 points.
+
+    The parameters scale and usesvd are explained in the more general
+    affine_matrix_from_points function.
+
+    The returned matrix is a similarity or Euclidean transformation matrix.
+    This function has a fast C implementation in transformations.c.
+
+    >>> v0 = numpy.random.rand(3, 10)
+    >>> M = superimposition_matrix(v0, v0)
+    >>> numpy.allclose(M, numpy.identity(4))
+    True
+    >>> R = random_rotation_matrix(numpy.random.random(3))
+    >>> v0 = [[1,0,0], [0,1,0], [0,0,1], [1,1,1]]
+    >>> v1 = numpy.dot(R, v0)
+    >>> M = superimposition_matrix(v0, v1)
+    >>> numpy.allclose(v1, numpy.dot(M, v0))
+    True
+    >>> v0 = (numpy.random.rand(4, 100) - 0.5) * 20
+    >>> v0[3] = 1
+    >>> v1 = numpy.dot(R, v0)
+    >>> M = superimposition_matrix(v0, v1)
+    >>> numpy.allclose(v1, numpy.dot(M, v0))
+    True
+    >>> S = scale_matrix(random.random())
+    >>> T = translation_matrix(numpy.random.random(3)-0.5)
+    >>> M = concatenate_matrices(T, R, S)
+    >>> v1 = numpy.dot(M, v0)
+    >>> v0[:3] += numpy.random.normal(0, 1e-9, 300).reshape(3, -1)
+    >>> M = superimposition_matrix(v0, v1, scale=True)
+    >>> numpy.allclose(v1, numpy.dot(M, v0))
+    True
+    >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False)
+    >>> numpy.allclose(v1, numpy.dot(M, v0))
+    True
+    >>> v = numpy.empty((4, 100, 3))
+    >>> v[:, :, 0] = v0
+    >>> M = superimposition_matrix(v0, v1, scale=True, usesvd=False)
+    >>> numpy.allclose(v1, numpy.dot(M, v[:, :, 0]))
+    True
+
+    """
+    v0 = numpy.array(v0, dtype=numpy.float64, copy=False)[:3]
+    v1 = numpy.array(v1, dtype=numpy.float64, copy=False)[:3]
+    return affine_matrix_from_points(v0, v1, shear=False,
+                                     scale=scale, usesvd=usesvd)
+
+
+def euler_matrix(ai, aj, ak, axes='sxyz'):
+    """Return homogeneous rotation matrix from Euler angles and axis sequence.
+
+    ai, aj, ak : Euler's roll, pitch and yaw angles
+    axes : One of 24 axis sequences as string or encoded tuple
+
+    >>> R = euler_matrix(1, 2, 3, 'syxz')
+    >>> numpy.allclose(numpy.sum(R[0]), -1.34786452)
+    True
+    >>> R = euler_matrix(1, 2, 3, (0, 1, 0, 1))
+    >>> numpy.allclose(numpy.sum(R[0]), -0.383436184)
+    True
+    >>> ai, aj, ak = (4*math.pi) * (numpy.random.random(3) - 0.5)
+    >>> for axes in _AXES2TUPLE.keys():
+    ...    R = euler_matrix(ai, aj, ak, axes)
+    >>> for axes in _TUPLE2AXES.keys():
+    ...    R = euler_matrix(ai, aj, ak, axes)
+
+    """
+    try:
+        firstaxis, parity, repetition, frame = _AXES2TUPLE[axes]
+    except (AttributeError, KeyError):
+        _TUPLE2AXES[axes]  # validation
+        firstaxis, parity, repetition, frame = axes
+
+    i = firstaxis
+    j = _NEXT_AXIS[i+parity]
+    k = _NEXT_AXIS[i-parity+1]
+
+    if frame:
+        ai, ak = ak, ai
+    if parity:
+        ai, aj, ak = -ai, -aj, -ak
+
+    si, sj, sk = math.sin(ai), math.sin(aj), math.sin(ak)
+    ci, cj, ck = math.cos(ai), math.cos(aj), math.cos(ak)
+    cc, cs = ci*ck, ci*sk
+    sc, ss = si*ck, si*sk
+
+    M = numpy.identity(4)
+    if repetition:
+        M[i, i] = cj
+        M[i, j] = sj*si
+        M[i, k] = sj*ci
+        M[j, i] = sj*sk
+        M[j, j] = -cj*ss+cc
+        M[j, k] = -cj*cs-sc
+        M[k, i] = -sj*ck
+        M[k, j] = cj*sc+cs
+        M[k, k] = cj*cc-ss
+    else:
+        M[i, i] = cj*ck
+        M[i, j] = sj*sc-cs
+        M[i, k] = sj*cc+ss
+        M[j, i] = cj*sk
+        M[j, j] = sj*ss+cc
+        M[j, k] = sj*cs-sc
+        M[k, i] = -sj
+        M[k, j] = cj*si
+        M[k, k] = cj*ci
+    return M
+
+
+def euler_from_matrix(matrix, axes='sxyz'):
+    """Return Euler angles from rotation matrix for specified axis sequence.
+
+    axes : One of 24 axis sequences as string or encoded tuple
+
+    Note that many Euler angle triplets can describe one matrix.
+
+    >>> R0 = euler_matrix(1, 2, 3, 'syxz')
+    >>> al, be, ga = euler_from_matrix(R0, 'syxz')
+    >>> R1 = euler_matrix(al, be, ga, 'syxz')
+    >>> numpy.allclose(R0, R1)
+    True
+    >>> angles = (4*math.pi) * (numpy.random.random(3) - 0.5)
+    >>> for axes in _AXES2TUPLE.keys():
+    ...    R0 = euler_matrix(axes=axes, *angles)
+    ...    R1 = euler_matrix(axes=axes, *euler_from_matrix(R0, axes))
+    ...    if not numpy.allclose(R0, R1): print(axes, "failed")
+
+    """
+    try:
+        firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]
+    except (AttributeError, KeyError):
+        _TUPLE2AXES[axes]  # validation
+        firstaxis, parity, repetition, frame = axes
+
+    i = firstaxis
+    j = _NEXT_AXIS[i+parity]
+    k = _NEXT_AXIS[i-parity+1]
+
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:3, :3]
+    if repetition:
+        sy = math.sqrt(M[i, j]*M[i, j] + M[i, k]*M[i, k])
+        if sy > _EPS:
+            ax = math.atan2( M[i, j],  M[i, k])
+            ay = math.atan2( sy,       M[i, i])
+            az = math.atan2( M[j, i], -M[k, i])
+        else:
+            ax = math.atan2(-M[j, k],  M[j, j])
+            ay = math.atan2( sy,       M[i, i])
+            az = 0.0
+    else:
+        cy = math.sqrt(M[i, i]*M[i, i] + M[j, i]*M[j, i])
+        if cy > _EPS:
+            ax = math.atan2( M[k, j],  M[k, k])
+            ay = math.atan2(-M[k, i],  cy)
+            az = math.atan2( M[j, i],  M[i, i])
+        else:
+            ax = math.atan2(-M[j, k],  M[j, j])
+            ay = math.atan2(-M[k, i],  cy)
+            az = 0.0
+
+    if parity:
+        ax, ay, az = -ax, -ay, -az
+    if frame:
+        ax, az = az, ax
+    return ax, ay, az
+
+
+def euler_from_quaternion(quaternion, axes='sxyz'):
+    """Return Euler angles from quaternion for specified axis sequence.
+
+    >>> angles = euler_from_quaternion([0.99810947, 0.06146124, 0, 0])
+    >>> numpy.allclose(angles, [0.123, 0, 0])
+    True
+
+    """
+    return euler_from_matrix(quaternion_matrix(quaternion), axes)
+
+
+def quaternion_from_euler(ai, aj, ak, axes='sxyz'):
+    """Return quaternion from Euler angles and axis sequence.
+
+    ai, aj, ak : Euler's roll, pitch and yaw angles
+    axes : One of 24 axis sequences as string or encoded tuple
+
+    >>> q = quaternion_from_euler(1, 2, 3, 'ryxz')
+    >>> numpy.allclose(q, [0.435953, 0.310622, -0.718287, 0.444435])
+    True
+
+    """
+    try:
+        firstaxis, parity, repetition, frame = _AXES2TUPLE[axes.lower()]
+    except (AttributeError, KeyError):
+        _TUPLE2AXES[axes]  # validation
+        firstaxis, parity, repetition, frame = axes
+
+    i = firstaxis + 1
+    j = _NEXT_AXIS[i+parity-1] + 1
+    k = _NEXT_AXIS[i-parity] + 1
+
+    if frame:
+        ai, ak = ak, ai
+    if parity:
+        aj = -aj
+
+    ai /= 2.0
+    aj /= 2.0
+    ak /= 2.0
+    ci = math.cos(ai)
+    si = math.sin(ai)
+    cj = math.cos(aj)
+    sj = math.sin(aj)
+    ck = math.cos(ak)
+    sk = math.sin(ak)
+    cc = ci*ck
+    cs = ci*sk
+    sc = si*ck
+    ss = si*sk
+
+    q = numpy.empty((4, ))
+    if repetition:
+        q[0] = cj*(cc - ss)
+        q[i] = cj*(cs + sc)
+        q[j] = sj*(cc + ss)
+        q[k] = sj*(cs - sc)
+    else:
+        q[0] = cj*cc + sj*ss
+        q[i] = cj*sc - sj*cs
+        q[j] = cj*ss + sj*cc
+        q[k] = cj*cs - sj*sc
+    if parity:
+        q[j] *= -1.0
+
+    return q
+
+
+def quaternion_about_axis(angle, axis):
+    """Return quaternion for rotation about axis.
+
+    >>> q = quaternion_about_axis(0.123, [1, 0, 0])
+    >>> numpy.allclose(q, [0.99810947, 0.06146124, 0, 0])
+    True
+
+    """
+    q = numpy.array([0.0, axis[0], axis[1], axis[2]])
+    qlen = vector_norm(q)
+    if qlen > _EPS:
+        q *= math.sin(angle/2.0) / qlen
+    q[0] = math.cos(angle/2.0)
+    return q
+
+
+def quaternion_matrix(quaternion):
+    """Return homogeneous rotation matrix from quaternion.
+
+    >>> M = quaternion_matrix([0.99810947, 0.06146124, 0, 0])
+    >>> numpy.allclose(M, rotation_matrix(0.123, [1, 0, 0]))
+    True
+    >>> M = quaternion_matrix([1, 0, 0, 0])
+    >>> numpy.allclose(M, numpy.identity(4))
+    True
+    >>> M = quaternion_matrix([0, 1, 0, 0])
+    >>> numpy.allclose(M, numpy.diag([1, -1, -1, 1]))
+    True
+
+    """
+    q = numpy.array(quaternion, dtype=numpy.float64, copy=True)
+    n = numpy.dot(q, q)
+    if n < _EPS:
+        return numpy.identity(4)
+    q *= math.sqrt(2.0 / n)
+    q = numpy.outer(q, q)
+    return numpy.array([
+        [1.0-q[2, 2]-q[3, 3],     q[1, 2]-q[3, 0],     q[1, 3]+q[2, 0], 0.0],
+        [    q[1, 2]+q[3, 0], 1.0-q[1, 1]-q[3, 3],     q[2, 3]-q[1, 0], 0.0],
+        [    q[1, 3]-q[2, 0],     q[2, 3]+q[1, 0], 1.0-q[1, 1]-q[2, 2], 0.0],
+        [                0.0,                 0.0,                 0.0, 1.0]])
+
+
+def quaternion_from_matrix(matrix, isprecise=False):
+    """Return quaternion from rotation matrix.
+
+    If isprecise is True, the input matrix is assumed to be a precise rotation
+    matrix and a faster algorithm is used.
+
+    >>> q = quaternion_from_matrix(numpy.identity(4), True)
+    >>> numpy.allclose(q, [1, 0, 0, 0])
+    True
+    >>> q = quaternion_from_matrix(numpy.diag([1, -1, -1, 1]))
+    >>> numpy.allclose(q, [0, 1, 0, 0]) or numpy.allclose(q, [0, -1, 0, 0])
+    True
+    >>> R = rotation_matrix(0.123, (1, 2, 3))
+    >>> q = quaternion_from_matrix(R, True)
+    >>> numpy.allclose(q, [0.9981095, 0.0164262, 0.0328524, 0.0492786])
+    True
+    >>> R = [[-0.545, 0.797, 0.260, 0], [0.733, 0.603, -0.313, 0],
+    ...      [-0.407, 0.021, -0.913, 0], [0, 0, 0, 1]]
+    >>> q = quaternion_from_matrix(R)
+    >>> numpy.allclose(q, [0.19069, 0.43736, 0.87485, -0.083611])
+    True
+    >>> R = [[0.395, 0.362, 0.843, 0], [-0.626, 0.796, -0.056, 0],
+    ...      [-0.677, -0.498, 0.529, 0], [0, 0, 0, 1]]
+    >>> q = quaternion_from_matrix(R)
+    >>> numpy.allclose(q, [0.82336615, -0.13610694, 0.46344705, -0.29792603])
+    True
+    >>> R = random_rotation_matrix()
+    >>> q = quaternion_from_matrix(R)
+    >>> is_same_transform(R, quaternion_matrix(q))
+    True
+    >>> is_same_quaternion(quaternion_from_matrix(R, isprecise=False),
+    ...                    quaternion_from_matrix(R, isprecise=True))
+    True
+    >>> R = euler_matrix(0.0, 0.0, numpy.pi/2.0)
+    >>> is_same_quaternion(quaternion_from_matrix(R, isprecise=False),
+    ...                    quaternion_from_matrix(R, isprecise=True))
+    True
+
+    """
+    M = numpy.array(matrix, dtype=numpy.float64, copy=False)[:4, :4]
+    if isprecise:
+        q = numpy.empty((4, ))
+        t = numpy.trace(M)
+        if t > M[3, 3]:
+            q[0] = t
+            q[3] = M[1, 0] - M[0, 1]
+            q[2] = M[0, 2] - M[2, 0]
+            q[1] = M[2, 1] - M[1, 2]
+        else:
+            i, j, k = 0, 1, 2
+            if M[1, 1] > M[0, 0]:
+                i, j, k = 1, 2, 0
+            if M[2, 2] > M[i, i]:
+                i, j, k = 2, 0, 1
+            t = M[i, i] - (M[j, j] + M[k, k]) + M[3, 3]
+            q[i] = t
+            q[j] = M[i, j] + M[j, i]
+            q[k] = M[k, i] + M[i, k]
+            q[3] = M[k, j] - M[j, k]
+            q = q[[3, 0, 1, 2]]
+        q *= 0.5 / math.sqrt(t * M[3, 3])
+    else:
+        m00 = M[0, 0]
+        m01 = M[0, 1]
+        m02 = M[0, 2]
+        m10 = M[1, 0]
+        m11 = M[1, 1]
+        m12 = M[1, 2]
+        m20 = M[2, 0]
+        m21 = M[2, 1]
+        m22 = M[2, 2]
+        # symmetric matrix K
+        K = numpy.array([[m00-m11-m22, 0.0,         0.0,         0.0],
+                         [m01+m10,     m11-m00-m22, 0.0,         0.0],
+                         [m02+m20,     m12+m21,     m22-m00-m11, 0.0],
+                         [m21-m12,     m02-m20,     m10-m01,     m00+m11+m22]])
+        K /= 3.0
+        # quaternion is eigenvector of K that corresponds to largest eigenvalue
+        w, V = numpy.linalg.eigh(K)
+        q = V[[3, 0, 1, 2], numpy.argmax(w)]
+    if q[0] < 0.0:
+        numpy.negative(q, q)
+    return q
+
+
+def quaternion_multiply(quaternion1, quaternion0):
+    """Return multiplication of two quaternions.
+
+    >>> q = quaternion_multiply([4, 1, -2, 3], [8, -5, 6, 7])
+    >>> numpy.allclose(q, [28, -44, -14, 48])
+    True
+
+    """
+    w0, x0, y0, z0 = quaternion0
+    w1, x1, y1, z1 = quaternion1
+    return numpy.array([
+        -x1*x0 - y1*y0 - z1*z0 + w1*w0,
+        x1*w0 + y1*z0 - z1*y0 + w1*x0,
+        -x1*z0 + y1*w0 + z1*x0 + w1*y0,
+        x1*y0 - y1*x0 + z1*w0 + w1*z0], dtype=numpy.float64)
+
+
+def quaternion_conjugate(quaternion):
+    """Return conjugate of quaternion.
+
+    >>> q0 = random_quaternion()
+    >>> q1 = quaternion_conjugate(q0)
+    >>> q1[0] == q0[0] and all(q1[1:] == -q0[1:])
+    True
+
+    """
+    q = numpy.array(quaternion, dtype=numpy.float64, copy=True)
+    numpy.negative(q[1:], q[1:])
+    return q
+
+
+def quaternion_inverse(quaternion):
+    """Return inverse of quaternion.
+
+    >>> q0 = random_quaternion()
+    >>> q1 = quaternion_inverse(q0)
+    >>> numpy.allclose(quaternion_multiply(q0, q1), [1, 0, 0, 0])
+    True
+
+    """
+    q = numpy.array(quaternion, dtype=numpy.float64, copy=True)
+    numpy.negative(q[1:], q[1:])
+    return q / numpy.dot(q, q)
+
+
+def quaternion_real(quaternion):
+    """Return real part of quaternion.
+
+    >>> quaternion_real([3, 0, 1, 2])
+    3.0
+
+    """
+    return float(quaternion[0])
+
+
+def quaternion_imag(quaternion):
+    """Return imaginary part of quaternion.
+
+    >>> quaternion_imag([3, 0, 1, 2])
+    array([ 0.,  1.,  2.])
+
+    """
+    return numpy.array(quaternion[1:4], dtype=numpy.float64, copy=True)
+
+
+def quaternion_slerp(quat0, quat1, fraction, spin=0, shortestpath=True):
+    """Return spherical linear interpolation between two quaternions.
+
+    >>> q0 = random_quaternion()
+    >>> q1 = random_quaternion()
+    >>> q = quaternion_slerp(q0, q1, 0)
+    >>> numpy.allclose(q, q0)
+    True
+    >>> q = quaternion_slerp(q0, q1, 1, 1)
+    >>> numpy.allclose(q, q1)
+    True
+    >>> q = quaternion_slerp(q0, q1, 0.5)
+    >>> angle = math.acos(numpy.dot(q0, q))
+    >>> numpy.allclose(2, math.acos(numpy.dot(q0, q1)) / angle) or \
+        numpy.allclose(2, math.acos(-numpy.dot(q0, q1)) / angle)
+    True
+
+    """
+    q0 = unit_vector(quat0[:4])
+    q1 = unit_vector(quat1[:4])
+    if fraction == 0.0:
+        return q0
+    elif fraction == 1.0:
+        return q1
+    d = numpy.dot(q0, q1)
+    if abs(abs(d) - 1.0) < _EPS:
+        return q0
+    if shortestpath and d < 0.0:
+        # invert rotation
+        d = -d
+        numpy.negative(q1, q1)
+    angle = math.acos(d) + spin * math.pi
+    if abs(angle) < _EPS:
+        return q0
+    isin = 1.0 / math.sin(angle)
+    q0 *= math.sin((1.0 - fraction) * angle) * isin
+    q1 *= math.sin(fraction * angle) * isin
+    q0 += q1
+    return q0
+
+
+def random_quaternion(rand=None):
+    """Return uniform random unit quaternion.
+
+    rand: array like or None
+        Three independent random variables that are uniformly distributed
+        between 0 and 1.
+
+    >>> q = random_quaternion()
+    >>> numpy.allclose(1, vector_norm(q))
+    True
+    >>> q = random_quaternion(numpy.random.random(3))
+    >>> len(q.shape), q.shape[0]==4
+    (1, True)
+
+    """
+    if rand is None:
+        rand = numpy.random.rand(3)
+    else:
+        assert len(rand) == 3
+    r1 = numpy.sqrt(1.0 - rand[0])
+    r2 = numpy.sqrt(rand[0])
+    pi2 = math.pi * 2.0
+    t1 = pi2 * rand[1]
+    t2 = pi2 * rand[2]
+    return numpy.array([numpy.cos(t2)*r2, numpy.sin(t1)*r1,
+                        numpy.cos(t1)*r1, numpy.sin(t2)*r2])
+
+
+def random_rotation_matrix(rand=None):
+    """Return uniform random rotation matrix.
+
+    rand: array like
+        Three independent random variables that are uniformly distributed
+        between 0 and 1 for each returned quaternion.
+
+    >>> R = random_rotation_matrix()
+    >>> numpy.allclose(numpy.dot(R.T, R), numpy.identity(4))
+    True
+
+    """
+    return quaternion_matrix(random_quaternion(rand))
+
+
+class Arcball(object):
+    """Virtual Trackball Control.
+
+    >>> ball = Arcball()
+    >>> ball = Arcball(initial=numpy.identity(4))
+    >>> ball.place([320, 320], 320)
+    >>> ball.down([500, 250])
+    >>> ball.drag([475, 275])
+    >>> R = ball.matrix()
+    >>> numpy.allclose(numpy.sum(R), 3.90583455)
+    True
+    >>> ball = Arcball(initial=[1, 0, 0, 0])
+    >>> ball.place([320, 320], 320)
+    >>> ball.setaxes([1, 1, 0], [-1, 1, 0])
+    >>> ball.constrain = True
+    >>> ball.down([400, 200])
+    >>> ball.drag([200, 400])
+    >>> R = ball.matrix()
+    >>> numpy.allclose(numpy.sum(R), 0.2055924)
+    True
+    >>> ball.next()
+
+    """
+    def __init__(self, initial=None):
+        """Initialize virtual trackball control.
+
+        initial : quaternion or rotation matrix
+
+        """
+        self._axis = None
+        self._axes = None
+        self._radius = 1.0
+        self._center = [0.0, 0.0]
+        self._vdown = numpy.array([0.0, 0.0, 1.0])
+        self._constrain = False
+        if initial is None:
+            self._qdown = numpy.array([1.0, 0.0, 0.0, 0.0])
+        else:
+            initial = numpy.array(initial, dtype=numpy.float64)
+            if initial.shape == (4, 4):
+                self._qdown = quaternion_from_matrix(initial)
+            elif initial.shape == (4, ):
+                initial /= vector_norm(initial)
+                self._qdown = initial
+            else:
+                raise ValueError("initial not a quaternion or matrix")
+        self._qnow = self._qpre = self._qdown
+
+    def place(self, center, radius):
+        """Place Arcball, e.g. when window size changes.
+
+        center : sequence[2]
+            Window coordinates of trackball center.
+        radius : float
+            Radius of trackball in window coordinates.
+
+        """
+        self._radius = float(radius)
+        self._center[0] = center[0]
+        self._center[1] = center[1]
+
+    def setaxes(self, *axes):
+        """Set axes to constrain rotations."""
+        if axes is None:
+            self._axes = None
+        else:
+            self._axes = [unit_vector(axis) for axis in axes]
+
+    @property
+    def constrain(self):
+        """Return state of constrain to axis mode."""
+        return self._constrain
+
+    @constrain.setter
+    def constrain(self, value):
+        """Set state of constrain to axis mode."""
+        self._constrain = bool(value)
+
+    def down(self, point):
+        """Set initial cursor window coordinates and pick constrain-axis."""
+        self._vdown = arcball_map_to_sphere(point, self._center, self._radius)
+        self._qdown = self._qpre = self._qnow
+        if self._constrain and self._axes is not None:
+            self._axis = arcball_nearest_axis(self._vdown, self._axes)
+            self._vdown = arcball_constrain_to_axis(self._vdown, self._axis)
+        else:
+            self._axis = None
+
+    def drag(self, point):
+        """Update current cursor window coordinates."""
+        vnow = arcball_map_to_sphere(point, self._center, self._radius)
+        if self._axis is not None:
+            vnow = arcball_constrain_to_axis(vnow, self._axis)
+        self._qpre = self._qnow
+        t = numpy.cross(self._vdown, vnow)
+        if numpy.dot(t, t) < _EPS:
+            self._qnow = self._qdown
+        else:
+            q = [numpy.dot(self._vdown, vnow), t[0], t[1], t[2]]
+            self._qnow = quaternion_multiply(q, self._qdown)
+
+    def next(self, acceleration=0.0):
+        """Continue rotation in direction of last drag."""
+        q = quaternion_slerp(self._qpre, self._qnow, 2.0+acceleration, False)
+        self._qpre, self._qnow = self._qnow, q
+
+    def matrix(self):
+        """Return homogeneous rotation matrix."""
+        return quaternion_matrix(self._qnow)
+
+
+def arcball_map_to_sphere(point, center, radius):
+    """Return unit sphere coordinates from window coordinates."""
+    v0 = (point[0] - center[0]) / radius
+    v1 = (center[1] - point[1]) / radius
+    n = v0*v0 + v1*v1
+    if n > 1.0:
+        # position outside of sphere
+        n = math.sqrt(n)
+        return numpy.array([v0/n, v1/n, 0.0])
+    else:
+        return numpy.array([v0, v1, math.sqrt(1.0 - n)])
+
+
+def arcball_constrain_to_axis(point, axis):
+    """Return sphere point perpendicular to axis."""
+    v = numpy.array(point, dtype=numpy.float64, copy=True)
+    a = numpy.array(axis, dtype=numpy.float64, copy=True)
+    v -= a * numpy.dot(a, v)  # on plane
+    n = vector_norm(v)
+    if n > _EPS:
+        if v[2] < 0.0:
+            numpy.negative(v, v)
+        v /= n
+        return v
+    if a[2] == 1.0:
+        return numpy.array([1.0, 0.0, 0.0])
+    return unit_vector([-a[1], a[0], 0.0])
+
+
+def arcball_nearest_axis(point, axes):
+    """Return axis, which arc is nearest to point."""
+    point = numpy.array(point, dtype=numpy.float64, copy=False)
+    nearest = None
+    mx = -1.0
+    for axis in axes:
+        t = numpy.dot(arcball_constrain_to_axis(point, axis), point)
+        if t > mx:
+            nearest = axis
+            mx = t
+    return nearest
+
+
+# epsilon for testing whether a number is close to zero
+_EPS = numpy.finfo(float).eps * 4.0
+
+# axis sequences for Euler angles
+_NEXT_AXIS = [1, 2, 0, 1]
+
+# map axes strings to/from tuples of inner axis, parity, repetition, frame
+_AXES2TUPLE = {
+    'sxyz': (0, 0, 0, 0), 'sxyx': (0, 0, 1, 0), 'sxzy': (0, 1, 0, 0),
+    'sxzx': (0, 1, 1, 0), 'syzx': (1, 0, 0, 0), 'syzy': (1, 0, 1, 0),
+    'syxz': (1, 1, 0, 0), 'syxy': (1, 1, 1, 0), 'szxy': (2, 0, 0, 0),
+    'szxz': (2, 0, 1, 0), 'szyx': (2, 1, 0, 0), 'szyz': (2, 1, 1, 0),
+    'rzyx': (0, 0, 0, 1), 'rxyx': (0, 0, 1, 1), 'ryzx': (0, 1, 0, 1),
+    'rxzx': (0, 1, 1, 1), 'rxzy': (1, 0, 0, 1), 'ryzy': (1, 0, 1, 1),
+    'rzxy': (1, 1, 0, 1), 'ryxy': (1, 1, 1, 1), 'ryxz': (2, 0, 0, 1),
+    'rzxz': (2, 0, 1, 1), 'rxyz': (2, 1, 0, 1), 'rzyz': (2, 1, 1, 1)}
+
+_TUPLE2AXES = dict((v, k) for k, v in _AXES2TUPLE.items())
+
+
+def vector_norm(data, axis=None, out=None):
+    """Return length, i.e. Euclidean norm, of ndarray along axis.
+
+    >>> v = numpy.random.random(3)
+    >>> n = vector_norm(v)
+    >>> numpy.allclose(n, numpy.linalg.norm(v))
+    True
+    >>> v = numpy.random.rand(6, 5, 3)
+    >>> n = vector_norm(v, axis=-1)
+    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=2)))
+    True
+    >>> n = vector_norm(v, axis=1)
+    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
+    True
+    >>> v = numpy.random.rand(5, 4, 3)
+    >>> n = numpy.empty((5, 3))
+    >>> vector_norm(v, axis=1, out=n)
+    >>> numpy.allclose(n, numpy.sqrt(numpy.sum(v*v, axis=1)))
+    True
+    >>> vector_norm([])
+    0.0
+    >>> vector_norm([1])
+    1.0
+
+    """
+    data = numpy.array(data, dtype=numpy.float64, copy=True)
+    if out is None:
+        if data.ndim == 1:
+            return math.sqrt(numpy.dot(data, data))
+        data *= data
+        out = numpy.atleast_1d(numpy.sum(data, axis=axis))
+        numpy.sqrt(out, out)
+        return out
+    else:
+        data *= data
+        numpy.sum(data, axis=axis, out=out)
+        numpy.sqrt(out, out)
+
+
+def unit_vector(data, axis=None, out=None):
+    """Return ndarray normalized by length, i.e. Euclidean norm, along axis.
+
+    >>> v0 = numpy.random.random(3)
+    >>> v1 = unit_vector(v0)
+    >>> numpy.allclose(v1, v0 / numpy.linalg.norm(v0))
+    True
+    >>> v0 = numpy.random.rand(5, 4, 3)
+    >>> v1 = unit_vector(v0, axis=-1)
+    >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=2)), 2)
+    >>> numpy.allclose(v1, v2)
+    True
+    >>> v1 = unit_vector(v0, axis=1)
+    >>> v2 = v0 / numpy.expand_dims(numpy.sqrt(numpy.sum(v0*v0, axis=1)), 1)
+    >>> numpy.allclose(v1, v2)
+    True
+    >>> v1 = numpy.empty((5, 4, 3))
+    >>> unit_vector(v0, axis=1, out=v1)
+    >>> numpy.allclose(v1, v2)
+    True
+    >>> list(unit_vector([]))
+    []
+    >>> list(unit_vector([1]))
+    [1.0]
+
+    """
+    if out is None:
+        data = numpy.array(data, dtype=numpy.float64, copy=True)
+        if data.ndim == 1:
+            data /= math.sqrt(numpy.dot(data, data))
+            return data
+    else:
+        if out is not data:
+            out[:] = numpy.array(data, copy=False)
+        data = out
+    length = numpy.atleast_1d(numpy.sum(data*data, axis))
+    numpy.sqrt(length, length)
+    if axis is not None:
+        length = numpy.expand_dims(length, axis)
+    data /= length
+    if out is None:
+        return data
+
+
+def random_vector(size):
+    """Return array of random doubles in the half-open interval [0.0, 1.0).
+
+    >>> v = random_vector(10000)
+    >>> numpy.all(v >= 0) and numpy.all(v < 1)
+    True
+    >>> v0 = random_vector(10)
+    >>> v1 = random_vector(10)
+    >>> numpy.any(v0 == v1)
+    False
+
+    """
+    return numpy.random.random(size)
+
+
+def vector_product(v0, v1, axis=0):
+    """Return vector perpendicular to vectors.
+
+    >>> v = vector_product([2, 0, 0], [0, 3, 0])
+    >>> numpy.allclose(v, [0, 0, 6])
+    True
+    >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]]
+    >>> v1 = [[3], [0], [0]]
+    >>> v = vector_product(v0, v1)
+    >>> numpy.allclose(v, [[0, 0, 0, 0], [0, 0, 6, 6], [0, -6, 0, -6]])
+    True
+    >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]]
+    >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]]
+    >>> v = vector_product(v0, v1, axis=1)
+    >>> numpy.allclose(v, [[0, 0, 6], [0, -6, 0], [6, 0, 0], [0, -6, 6]])
+    True
+
+    """
+    return numpy.cross(v0, v1, axis=axis)
+
+
+def angle_between_vectors(v0, v1, directed=True, axis=0):
+    """Return angle between vectors.
+
+    If directed is False, the input vectors are interpreted as undirected axes,
+    i.e. the maximum angle is pi/2.
+
+    >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3])
+    >>> numpy.allclose(a, math.pi)
+    True
+    >>> a = angle_between_vectors([1, -2, 3], [-1, 2, -3], directed=False)
+    >>> numpy.allclose(a, 0)
+    True
+    >>> v0 = [[2, 0, 0, 2], [0, 2, 0, 2], [0, 0, 2, 2]]
+    >>> v1 = [[3], [0], [0]]
+    >>> a = angle_between_vectors(v0, v1)
+    >>> numpy.allclose(a, [0, 1.5708, 1.5708, 0.95532])
+    True
+    >>> v0 = [[2, 0, 0], [2, 0, 0], [0, 2, 0], [2, 0, 0]]
+    >>> v1 = [[0, 3, 0], [0, 0, 3], [0, 0, 3], [3, 3, 3]]
+    >>> a = angle_between_vectors(v0, v1, axis=1)
+    >>> numpy.allclose(a, [1.5708, 1.5708, 1.5708, 0.95532])
+    True
+
+    """
+    v0 = numpy.array(v0, dtype=numpy.float64, copy=False)
+    v1 = numpy.array(v1, dtype=numpy.float64, copy=False)
+    dot = numpy.sum(v0 * v1, axis=axis)
+    dot /= vector_norm(v0, axis=axis) * vector_norm(v1, axis=axis)
+    dot = numpy.clip(dot, -1.0, 1.0)
+    return numpy.arccos(dot if directed else numpy.fabs(dot))
+
+
+def inverse_matrix(matrix):
+    """Return inverse of square transformation matrix.
+
+    >>> M0 = random_rotation_matrix()
+    >>> M1 = inverse_matrix(M0.T)
+    >>> numpy.allclose(M1, numpy.linalg.inv(M0.T))
+    True
+    >>> for size in range(1, 7):
+    ...     M0 = numpy.random.rand(size, size)
+    ...     M1 = inverse_matrix(M0)
+    ...     if not numpy.allclose(M1, numpy.linalg.inv(M0)): print(size)
+
+    """
+    return numpy.linalg.inv(matrix)
+
+
+def concatenate_matrices(*matrices):
+    """Return concatenation of series of transformation matrices.
+
+    >>> M = numpy.random.rand(16).reshape((4, 4)) - 0.5
+    >>> numpy.allclose(M, concatenate_matrices(M))
+    True
+    >>> numpy.allclose(numpy.dot(M, M.T), concatenate_matrices(M, M.T))
+    True
+
+    """
+    M = numpy.identity(4)
+    for i in matrices:
+        M = numpy.dot(M, i)
+    return M
+
+
+def is_same_transform(matrix0, matrix1):
+    """Return True if two matrices perform same transformation.
+
+    >>> is_same_transform(numpy.identity(4), numpy.identity(4))
+    True
+    >>> is_same_transform(numpy.identity(4), random_rotation_matrix())
+    False
+
+    """
+    matrix0 = numpy.array(matrix0, dtype=numpy.float64, copy=True)
+    matrix0 /= matrix0[3, 3]
+    matrix1 = numpy.array(matrix1, dtype=numpy.float64, copy=True)
+    matrix1 /= matrix1[3, 3]
+    return numpy.allclose(matrix0, matrix1)
+
+
+def is_same_quaternion(q0, q1):
+    """Return True if two quaternions are equal."""
+    q0 = numpy.array(q0)
+    q1 = numpy.array(q1)
+    return numpy.allclose(q0, q1) or numpy.allclose(q0, -q1)
+
+
+def _import_module(name, package=None, warn=True, prefix='_py_', ignore='_'):
+    """Try import all public attributes from module into global namespace.
+
+    Existing attributes with name clashes are renamed with prefix.
+    Attributes starting with underscore are ignored by default.
+
+    Return True on successful import.
+
+    """
+    import warnings
+    from importlib import import_module
+    try:
+        if not package:
+            module = import_module(name)
+        else:
+            module = import_module('.' + name, package=package)
+    except ImportError:
+        if warn:
+            warnings.warn('failed to import module %s' % name)
+    else:
+        for attr in dir(module):
+            if ignore and attr.startswith(ignore):
+                continue
+            if prefix:
+                if attr in globals():
+                    globals()[prefix + attr] = globals()[attr]
+                elif warn:
+                    warnings.warn('no Python implementation of ' + attr)
+            globals()[attr] = getattr(module, attr)
+        return True
+
+
+_import_module('_transformations')
+
+if __name__ == '__main__':
+    import doctest
+    import random  # noqa: used in doctests
+    try:
+        numpy.set_printoptions(suppress=True, precision=5, legacy='1.13')
+    except TypeError:
+        numpy.set_printoptions(suppress=True, precision=5)
+    doctest.testmod()

lib/utils.py

@@ -0,0 +1,15 @@
+import logging
+
+def setup_logger(logger_name, log_file, level=logging.INFO):
+    l = logging.getLogger(logger_name)
+    formatter = logging.Formatter('%(asctime)s : %(message)s')
+    fileHandler = logging.FileHandler(log_file, mode='w')
+    fileHandler.setFormatter(formatter)
+
+    l.setLevel(level)
+    l.addHandler(fileHandler)
+
+    streamHandler = logging.StreamHandler()
+    streamHandler.setFormatter(formatter)
+    l.addHandler(streamHandler)
+    return l

replace_ycb_toolbox/evaluate_poses_keyframe.m

@@ -0,0 +1,217 @@
+function evaluate_poses_keyframe
+
+opt = globals();
+
+% read class names
+fid = fopen('classes.txt', 'r');
+C = textscan(fid, '%s');
+object_names = C{1};
+fclose(fid);
+
+% load model points
+num_objects = numel(object_names);
+models = cell(num_objects, 1);
+for i = 1:num_objects
+    filename = fullfile(opt.root, 'models', object_names{i}, 'points.xyz');
+    disp(filename);
+    models{i} = load(filename);
+end
+
+% load the keyframe indexes
+fid = fopen('keyframe.txt', 'r');
+C = textscan(fid, '%s');
+keyframes = C{1};
+fclose(fid);
+
+% save results
+distances_sys = zeros(100000, 5);
+distances_non = zeros(100000, 5);
+errors_rotation = zeros(100000, 5); 
+errors_translation = zeros(100000, 5);
+results_seq_id = zeros(100000, 1);
+results_frame_id = zeros(100000, 1);
+results_object_id = zeros(100000, 1);
+results_cls_id = zeros(100000, 1);
+
+% for each image
+count = 0;
+for i = 1:numel(keyframes)
+    
+    % parse keyframe name
+    name = keyframes{i};
+    pos = strfind(name, '/');
+    seq_id = str2double(name(1:pos-1));
+    frame_id = str2double(name(pos+1:end));
+            
+    % load PoseCNN result
+    filename = sprintf('results_PoseCNN_RSS2018/%06d.mat', i - 1);
+    result = load(filename);
+    filename = sprintf('Densefusion_iterative_result/%04d.mat', i - 1);
+    result_my = load(filename);
+    filename = sprintf('Densefusion_wo_refine_result/%04d.mat', i - 1);
+    result_mygt = load(filename);
+
+    % load 3D coordinate regression result
+    filename = sprintf('results_3DCoordinate/%04d.mat', i - 1);
+    result_3DCoordinate = load(filename);
+
+    % load gt poses
+    filename = fullfile(opt.root, 'data', sprintf('%04d/%06d-meta.mat', seq_id, frame_id));
+    disp(filename);
+    gt = load(filename);
+
+    % for each gt poses
+    for j = 1:numel(gt.cls_indexes)
+        count = count + 1;
+        cls_index = gt.cls_indexes(j);
+        RT_gt = gt.poses(:, :, j);
+
+        results_seq_id(count) = seq_id;
+        results_frame_id(count) = frame_id;
+        results_object_id(count) = j;
+        results_cls_id(count) = cls_index;
+
+        % network result
+        roi_index = find(result.rois(:, 2) == cls_index);
+        if isempty(roi_index) == 0
+            RT = zeros(3, 4);
+
+            % pose from network
+            RT(1:3, 1:3) = quat2rotm(result_my.poses(roi_index, 1:4));
+            RT(:, 4) = result_my.poses(roi_index, 5:7);
+            distances_sys(count, 1) = adi(RT, RT_gt, models{cls_index}');
+            distances_non(count, 1) = add(RT, RT_gt, models{cls_index}');
+            errors_rotation(count, 1) = re(RT(1:3, 1:3), RT_gt(1:3, 1:3));
+            errors_translation(count, 1) = te(RT(:, 4), RT_gt(:, 4));
+
+            % pose after ICP refinement
+            RT(1:3, 1:3) = quat2rotm(result.poses_icp(roi_index, 1:4));
+            RT(:, 4) = result.poses_icp(roi_index, 5:7);
+            distances_sys(count, 2) = adi(RT, RT_gt, models{cls_index}');
+            distances_non(count, 2) = add(RT, RT_gt, models{cls_index}');
+            errors_rotation(count, 2) = re(RT(1:3, 1:3), RT_gt(1:3, 1:3));
+            errors_translation(count, 2) = te(RT(:, 4), RT_gt(:, 4));
+
+            % pose from multiview
+            RT(1:3, 1:3) = quat2rotm(result_mygt.poses(roi_index, 1:4));
+            RT(:, 4) = result_mygt.poses(roi_index, 5:7);
+            distances_sys(count, 3) = adi(RT, RT_gt, models{cls_index}');
+            distances_non(count, 3) = add(RT, RT_gt, models{cls_index}');
+            errors_rotation(count, 3) = re(RT(1:3, 1:3), RT_gt(1:3, 1:3));
+            errors_translation(count, 3) = te(RT(:, 4), RT_gt(:, 4));
+% 
+            
+%             % pose from multiview + ICP
+%             RT(1:3, 1:3) = quat2rotm(result.poses_multiview_icp(roi_index, 1:4));
+%             RT(:, 4) = result.poses_multiview_icp(roi_index, 5:7);
+%             distances_sys(count, 4) = adi(RT, RT_gt, models{cls_index}');
+%             distances_non(count, 4) = add(RT, RT_gt, models{cls_index}');
+%             errors_rotation(count, 4) = re(RT(1:3, 1:3), RT_gt(1:3, 1:3));
+%             errors_translation(count, 4) = te(RT(:, 4), RT_gt(:, 4));                    
+        else
+            distances_sys(count, 1:4) = inf;
+            distances_non(count, 1:4) = inf;
+            errors_rotation(count, 1:4) = inf;
+            errors_translation(count, 1:4) = inf;
+        end
+
+
+        % 3D Coordinate regression result
+        roi_index = find(result_3DCoordinate.rois(:, 2) == cls_index);
+        if isempty(roi_index) == 0
+            RT = zeros(3, 4);
+            RT(1:3, 1:3) = quat2rotm(result_3DCoordinate.poses(roi_index, 1:4));
+            RT(:, 4) = result_3DCoordinate.poses(roi_index, 5:7);
+            distances_sys(count, 5) = adi(RT, RT_gt, models{cls_index}');
+            distances_non(count, 5) = add(RT, RT_gt, models{cls_index}');
+            errors_rotation(count, 5) = re(RT(1:3, 1:3), RT_gt(1:3, 1:3));
+            errors_translation(count, 5) = te(RT(:, 4), RT_gt(:, 4));                    
+        else
+            distances_sys(count, 5) = inf;
+            distances_non(count, 5) = inf;
+            errors_rotation(count, 5) = inf;
+            errors_translation(count, 5) = inf;
+        end
+    end
+end
+distances_sys = distances_sys(1:count, :);
+distances_non = distances_non(1:count, :);
+errors_rotation = errors_rotation(1:count, :);
+errors_translation = errors_translation(1:count, :);
+results_seq_id = results_seq_id(1:count);
+results_frame_id = results_frame_id(1:count);
+results_object_id = results_object_id(1:count, :);
+results_cls_id = results_cls_id(1:count, :);
+save('results_keyframe.mat', 'distances_sys', 'distances_non', 'errors_rotation', 'errors_translation',...
+    'results_seq_id', 'results_frame_id', 'results_object_id', 'results_cls_id');
+
+function pts_new = transform_pts_Rt(pts, RT)
+%     """
+%     Applies a rigid transformation to 3D points.
+% 
+%     :param pts: nx3 ndarray with 3D points.
+%     :param R: 3x3 rotation matrix.
+%     :param t: 3x1 translation vector.
+%     :return: nx3 ndarray with transformed 3D points.
+%     """
+n = size(pts, 2);
+pts_new = RT * [pts; ones(1, n)];
+
+function error = add(RT_est, RT_gt, pts)
+%     """
+%     Average Distance of Model Points for objects with no indistinguishable views
+%     - by Hinterstoisser et al. (ACCV 2012).
+% 
+%     :param R_est, t_est: Estimated pose (3x3 rot. matrix and 3x1 trans. vector).
+%     :param R_gt, t_gt: GT pose (3x3 rot. matrix and 3x1 trans. vector).
+%     :param model: Object model given by a dictionary where item 'pts'
+%     is nx3 ndarray with 3D model points.
+%     :return: Error of pose_est w.r.t. pose_gt.
+%     """
+pts_est = transform_pts_Rt(pts, RT_est);
+pts_gt = transform_pts_Rt(pts, RT_gt);
+diff = pts_est - pts_gt;
+error = mean(sqrt(sum(diff.^2, 1)));
+
+function error = adi(RT_est, RT_gt, pts)
+%     """
+%     Average Distance of Model Points for objects with indistinguishable views
+%     - by Hinterstoisser et al. (ACCV 2012).
+% 
+%     :param R_est, t_est: Estimated pose (3x3 rot. matrix and 3x1 trans. vector).
+%     :param R_gt, t_gt: GT pose (3x3 rot. matrix and 3x1 trans. vector).
+%     :param model: Object model given by a dictionary where item 'pts'
+%     is nx3 ndarray with 3D model points.
+%     :return: Error of pose_est w.r.t. pose_gt.
+%     """
+pts_est = transform_pts_Rt(pts, RT_est);
+pts_gt = transform_pts_Rt(pts, RT_gt);
+
+% Calculate distances to the nearest neighbors from pts_gt to pts_est
+MdlKDT = KDTreeSearcher(pts_est');
+[~, D] = knnsearch(MdlKDT, pts_gt');
+error = mean(D);
+
+function error = re(R_est, R_gt)
+%     """
+%     Rotational Error.
+% 
+%     :param R_est: Rotational element of the estimated pose (3x1 vector).
+%     :param R_gt: Rotational element of the ground truth pose (3x1 vector).
+%     :return: Error of t_est w.r.t. t_gt.
+%     """
+
+error_cos = 0.5 * (trace(R_est * inv(R_gt)) - 1.0);
+error_cos = min(1.0, max(-1.0, error_cos));
+error = acos(error_cos);
+error = 180.0 * error / pi;
+
+function error = te(t_est, t_gt)
+% """
+% Translational Error.
+% 
+% :param t_est: Translation element of the estimated pose (3x1 vector).
+% :param t_gt: Translation element of the ground truth pose (3x1 vector).
+% :return: Error of t_est w.r.t. t_gt.
+% """
+error = norm(t_gt - t_est);

replace_ycb_toolbox/plot_accuracy_keyframe.m

@@ -0,0 +1,170 @@
+function plot_accuracy_keyframe
+
+color = {'r', 'y', 'g', 'b', 'm'};
+leng = {'iterative', 'PoseCNN+ICP', 'per-pixel', '3DCoordinate', ...
+    '3D'};
+aps = zeros(5, 1);
+lengs = cell(5, 1);
+close all;
+
+% load results
+object = load('results_keyframe.mat');
+distances_sys = object.distances_sys;
+distances_non = object.distances_non;
+rotations = object.errors_rotation;
+translations = object.errors_translation;
+cls_ids = object.results_cls_id;
+
+index_plot = [2, 3, 1, 5];
+
+% read class names
+fid = fopen('classes.txt', 'r');
+C = textscan(fid, '%s');
+classes = C{1};
+classes{end+1} = 'All 21 objects';
+fclose(fid);
+
+hf = figure('units','normalized','outerposition',[0 0 1 1]);
+font_size = 12;
+max_distance = 0.1;
+
+% for each class
+for k = 1:numel(classes)
+    index = find(cls_ids == k);
+    if isempty(index)
+        index = 1:size(distances_sys,1);
+    end
+
+    % distance symmetry
+    subplot(2, 2, 1);
+    for i = index_plot
+        D = distances_sys(index, i);
+        D(D > max_distance) = inf;
+        d = sort(D);
+        n = numel(d);
+        c = numel(d(d < 0.02));
+        accuracy = cumsum(ones(1, n)) / n;
+%         fprintf('k = %d i = %d : length %d\n',k,i,length(d));
+%         dd = find(d == d(end));
+%         ddd = find(d ~= d(end));
+%         fprintf('k = %d i = %d : length %d %d %d %d\n',k,i,length(d), length(dd), d(end), ddd(end));
+
+        plot(d, accuracy, color{i}, 'LineWidth', 4);
+        aps(i) = VOCap(d, accuracy);
+        lengs{i} = sprintf('%s(AUC:%.2f)(<2cm:%.2f)', leng{i}, aps(i)*100, (c/n)*100);
+        hold on;
+    end
+    hold off;
+    %h = legend('network', 'refine tranlation only', 'icp', 'stereo translation only', 'stereo full', '3d coordinate');
+    %set(h, 'FontSize', 16);
+    h = legend(lengs(index_plot), 'Location', 'southeast');
+    set(h, 'FontSize', font_size);
+    h = xlabel('Average distance threshold in meter (symmetry)');
+    set(h, 'FontSize', font_size);
+    h = ylabel('accuracy');
+    set(h, 'FontSize', font_size);
+    h = title(classes{k}, 'Interpreter', 'none');
+    set(h, 'FontSize', font_size);
+    xt = get(gca, 'XTick');
+    set(gca, 'FontSize', font_size)
+
+    % distance non-symmetry
+    subplot(2, 2, 2);
+    for i = index_plot
+        D = distances_non(index, i);
+        D(D > max_distance) = inf;
+        d = sort(D);
+        n = numel(d);
+        c = numel(d(d < 0.02));
+        accuracy = cumsum(ones(1, n)) / n;
+        plot(d, accuracy, color{i}, 'LineWidth', 4);
+        aps(i) = VOCap(d, accuracy);
+        lengs{i} = sprintf('%s(AUC:%.2f)(<2cm:%.2f)', leng{i}, aps(i)*100, (c/n)*100);        
+        hold on;
+    end
+    hold off;
+    %h = legend('network', 'refine tranlation only', 'icp', 'stereo translation only', 'stereo full', '3d coordinate');
+    %set(h, 'FontSize', 16);
+    h = legend(lengs(index_plot), 'Location', 'southeast');
+    set(h, 'FontSize', font_size);
+    h = xlabel('Average distance threshold in meter (non-symmetry)');
+    set(h, 'FontSize', font_size);
+    h = ylabel('accuracy');
+    set(h, 'FontSize', font_size);
+    h = title(classes{k}, 'Interpreter', 'none');
+    set(h, 'FontSize', font_size);    
+    xt = get(gca, 'XTick');
+    set(gca, 'FontSize', font_size)
+    
+    % rotation
+    subplot(2, 2, 3);
+    for i = index_plot
+        D = rotations(index, i);
+        d = sort(D);
+        n = numel(d);
+        accuracy = cumsum(ones(1, n)) / n;
+        plot(d, accuracy, color{i}, 'LineWidth', 4);
+        hold on;
+    end
+    hold off;
+    %h = legend('network', 'refine tranlation only', 'icp', 'stereo translation only', 'stereo full', '3d coordinate');
+    %set(h, 'FontSize', 16);
+    h = legend(leng(index_plot), 'Location', 'southeast');
+    set(h, 'FontSize', font_size);
+    h = xlabel('Rotation angle threshold');
+    set(h, 'FontSize', font_size);
+    h = ylabel('accuracy');
+    set(h, 'FontSize', font_size);
+    h = title(classes{k}, 'Interpreter', 'none');
+    set(h, 'FontSize', font_size);
+    xt = get(gca, 'XTick');
+    set(gca, 'FontSize', font_size)
+
+    % translation
+    subplot(2, 2, 4);
+    for i = index_plot
+        D = translations(index, i);
+        D(D > max_distance) = inf;
+        d = sort(D);
+        n = numel(d);
+        accuracy = cumsum(ones(1, n)) / n;
+        plot(d, accuracy, color{i}, 'LineWidth', 4);
+        hold on;
+    end
+    hold off;
+    h = legend(leng(index_plot), 'Location', 'southeast');
+    set(h, 'FontSize', font_size);
+    h = xlabel('Translation threshold in meter');
+    set(h, 'FontSize', font_size);
+    h = ylabel('accuracy');
+    set(h, 'FontSize', font_size);
+    h = title(classes{k}, 'Interpreter', 'none');
+    set(h, 'FontSize', font_size);
+    xt = get(gca, 'XTick');
+    set(gca, 'FontSize', font_size)
+    
+    filename = sprintf('plots/%s.png', classes{k});
+    hgexport(hf, filename, hgexport('factorystyle'), 'Format', 'png');
+end
+
+function ap = VOCap(rec, prec)
+
+index = isfinite(rec);
+rec = rec(index);
+prec = prec(index)';
+
+mrec=[0 ; rec ; 0.1];
+% disp(prec)
+% disp(end)
+% disp(length(prec))
+% if length(prec) == 0
+%     prec(1) = 1;
+% end
+% disp(prec(end))
+
+mpre=[0 ; prec ; prec(end)];
+for i = 2:numel(mpre)
+    mpre(i) = max(mpre(i), mpre(i-1));
+end
+i = find(mrec(2:end) ~= mrec(1:end-1)) + 1;
+ap = sum((mrec(i) - mrec(i-1)) .* mpre(i)) * 10;

run.sh

@@ -0,0 +1,29 @@
+#!/bin/sh
+
+# Runs a docker container with the image created by build.sh
+until nvidia-docker ps
+do
+    echo "Waiting for docker server"
+    sleep 1
+done
+
+XSOCK=/tmp/.X11-unix
+
+XAUTH=/root/.Xauthority
+
+SRC_CONTAINER=/root/dense_fusion
+SRC_HOST="$(pwd)"
+
+xhost local:root
+
+nvidia-docker run \
+    --name dense_fusion \
+    -it --rm \
+    --volume=$XSOCK:$XSOCK:rw \
+    --volume=$XAUTH:$XAUTH:rw \
+    --volume=$SRC_HOST:$SRC_CONTAINER:rw \
+    --env="XAUTHORITY=${XAUTH}" \
+    --env="DISPLAY=${DISPLAY}" \
+    --privileged -v /dev/bus/usb:/dev/bus/usb \
+    --net=host \
+    dense_fusion

tools/_init_paths.py

@@ -0,0 +1,3 @@
+import os
+import sys
+sys.path.insert(0, os.getcwd())