Copy files from datasets/ParityLab/Hand-Datasets

RHD/raw/data/RHD_v1-1.zip

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

RHD/raw/doc/README.md

@@ -0,0 +1,121 @@
+# ColorHandPose3D network
+
+![Teaser](teaser.png)
+
+ColorHandPose3D is a Convolutional Neural Network estimating 3D Hand Pose from a single RGB Image. See the [project page](https://lmb.informatik.uni-freiburg.de/projects/hand3d/) for the dataset used and additional information.
+
+
+## Usage: Forward pass
+The network ships with a minimal example, that performs a forward pass and shows the predictions.
+
+- Download [data](https://lmb.informatik.uni-freiburg.de/projects/hand3d/ColorHandPose3D_data_v3.zip) and unzip it into the projects root folder (This will create 3 folders: "data", "results" and "weights")
+- *run.py* - Will run a forward pass of the network on the provided examples
+
+You can compare your results to the content of the folder "results", which shows the predictions we get on our system.
+
+
+## Recommended system
+Recommended system (tested):
+- Ubuntu 16.04.2 (xenial)
+- Tensorflow 1.3.0 GPU build with CUDA 8.0.44 and CUDNN 5.1
+- Python 3.5.2
+
+
+Python packages used by the example provided and their recommended version:
+- tensorflow==1.3.0
+- numpy==1.13.0
+- scipy==0.18.1
+- matplotlib==1.5.3
+
+## Preprocessing for training and evaluation
+In order to use the training and evaluation scripts you need download and preprocess the datasets.
+
+### Rendered Hand Pose Dataset (RHD)
+
+- Download the dataset accompanying this publication [RHD dataset v. 1.1](https://lmb.informatik.uni-freiburg.de/resources/datasets/RenderedHandposeDataset.en.html)
+- Set the variable 'path_to_db' to where the dataset is located on your machine
+- Optionally modify 'set' variable to training or evaluation
+- Run
+
+		python3.5 create_binary_db.py
+- This will create a binary file in *./data/bin* according to how 'set' was configured
+
+### Stereo Tracking Benchmark Dataset (STB)
+- For eval3d_full.py it is necessary to get the dataset presented in Zhang et al., ‘3d Hand Pose Tracking and Estimation Using Stereo Matching’, 2016
+- After unzipping the dataset run
+
+		cd ./data/stb/
+		matlab -nodesktop -nosplash -r "create_db"
+- This will create the binary file *./data/stb/stb_evaluation.bin*
+
+
+## Network training
+We provide scripts to train HandSegNet and PoseNet on the [Rendered Hand Pose Dataset (RHD)](https://lmb.informatik.uni-freiburg.de/resources/datasets/RenderedHandposeDataset.en.html).
+In case you want to retrain the networks on new data you can adapt the code provided to your needs.
+
+The following steps guide you through training HandSegNet and PoseNet on the Rendered Hand Pose Dataset (RHD).
+
+- Make sure you followed the steps in the section 'Preprocessing'
+- Start training of HandSegNet with training_handsegnet.py
+- Start training of PoseNet with training_posenet.py
+- Set USE_RETRAINED = True on line 32 in eval2d_gt_cropped.py
+- Run eval2d_gt_cropped.py to evaluate the retrained PoseNet on RHD-e
+- Set USE_RETRAINED = True on line 31 in eval2d.py
+- Run eval2d.py to evaluate the retrained HandSegNet + PoseNet on RHD-e
+
+You should be able to obtain results that roughly match the following numbers we obtain with Tensorflow v1.3:
+
+eval2d_gt_cropped.py yields:
+
+    Evaluation results:
+    Average mean EPE: 7.630 pixels
+    Average median EPE: 3.939 pixels
+    Area under curve: 0.771
+
+
+eval2d.py yields:
+
+    Evaluation results:
+    Average mean EPE: 15.469 pixels
+    Average median EPE: 4.374 pixels
+    Area under curve: 0.715
+
+Because training itself isn't a deterministic process results will differ between runs.
+Note that these results are not listed in the paper.
+
+
+
+## Evaluation
+
+There are four scripts that evaluate different parts of the architecture:
+
+1. eval2d_gt_cropped.py: Evaluates PoseNet  on 2D keypoint localization using ground truth annoation to create hand cropped images (section 6.1, Table 1 of the paper)
+2.  eval2d.py: Evaluates HandSegNet and PoseNet on 2D keypoint localization (section 6.1, Table 1 of the paper)
+3.  eval3d.py: Evaluates different approaches on lifting 2D predictions into 3D (section 6.2.1, Table 2 of the paper)
+3.  eval3d_full.py: Evaluates our full pipeline on 3D keypoint localization from RGB (section 6.2.1, Table 2 of the paper)
+
+This provides the possibility to reproduce results from the paper that are based on the RHD dataset.
+
+
+## License and Citation
+This project is licensed under the terms of the GPL v2 license. By using the software, you are agreeing to the terms of the [license agreement](https://github.com/lmb-freiburg/hand3d/blob/master/LICENSE).
+
+
+Please cite us in your publications if it helps your research:
+
+	@InProceedings{zb2017hand,
+	  author    = {Christian Zimmermann and Thomas Brox},
+	  title     = {Learning to Estimate 3D Hand Pose from Single RGB Images},
+	  booktitle    = "IEEE International Conference on Computer Vision (ICCV)",
+	  year      = {2017},
+	  note         = "https://arxiv.org/abs/1705.01389",
+	  url          = "https://lmb.informatik.uni-freiburg.de/projects/hand3d/"
+	}
+
+
+
+## Known issues
+
+- There is an issue with the results of section 6.1, Table 1 that reports performance of 2D keypoint localization on full scale images (eval2d.py). PoseNet was trained to predict the "palm center", but the evaluation script compares to the "wrist". This results into an systematic error and therefore the reported results are significantly worse than under a correct evaluation setting. Using the correct setting during evaluation improves results approximately by 2-10% (dependent on the measure).
+- The numbers reported for the "Bottleneck" approach in Table 2 of the paper are not correct. The actual result are approx. 8 % worse.
+- There is a minor issue with the first version of RHD. There was a rounding/casting problem, which led to values of the images to be off by one every now and then compared to the version used in the paper. The difference is visually not noticable and not large, but it prevents from reaching the reported numbers exactly.

RHD/raw/doc/SOURCES.md

@@ -0,0 +1,7 @@
+# RHD 原始包来源
+
+本包复用本地此前从官方获取的完整 ZIP，未解压。官方项目：https://github.com/lmb-freiburg/hand3d 。
+
+文件：`RHD_v1-1.zip`；大小：7080690299 字节；SHA256：`e04310f19ccb0429c999efaf2a1e2a2b046f3024cada6794585a08fb92fb876f`。该摘要与本地下载回执一致，不宣称为官方独立发布的摘要。
+
+下一步：小规模真实转换与本地人工核验；本次仅准备 raw。

RHD/raw/doc/dataset_README.txt

@@ -0,0 +1,71 @@
+--------------------------
+RENDERED HAND POSE DATASET - version 1.1
+--------------------------
+
+_______
+LICENCE
+This dataset is provided for research purposes only and without any warranty. Any commercial use is prohibited. If you use the dataset or parts of it in your research, you must cite the respective paper.
+
+@InProceedings{zb2017hand,
+  author    = {Christian Zimmermann and Thomas Brox},
+  title     = {Learning to Estimate 3D Hand Pose from Single RGB Images},
+  booktitle    = "IEEE International Conference on Computer Vision (ICCV)",
+  year      = {2017},
+  note         = "https://arxiv.org/abs/1705.01389",
+  url          = "https://lmb.informatik.uni-freiburg.de/projects/hand3d/"
+}
+
+_______
+CONTENT
+
+This dataset provides 41258 training and 2728 testing samples. Each sample provides:
+	- RGB image (320x320 pixels)
+	- Depth map (320x320 pixels); See examples for how to convert the provided RGB
+	- Segmentation masks (320x320 pixels) for the following classes: background, person, three classes for each finger and one for each palm
+	- 21 Keypoints for each hand with their uv coordinates in the image frame, xyz coordinates in the world frame and an indicator if they are visible
+	- Intrinsic Camera Matrix K
+It was created with freely available character from www.mixamo.com and rendered with www.blender.org
+For more details see the aforementioned paper.
+
+Keypoints available:
+0: left wrist, 1-4: left thumb [tip to palm], 5-8: left index, ..., 17-20: left pinky,
+21: right wrist, 22-25: right thumb, ..., 38-41: right pinky
+
+Segmentation masks available:
+0: background, 1: person, 
+2-4: left thumb [tip to palm], 5-7: left index, ..., 14-16: left pinky, 17: palm, 
+18-20: right thumb, ..., right palm: 33
+
+_______
+HOW TO USE
+
+The dataset ships with minimal examples, that browse the dataset and show samples.
+There is one example for Phython and one for MATLAB users; Their functionality is identical.
+Both files are located in the root folder.
+
+_______
+STRUCTURE
+
+./ 			: Root folder
+./view_samples.m	: Script that shows basic use of the data for MATLAB
+./view_samples.py	: Script that shows basic use of the data for Python
+./evaluation/		: Contains the split used for evaluation of our algorithm
+./evaluation/anno_training.mat		: Data structure for MATLAB use containing keypoint annotations and camera matrices K
+./evaluation/anno_training.pickle	: Data structure for Python use containing keypoint annotations and camera matrices K
+./evaluation/color/	: Color images
+./evaluation/depth/	: 16bit Depth maps, where the 8 top bits are stored in red and the lower 8 bits are stored in green channel
+./evaluation/mask/	: Segmentation masks
+./training/		: Contains the split used for training of our algorithm (subfolders identical to ./evaluation/)
+
+_______
+CHANGELOG
+
+version 1.1
+  - There was a rounding/casting problem, which led to values of the images to be off by one every now and then compared to the version used in the paper. The difference is visually not noticable and not large, but it prevents from reaching the reported numbers exactly.
+  - There were two minor bugs in view_samples.m. Thank you Franziska Mueller for reporting them.
+
+_______
+CONTACT
+
+For questions about the dataset please contact Christian Zimmermann (zimmermann@cs.uni-freiburg.de)
+

RHD/raw/script/create_binary_db.py

@@ -0,0 +1,118 @@
+#
+#  ColorHandPose3DNetwork - Network for estimating 3D Hand Pose from a single RGB Image
+#  Copyright (C) 2017  Christian Zimmermann
+#
+#  This program is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 2 of the License, or
+#  (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+"""
+    Script to convert Rendered Handpose Dataset into binary files,
+    which allows for much faster reading than plain image files.
+
+    Set "path_to_db" and "set" accordingly.
+
+    In order to use this file you need to download and unzip the dataset first.
+"""
+from __future__ import print_function, unicode_literals
+
+import pickle
+import os
+import scipy.misc
+import struct
+
+# SET THIS to where RHD is located on your machine
+path_to_db = './RHD_published_v2/'
+
+# chose if you want to create a binary for training or evaluation set
+# set = 'training'
+set = 'evaluation'
+
+### No more changes below this line ###
+
+
+# function to write the binary file
+def write_to_binary(file_handle, image, mask, kp_coord_xyz, kp_coord_uv, kp_visible, K_mat):
+    """" Writes records to an open binary file. """
+    bytes_written = 0
+    # 1. write kp_coord_xyz
+    for coord in kp_coord_xyz:
+        file_handle.write(struct.pack('f', coord[0]))
+        file_handle.write(struct.pack('f', coord[1]))
+        file_handle.write(struct.pack('f', coord[2]))
+    bytes_written += 4*kp_coord_xyz.shape[0]*kp_coord_xyz.shape[1]
+
+    # 2. write kp_coord_uv
+    for coord in kp_coord_uv:
+        file_handle.write(struct.pack('f', coord[0]))
+        file_handle.write(struct.pack('f', coord[1]))
+    bytes_written += 4*kp_coord_uv.shape[0]*kp_coord_uv.shape[1]
+
+    # 3. write camera intrinsic matrix
+    for K_row in K_mat:
+        for K_element in K_row:
+            file_handle.write(struct.pack('f', K_element))
+    bytes_written += 4*9
+
+    file_handle.write(struct.pack('B', 255))
+    file_handle.write(struct.pack('B', 255))
+    bytes_written += 2
+
+    # 4. write image
+    for x in range(image.shape[0]):
+        for y in range(image.shape[1]):
+            file_handle.write(struct.pack('B', image[x, y, 0]))
+            file_handle.write(struct.pack('B', image[x, y, 1]))
+            file_handle.write(struct.pack('B', image[x, y, 2]))
+    bytes_written += 4*image.shape[0]*image.shape[1]*image.shape[2]
+
+    # 5. write mask
+    for x in range(mask.shape[0]):
+        for y in range(mask.shape[1]):
+            file_handle.write(struct.pack('B', mask[x, y]))
+    bytes_written += 4*mask.shape[0]*mask.shape[1]
+
+    # 6. write visibility
+    for x in range(kp_visible.shape[0]):
+        file_handle.write(struct.pack('B', kp_visible[x]))
+    bytes_written += kp_visible.shape[0]
+
+    # print('bytes_written', bytes_written)
+
+# binary file we will write
+file_name_out = './data/bin/rhd_%s.bin' % set
+
+if not os.path.exists('./data/bin'):
+    os.mkdir('./data/bin')
+
+# load annotations of this set
+with open(os.path.join(path_to_db, set, 'anno_%s.pickle' % set), 'rb') as fi:
+    anno_all = pickle.load(fi)
+
+# iterate samples of the set and write to binary file
+with open(file_name_out, 'wb') as fo:
+    num_samples = len(anno_all.items())
+    for sample_id, anno in anno_all.items():
+        # load data
+        image = scipy.misc.imread(os.path.join(path_to_db, set, 'color', '%.5d.png' % sample_id))
+        mask = scipy.misc.imread(os.path.join(path_to_db, set, 'mask', '%.5d.png' % sample_id))
+
+        # get info from annotation dictionary
+        kp_coord_uv = anno['uv_vis'][:, :2]  # u, v coordinates of 42 hand keypoints, pixel
+        kp_visible = anno['uv_vis'][:, 2] == 1  # visibility of the keypoints, boolean
+        kp_coord_xyz = anno['xyz']  # x, y, z coordinates of the keypoints, in meters
+        camera_intrinsic_matrix = anno['K']  # matrix containing intrinsic parameters
+
+        write_to_binary(fo, image, mask, kp_coord_xyz, kp_coord_uv, kp_visible, camera_intrinsic_matrix)
+
+        if (sample_id % 100) == 0:
+            print('%d / %d images done: %.3f percent' % (sample_id, num_samples, sample_id*100.0/num_samples))