Add files using upload-large-folder tool

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/about.rst

@@ -0,0 +1,28 @@
+About graspnetAPI
+=================
+
+.. image:: _static/graspnetlogo1-blue.png
+
+GraspNet is an open project for general object grasping that is continuously enriched. Currently we release GraspNet-1Billion, a large-scale benchmark for general object grasping, as well as other related areas (e.g. 6D pose estimation, unseen object segmentation, etc.). graspnetAPI is a Python API that assists in loading, parsing and visualizing the annotations in GraspNet. Please visit graspnet website_ for more information on GraspNet, including for the data, paper, and tutorials. The exact format of the annotations is also described on the GraspNet website. In addition to this API, please download both the GraspNet images and annotations in order to run the demo.
+
+.. _website: https://graspnet.net/
+
+
+Resources
+---------
+- Documentations_ 
+- PDF_Documentations_
+- Website_
+- Code_
+
+.. _Code: https://github.com/graspnet/graspnetapi
+
+.. _Documentations: https://graspnetapi.readthedocs.io/en/latest/
+
+.. _PDF_Documentations: https://graspnetapi.readthedocs.io/_/downloads/en/latest/pdf/
+
+.. _Website: https://graspnet.net/
+
+License
+-------
+graspnetAPI is licensed under the none commercial CC4.0 license [see https://graspnet.net/about]

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/conf.py

@@ -0,0 +1,58 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+sys.path.insert(0, os.path.abspath('../../graspnetAPI'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'graspnetAPI'
+copyright = '2021, MVIG, Shanghai Jiao Tong University'
+author = 'graspnet'
+
+# The full version, including alpha/beta/rc tags
+release = '1.2.11'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.autodoc',
+        'sphinx.ext.todo',
+        'sphinx.ext.viewcode'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = []
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+master_doc = 'index'

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_check_data.rst

@@ -0,0 +1,8 @@
+.. _example_check_data:
+
+Check Dataset Files
+===================
+
+You can check if there is any missing file in the dataset by the following code.
+
+.. literalinclude:: ../../examples/exam_check_data.py

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_convert.rst

@@ -0,0 +1,62 @@
+.. _example_vis:
+
+Convert Labels between rectangle format and 6d format
+=====================================================
+
+Get a GraspNet instance.
+
+.. literalinclude:: ../../examples/exam_convert.py
+    :lines: 4-22
+
+Convert rectangle format to 6d format
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+First, load rectangle labels from dataset.
+
+.. literalinclude:: ../../examples/exam_convert.py
+    :lines: 24-25
+
+**Convert a single RectGrasp to Grasp.**
+
+.. note:: This conversion may fail due to invalid depth information.
+
+.. literalinclude:: ../../examples/exam_convert.py
+    :lines: 27-42
+
+Before Conversion:
+
+.. image:: _static/convert_single_before.png
+
+After Conversion:
+
+.. image:: _static/convert_single_after.png
+
+**Convert RectGraspGroup to GraspGroup.**
+
+.. literalinclude:: ../../examples/exam_convert.py
+    :lines: 44-56
+
+Before Conversion:
+
+.. image:: _static/convert_rect_before.png
+
+After Conversion:
+
+.. image:: _static/convert_rect_after.png
+
+Convert 6d format to rectangle format
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. note:: Grasp to RectGrasp conversion is not applicable as only very few 6d grasp can be converted to rectangle grasp.
+
+.. literalinclude:: ../../examples/exam_convert.py
+    :lines: 58-
+
+Before Conversion:
+
+.. image:: _static/convert_6d_before.png
+
+After Conversion:
+
+.. image:: _static/convert_6d_after.png
+

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_eval.rst

@@ -0,0 +1,73 @@
+.. _example_eval:
+
+Evaluation
+==========
+
+Data Preparation
+^^^^^^^^^^^^^^^^
+
+The first step of evaluation is to prepare your own results.
+You need to run your code and generate a `GraspGroup` for each image in each scene.
+Then call the `save_npy` function of `GraspGroup` to dump the results.
+
+To generate a `GraspGroup` and save it, you can directly input a 2D numpy array for the `GraspGroup` class:
+::
+
+  gg=GraspGroup(np.array([[score_1, width_1, height_1, depth_1, rotation_matrix_1(9), translation_1(3), object_id_1],
+                          [score_2, width_2, height_2, depth_2, rotation_matrix_2(9), translation_2(3), object_id_2],
+                          ...,
+                          [score_N, width_N, height_N, depth_N, rotation_matrix_N(9), translation_N(3), object_id_N]]
+                ))
+  gg.save_npy(save_path)
+
+where your algorithm predicts N grasp poses for an image. For the `object_id`, you can simply input `0`. For the meaning of other entries, you should refer to the doc for Grasp Label Format-API Loaded Labels
+
+The file structure of dump folder should be as follows:
+
+::
+
+    |-- dump_folder
+        |-- scene_0100
+        |   |-- kinect                  
+        |   |   |
+        |   |   --- 0000.npy to 0255.npy
+        |   |    
+        |   --- realsense
+        |       |
+        |       --- 0000.npy to 0255.npy
+        |
+        |-- scene_0101
+        |
+        ...
+        |
+        --- scene_0189
+
+You can choose to generate dump files for only one camera, there will be no error for doing that.
+
+Evaluation API
+^^^^^^^^^^^^^^
+
+Get GraspNetEval instances.
+
+.. literalinclude:: ../../examples/exam_eval.py
+    :lines: 4-17
+
+Evaluate A Single Scene
+-----------------------
+
+.. literalinclude:: ../../examples/exam_eval.py
+    :lines: 19-23
+
+Evaluate All Scenes
+-------------------
+
+.. literalinclude:: ../../examples/exam_eval.py
+    :lines: 25-27
+
+Evaluate 'Seen' Split
+---------------------
+
+.. literalinclude:: ../../examples/exam_eval.py
+    :lines: 29-31
+
+

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_generate_rectangle_labels.rst

@@ -0,0 +1,26 @@
+.. _example_generate_rectangle_labels:
+
+Generating Rectangle Grasp Labels
+=================================
+
+You can generate the rectangle grasp labels by yourself.
+
+Import necessary libs:
+
+.. literalinclude:: ../../examples/exam_generate_rectangle_grasp.py
+    :lines: 4-11
+
+Setup how many processes to use in generating the labels.
+
+.. literalinclude:: ../../examples/exam_generate_rectangle_grasp.py
+    :lines: 13-15
+
+The function to generate labels.
+
+.. literalinclude:: ../../examples/exam_generate_rectangle_grasp.py
+    :lines: 17-31
+
+Run the function for each scene and camera.
+
+.. literalinclude:: ../../examples/exam_generate_rectangle_grasp.py
+    :lines: 33-52

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_loadGrasp.rst

@@ -0,0 +1,30 @@
+.. _example_loadGrasp:
+
+Loading Grasp Labels
+====================
+
+Both `6d` and `rect` format labels can be loaded.
+
+First, import relative libs.
+
+.. literalinclude:: ../../examples/exam_loadGrasp.py
+    :lines: 4-7
+
+Then, get a GraspNet instance and setup parameters.
+
+.. literalinclude:: ../../examples/exam_loadGrasp.py
+    :lines: 11-19
+
+Load GraspLabel in `6d` format and visulize the result.
+
+.. literalinclude:: ../../examples/exam_loadGrasp.py
+    :lines: 21-29
+
+.. image:: _static/6d_example.png
+
+Load GraspLabel in `rect` format and visulize the result.
+
+.. literalinclude:: ../../examples/exam_loadGrasp.py
+    :lines: 31-40
+
+.. image:: _static/rect_example.png

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_nms.rst

@@ -0,0 +1,112 @@
+.. _example_nms:
+
+Apply NMS on Grasps
+===================
+
+
+Get a GraspNet instance.
+
+.. literalinclude:: ../../examples/exam_nms.py
+    :lines: 4-19
+
+Loading and visualizing grasp lables before NMS.
+
+.. literalinclude:: ../../examples/exam_nms.py
+    :lines: 21-29
+
+::
+
+    6d grasp:
+    ----------
+    Grasp Group, Number=90332:
+    Grasp: score:0.9000000357627869, width:0.11247877031564713, height:0.019999999552965164, depth:0.029999999329447746, translation:[-0.09166837 -0.16910084  0.39480919]
+    rotation:
+    [[-0.81045675 -0.57493848  0.11227506]
+    [ 0.49874267 -0.77775514 -0.38256073]
+    [ 0.30727136 -0.25405255  0.91708326]]
+    object id:66
+    Grasp: score:0.9000000357627869, width:0.10030215978622437, height:0.019999999552965164, depth:0.019999999552965164, translation:[-0.09166837 -0.16910084  0.39480919]
+    rotation:
+    [[-0.73440629 -0.67870212  0.0033038 ]
+    [ 0.64608938 -0.70059127 -0.3028869 ]
+    [ 0.20788456 -0.22030747  0.95302087]]
+    object id:66
+    Grasp: score:0.9000000357627869, width:0.08487851172685623, height:0.019999999552965164, depth:0.019999999552965164, translation:[-0.10412319 -0.13797761  0.38312319]
+    rotation:
+    [[ 0.03316294  0.78667939 -0.61647028]
+    [-0.47164679  0.55612743  0.68430364]
+    [ 0.88116372  0.26806271  0.38947764]]
+    object id:66
+    ......
+    Grasp: score:0.9000000357627869, width:0.11909123510122299, height:0.019999999552965164, depth:0.019999999552965164, translation:[-0.05140382  0.11790846  0.48782501]
+    rotation:
+    [[-0.71453273  0.63476181 -0.2941435 ]
+    [-0.07400083  0.3495101   0.93400562]
+    [ 0.69567728  0.68914449 -0.20276351]]
+    object id:14
+    Grasp: score:0.9000000357627869, width:0.10943549126386642, height:0.019999999552965164, depth:0.019999999552965164, translation:[-0.05140382  0.11790846  0.48782501]
+    rotation:
+    [[ 0.08162415  0.4604325  -0.88393396]
+    [-0.52200603  0.77526748  0.3556262 ]
+    [ 0.84902728  0.4323912   0.30362913]]
+    object id:14
+    Grasp: score:0.9000000357627869, width:0.11654743552207947, height:0.019999999552965164, depth:0.009999999776482582, translation:[-0.05140382  0.11790846  0.48782501]
+    rotation:
+    [[-0.18380146  0.39686993 -0.89928377]
+    [-0.61254776  0.66926688  0.42055583]
+    [ 0.76876676  0.62815309  0.12008961]]
+    object id:14
+    ------------
+
+.. image:: _static/before_nms.png
+
+Apply nms to GraspGroup and visualizing the result.
+
+.. literalinclude:: ../../examples/exam_nms.py
+    :lines: 31-38
+
+::
+
+    grasp after nms:
+    ----------
+    Grasp Group, Number=358:
+    Grasp: score:1.0, width:0.11948642134666443, height:0.019999999552965164, depth:0.03999999910593033, translation:[-0.00363996  0.03692623  0.3311775 ]
+    rotation:
+    [[ 0.32641056 -0.8457799   0.42203382]
+    [-0.68102902 -0.52005678 -0.51550031]
+    [ 0.65548128 -0.11915252 -0.74575269]]
+    object id:0
+    Grasp: score:1.0, width:0.12185929715633392, height:0.019999999552965164, depth:0.009999999776482582, translation:[-0.03486454  0.08384828  0.35117128]
+    rotation:
+    [[-0.00487804 -0.8475557   0.53068405]
+    [-0.27290785 -0.50941664 -0.81609803]
+    [ 0.96202785 -0.14880882 -0.22881967]]
+    object id:0
+    Grasp: score:1.0, width:0.04842342436313629, height:0.019999999552965164, depth:0.019999999552965164, translation:[0.10816982 0.10254505 0.50272578]
+    rotation:
+    [[-0.98109186 -0.01696888 -0.19279723]
+    [-0.1817532   0.42313483  0.88765001]
+    [ 0.06651681  0.90590769 -0.41821831]]
+    object id:20
+    ......
+    Grasp: score:0.9000000357627869, width:0.006192661356180906, height:0.019999999552965164, depth:0.009999999776482582, translation:[0.0122985  0.29616502 0.53319722]
+    rotation:
+    [[-0.26423979  0.39734706  0.87880182]
+    [-0.95826042 -0.00504095 -0.28585231]
+    [-0.10915259 -0.91765451  0.38209397]]
+    object id:46
+    Grasp: score:0.9000000357627869, width:0.024634981527924538, height:0.019999999552965164, depth:0.009999999776482582, translation:[0.11430283 0.18761221 0.51991153]
+    rotation:
+    [[-0.17379239 -0.96953499  0.17262182]
+    [-0.9434278   0.11365268 -0.31149188]
+    [ 0.28238329 -0.2169912  -0.93443805]]
+    object id:70
+    Grasp: score:0.9000000357627869, width:0.03459500893950462, height:0.019999999552965164, depth:0.009999999776482582, translation:[0.02079188 0.11184558 0.50796509]
+    rotation:
+    [[ 0.38108557 -0.27480939  0.88275337]
+    [-0.92043257 -0.20266907  0.33425891]
+    [ 0.08704928 -0.93989623 -0.33017775]]
+    object id:20
+    ----------
+
+.. image:: _static/after_nms.png

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/example_vis.rst

@@ -0,0 +1,39 @@
+.. _example_vis:
+
+Visualization of Dataset
+========================
+
+
+Get a GraspNet instance.
+
+.. literalinclude:: ../../examples/exam_vis.py
+    :lines: 7-14
+
+
+Show grasp labels on a object.
+
+.. literalinclude:: ../../examples/exam_vis.py
+    :lines: 16-17
+
+.. image:: _static/vis_single.png
+
+Show 6D poses of objects in a scene.
+
+.. literalinclude:: ../../examples/exam_vis.py
+    :lines: 19-20
+
+.. image:: _static/vis_6d.png
+
+Show Rectangle grasp labels in a scene.
+
+.. literalinclude:: ../../examples/exam_vis.py
+    :lines: 22-23
+
+.. image:: _static/vis_rect.png
+
+Show 6D grasp labels in a scene.
+
+.. literalinclude:: ../../examples/exam_vis.py
+    :lines: 25-26
+
+.. image:: _static/vis_grasp.png

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/grasp_format.rst

@@ -0,0 +1,178 @@
+.. grasp_format:
+
+Grasp Label Format
+==================
+
+Raw Label Format
+----------------
+The raw label is composed of two parts, i.e. labels for all grasp candidates on each object and collision masks for each scene.
+
+
+
+Labels on Objects
+^^^^^^^^^^^^^^^^^
+The raw label on each object is a list of numpy arrays.
+
+::
+
+    >>> import numpy as np
+    >>> l = np.load('000_labels.npz') # GRASPNET_ROOT/grasp_label/000_labels.npz
+    >>> l.files
+    ['points', 'offsets', 'collision', 'scores']
+    >>> l['points'].shape
+    (3459, 3)
+    >>> l['offsets'].shape
+    (3459, 300, 12, 4, 3)
+    >>> l['collision'].shape
+    (3459, 300, 12, 4)
+    >>> l['collision'].dtype
+    dtype('bool')
+    >>> l['scores'].shape
+    (3459, 300, 12, 4)
+    >>> l['scores'][0][0][0][0]
+    -1.0
+
+- 'points' records the grasp center point coordinates in model frame.
+
+- 'offsets' records the in-plane rotation, depth and width of the gripper respectively in the last dimension.
+
+- 'collision' records the bool mask for if the grasp pose collides with the model.
+
+- 'scores' records the minimum coefficient of friction between the gripper and object to achieve a stable grasp.
+
+.. note::
+    
+    In the raw label, the **lower** score the grasp has, the **better** it is. However, -1.0 score means the grasp pose is totally not acceptable.
+
+300, 12, 4 denote view id, in-plane rotation id and depth id respectively. The views are defined here in graspnetAPI/utils/utils.py.
+
+.. literalinclude:: ../../graspnetAPI/utils/utils.py
+    :lines: 51-58
+    :linenos:
+
+Collision Masks on Each Scene
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Collision mask on each scene is a list of numpy arrays.
+
+::
+
+    >>> import numpy as np
+    >>> c = np.load('collision_labels.npz') # GRASPNET_ROOT/collision_label/scene_0000/collision_labels.npz
+    >>> c.files
+    ['arr_0', 'arr_4', 'arr_5', 'arr_2', 'arr_3', 'arr_7', 'arr_1', 'arr_8', 'arr_6']
+    >>> c['arr_0'].shape
+    (487, 300, 12, 4)
+    >>> c['arr_0'].dtype
+    dtype('bool')
+    >>> c['arr_0'][10][20][3]
+    array([ True,  True,  True,  True])
+
+'arr_i' is the collision mask for the `i` th object in the `object_id_list.txt` for each scene whose shape is (num_points, 300, 12, 4).
+num_points, 300, 12, 4 denote the number of points in the object, view id, in-plane rotation id and depth id respectively.
+
+Users can refer to :py:func:`graspnetAPI.GraspNet.loadGrasp` for more details of how to use the labels.
+
+API Loaded Labels
+-----------------
+
+Dealing with the raw labels are time-consuming and need high familiarity with graspnet.
+So the API also provides an easy access to the labels. 
+
+By calling :py:func:`graspnetAPI.GraspNet.loadGrasp`, users can get all the positive grasp labels in a scene with their parameters and scores.
+
+There are totally four kinds of data structures for loaded grasp labels: **Grasp**, **GraspGroup**, **RectGrasp** and **RectGraspGroup**.
+The internal data format of each class is a numpy array which is more efficient than the Python list.
+Their definitions are given in grasp.py
+
+Example Labels
+^^^^^^^^^^^^^^
+
+Before looking into the details, an example is given below.
+
+Loading a GraspGroup instance.
+
+.. literalinclude:: ../../examples/exam_grasp_format.py
+    :lines: 1-27
+
+Users can access elements by index or slice.
+
+.. literalinclude:: ../../examples/exam_grasp_format.py
+    :lines: 29-35
+
+Each element of GraspGroup is a Grasp instance.
+The properties of Grasp can be accessed via provided methods.
+
+.. literalinclude:: ../../examples/exam_grasp_format.py
+    :lines: 37-46
+
+RectGrasp is the class for rectangle grasps. The format is different from Grasp.
+But the provided APIs are similar.
+
+.. literalinclude:: ../../examples/exam_grasp_format.py
+    :lines: 49-65
+
+6D Grasp
+^^^^^^^^
+Actually, 17 float numbers are used to define a general 6d grasp.
+The width, height, depth, score and attached object id are also part of the definition.
+
+.. note::
+    
+    In the loaded label, the **higher** score the grasp has, the **better** it is which is different from raw labels. Actually, score = 1.1 - raw_score (which is the coefficient of friction)
+
+.. literalinclude:: ../../graspnetAPI/graspnet.py
+    :lines: 635-637
+    :emphasize-lines: 2
+
+The detailed defition of each parameter is shown in the figure.
+
+.. image:: _static/grasp_definition.png
+
+.. literalinclude:: ../../graspnetAPI/grasp.py
+    :lines: 14-36
+
+6D Grasp Group
+^^^^^^^^^^^^^^
+
+Usually, there are a lot of grasps in a scene, :py:class:`GraspGroup` is a class for these grasps.
+Compared with :py:class:`Grasp`, :py:class:`GraspGroup` contains a 2D numpy array, the additional dimension is the index for each grasp.
+
+.. literalinclude:: ../../graspnetAPI/grasp.py
+    :lines: 201-218
+
+Common operations on a list such as indexing, slicing and sorting are implemented. 
+Besides, one important function is that users can **dump** a GraspGroup into a numpy file and **load** it in another program by calling :py:func:`GraspGroup.save_npy` and :py:func:`GraspGroup.from_npy`.
+
+Rectangle Grasp
+^^^^^^^^^^^^^^^
+7 float numbers are used to define a general rectangle grasp, i.e. the center point, the open point, height, score and the attached object id.
+The detailed definition of each parameter is shown in the figure above and below and the coordinates for center point and open point are in the pixel frame.
+
+.. image:: _static/rect_grasp_definition.png
+
+.. literalinclude:: ../../graspnetAPI/grasp.py
+    :lines: 553-572
+
+Rectangle Grasp Group
+^^^^^^^^^^^^^^^^^^^^^
+
+The format for :py:class:`RectGraspGroup` is similar to that of :py:class:`RectGrasp` and :py:class:`GraspGroup`.
+
+.. literalinclude:: ../../graspnetAPI/grasp.py
+    :lines: 752-769
+
+.. note::
+
+    We recommend users to access and modify the labels by provided functions although users can also manipulate the data directly but it is **Not Recommended**.
+    Please refer to the Python API for more details.
+
+Grasp and GraspGroup Transformation
+-----------------------------------
+
+Users can transform a Grasp or GraspGroup giving a 4x4 matrix.
+
+.. literalinclude:: ../../examples/exam_grasp_format.py
+    :lines: 67-95
+
+.. image:: _static/transformation.png

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/graspnetAPI.rst

@@ -0,0 +1,46 @@
+graspnetAPI package
+===================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   graspnetAPI.utils
+
+Submodules
+----------
+
+graspnetAPI.grasp module
+------------------------
+
+.. automodule:: graspnetAPI.grasp
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.graspnet module
+---------------------------
+
+.. automodule:: graspnetAPI.graspnet
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.graspnet\_eval module
+---------------------------------
+
+.. automodule:: graspnetAPI.graspnet_eval
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: graspnetAPI
+   :members:
+   :undoc-members:
+   :show-inheritance:

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/graspnetAPI.utils.dexnet.grasping.meshpy.rst

@@ -0,0 +1,54 @@
+graspnetAPI.utils.dexnet.grasping.meshpy package
+================================================
+
+Submodules
+----------
+
+graspnetAPI.utils.dexnet.grasping.meshpy.mesh module
+----------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy.mesh
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.meshpy.obj\_file module
+---------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy.obj_file
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.meshpy.sdf module
+---------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy.sdf
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.meshpy.sdf\_file module
+---------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy.sdf_file
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.meshpy.stable\_pose module
+------------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy.stable_pose
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.meshpy
+   :members:
+   :undoc-members:
+   :show-inheritance:

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/graspnetAPI.utils.dexnet.grasping.rst

@@ -0,0 +1,70 @@
+graspnetAPI.utils.dexnet.grasping package
+=========================================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   graspnetAPI.utils.dexnet.grasping.meshpy
+
+Submodules
+----------
+
+graspnetAPI.utils.dexnet.grasping.contacts module
+-------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.contacts
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.grasp module
+----------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.grasp
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.grasp\_quality\_config module
+---------------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.grasp_quality_config
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.grasp\_quality\_function module
+-----------------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.grasp_quality_function
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.graspable\_object module
+----------------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.graspable_object
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.grasping.quality module
+------------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping.quality
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: graspnetAPI.utils.dexnet.grasping
+   :members:
+   :undoc-members:
+   :show-inheritance:

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/graspnetAPI.utils.dexnet.rst

@@ -0,0 +1,38 @@
+graspnetAPI.utils.dexnet package
+================================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   graspnetAPI.utils.dexnet.grasping
+
+Submodules
+----------
+
+graspnetAPI.utils.dexnet.abstractstatic module
+----------------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.abstractstatic
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.dexnet.constants module
+-----------------------------------------
+
+.. automodule:: graspnetAPI.utils.dexnet.constants
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: graspnetAPI.utils.dexnet
+   :members:
+   :undoc-members:
+   :show-inheritance:

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/graspnetAPI.utils.rst

@@ -0,0 +1,86 @@
+graspnetAPI.utils package
+=========================
+
+Subpackages
+-----------
+
+.. toctree::
+   :maxdepth: 4
+
+   graspnetAPI.utils.dexnet
+
+Submodules
+----------
+
+graspnetAPI.utils.config module
+-------------------------------
+
+.. automodule:: graspnetAPI.utils.config
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.eval\_utils module
+------------------------------------
+
+.. automodule:: graspnetAPI.utils.eval_utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.pose module
+-----------------------------
+
+.. automodule:: graspnetAPI.utils.pose
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.rotation module
+---------------------------------
+
+.. automodule:: graspnetAPI.utils.rotation
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.trans3d module
+--------------------------------
+
+.. automodule:: graspnetAPI.utils.trans3d
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.utils module
+------------------------------
+
+.. automodule:: graspnetAPI.utils.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.vis module
+----------------------------
+
+.. automodule:: graspnetAPI.utils.vis
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+graspnetAPI.utils.xmlhandler module
+-----------------------------------
+
+.. automodule:: graspnetAPI.utils.xmlhandler
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
+
+Module contents
+---------------
+
+.. automodule:: graspnetAPI.utils
+   :members:
+   :undoc-members:
+   :show-inheritance:

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/index.rst

@@ -0,0 +1,48 @@
+.. graspnetAPI documentation master file, created by
+   sphinx-quickstart on Tue Nov  3 13:04:51 2020.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Welcome to graspnetAPI's documentation!
+=======================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   about
+   install
+   grasp_format
+
+Examples
+=========
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Examples
+
+   example_check_data
+   example_generate_rectangle_labels
+   example_loadGrasp
+   example_vis
+   example_nms
+   example_convert
+   example_eval
+
+
+Python API
+==========
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Modules
+
+   graspnetAPI
+   graspnetAPI.utils
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/install.rst

@@ -0,0 +1,61 @@
+Installation
+============
+
+.. note::
+    
+    Only Python 3 on Linux is supported.
+
+Prerequisites
+^^^^^^^^^^^^^
+
+Python version under 3.6 is not tested. 
+
+Dataset
+^^^^^^^
+
+Download
+--------
+
+Download the dataset at https://graspnet.net/datasets.html
+
+Unzip
+-----
+
+Unzip the files as shown in https://graspnet.net/datasets.html.
+
+Rectangle Grasp Labels
+----------------------
+Rectangle grasp labels are optional if you need labels in this format.
+You can both generate the labels or download the file_. 
+
+If you want to generate the labels by yourself, you may refer to :ref:`example_generate_rectangle_labels`.
+
+.. note::
+    
+    Generating rectangle grasp labels may take a long time.
+
+After generating the labels or unzipping the labels, you need to run copy_rect_labels.py_ to copy rectangle grasp labels to corresponding folders.
+
+.. _copy_rect_labels.py: https://github.com/graspnet/graspnetAPI/blob/master/copy_rect_labels.py
+
+.. _file: https://graspnet.net/datasets.html
+
+Dexnet Model Cache
+------------------
+
+Dexnet model cache is optional without which the evaluation will be much slower(about 10x time slower).
+You can both download the file or generate it by yourself by running gen_pickle_dexmodel.py_(recommended). 
+
+.. _gen_pickle_dexmodel.py: https://github.com/graspnet/graspnetAPI/blob/master/gen_pickle_dexmodel.py
+
+Install API
+^^^^^^^^^^^
+You may install using pip::
+    
+    pip install graspnetAPI
+
+You can also install from source::
+
+    git clone https://github.com/graspnet/graspnetAPI.git
+    cd graspnetAPI/
+    pip install .

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/docs/source/modules.rst

@@ -0,0 +1,7 @@
+graspnetAPI
+===========
+
+.. toctree::
+   :maxdepth: 4
+
+   graspnetAPI

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/config.py

@@ -0,0 +1,18 @@
+def get_config():
+    '''
+     - return the config dict
+    '''
+    config = dict()
+    force_closure = dict()
+    force_closure['quality_method'] = 'force_closure'
+    force_closure['num_cone_faces'] = 8
+    force_closure['soft_fingers'] = 1
+    force_closure['quality_type'] = 'quasi_static'
+    force_closure['all_contacts_required']= 1
+    force_closure['check_approach'] = False
+    force_closure['torque_scaling'] = 0.01
+    force_closure['wrench_norm_thresh'] = 0.001
+    force_closure['wrench_regularizer'] = 0.0000000001
+    config['metrics'] = dict()
+    config['metrics']['force_closure'] = force_closure
+    return config

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/LICENSE

@@ -0,0 +1,18 @@
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/__init__.py

@@ -0,0 +1,24 @@
+# # -*- coding: utf-8 -*-
+# """
+# Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+# Permission to use, copy, modify, and distribute this software and its documentation for educational,
+# research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+# hereby granted, provided that the above copyright notice, this paragraph and the following two
+# paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+# Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+# 7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+# IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+# THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+# HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+# MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+# """
+# # from .constants import *
+# # from .abstractstatic import abstractstatic
+# # from .api import DexNet

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/abstractstatic.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+# Abstact static methods
+# Source: https://stackoverflow.com/questions/4474395/staticmethod-and-abc-abstractmethod-will-it-blend
+
+class abstractstatic(staticmethod):
+    __slots__ = ()
+    def __init__(self, function):
+        super(abstractstatic, self).__init__(function)
+        function.__isabstractmethod__ = True
+    __isabstractmethod__ = True

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/constants.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+# Grasp contact params
+NO_CONTACT_DIST = 0.2  # distance to points that are not in contact for window extraction
+WIN_DIST_LIM = 0.02  # limits for window plotting
+
+# File extensions
+HDF5_EXT = '.hdf5'
+OBJ_EXT = '.obj'
+OFF_EXT = '.off'
+STL_EXT = '.stl'
+SDF_EXT = '.sdf'
+URDF_EXT = '.urdf'
+
+# Tags for intermediate files
+DEC_TAG = '_dec'
+PROC_TAG = '_proc'
+
+# Solver default max iterations
+DEF_MAX_ITER = 100
+
+# Access levels for db
+READ_ONLY_ACCESS = 'READ_ONLY'
+READ_WRITE_ACCESS = 'READ_WRITE'
+WRITE_ACCESS = 'WRITE'

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/__init__.py

@@ -0,0 +1,20 @@
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/contacts.py

@@ -0,0 +1,703 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+"""
+Contact class that encapsulates friction cone and surface window computation.
+Authors: Brian Hou and Jeff Mahler
+"""
+
+from abc import ABCMeta, abstractmethod
+import itertools as it
+import logging
+import numpy as np
+from skimage.restoration import denoise_bilateral
+
+from autolab_core import RigidTransform
+
+from ..constants import NO_CONTACT_DIST
+from ..constants import WIN_DIST_LIM
+
+import IPython
+import matplotlib.pyplot as plt
+from sklearn.decomposition import PCA
+
+
+# class Contact(metaclass=ABCMeta):  # for python3
+class Contact:
+    """ Abstract class for contact models. """
+    __metaclass__ = ABCMeta
+
+class Contact3D(Contact):
+    """ 3D contact points.
+
+    Attributes
+    ----------
+    graspable : :obj:`GraspableObject3D`
+        object to use to get contact information
+    contact_point : 3x1 :obj:`numpy.ndarray`
+        point of contact on the object
+    in_direction : 3x1 :obj:`numpy.ndarray`
+        direction along which contact was made
+    normal : normalized 3x1 :obj:`numpy.ndarray`
+        surface normal at the contact point
+    """
+
+    def __init__(self, graspable, contact_point, in_direction=None):
+        self.graspable_ = graspable
+        self.point_ = contact_point  # in world coordinates
+
+        # cached attributes
+        self.in_direction_ = in_direction  # inward facing grasp axis
+        self.friction_cone_ = None
+        self.normal_ = None  # outward facing normal
+        self.surface_info_ = None
+
+        self._compute_normal()
+
+    @property
+    def graspable(self):
+        return self.graspable_
+
+    @property
+    def point(self):
+        return self.point_
+
+    @property
+    def normal(self):
+        return self.normal_
+
+    @normal.setter
+    def normal(self, normal):
+        self.normal_ = normal
+
+    @property
+    def in_direction(self):
+        return self.in_direction_
+
+    def _compute_normal(self):
+        """Compute outward facing normal at contact, according to in_direction.
+        Indexes into the SDF grid coordinates to lookup the normal info.
+        """
+        # tf to grid
+        as_grid = self.graspable.sdf.transform_pt_obj_to_grid(self.point)
+        on_surface, _ = self.graspable.sdf.on_surface(as_grid)
+        if not on_surface:
+            logging.debug('Contact point not on surface')
+            return None
+
+        # compute outward facing normal from SDF
+        normal = self.graspable.sdf.surface_normal(as_grid)
+
+        # flip normal to point outward if in_direction is defined
+        if self.in_direction_ is not None and np.dot(self.in_direction_, normal) > 0:
+            normal = -normal
+
+        # transform to world frame
+        normal = self.graspable.sdf.transform_pt_grid_to_obj(normal, direction=True)
+        self.normal_ = normal
+
+    def tangents(self, direction=None, align_axes=True, max_samples=1000):
+        """Returns the direction vector and tangent vectors at a contact point.
+        The direction vector defaults to the *inward-facing* normal vector at
+        this contact.
+        The direction and tangent vectors for a right handed coordinate frame.
+
+        Parameters
+        ----------
+        direction : 3x1 :obj:`numpy.ndarray`
+            direction to find orthogonal plane for
+        align_axes : bool
+            whether or not to align the tangent plane to the object reference frame
+        max_samples : int
+            number of samples to use in discrete optimization for alignment of reference frame
+
+        Returns
+        -------
+        direction : normalized 3x1 :obj:`numpy.ndarray`
+            direction to find orthogonal plane for
+        t1 : normalized 3x1 :obj:`numpy.ndarray`
+            first tangent vector, x axis
+        t2 : normalized 3x1 :obj:`numpy.ndarray`
+            second tangent vector, y axis
+        """
+        # illegal contact, cannot return tangents
+        if self.normal_ is None:
+            return None, None, None
+
+        # default to inward pointing normal
+        if direction is None:
+            direction = -self.normal_
+
+        # force direction to face inward
+        if np.dot(self.normal_, direction) > 0:
+            direction = -direction
+
+        # transform to 
+        direction = direction.reshape((3, 1))  # make 2D for SVD
+
+        # get orthogonal plane
+        U, _, _ = np.linalg.svd(direction)
+
+        # U[:, 1:] spans the tanget plane at the contact
+        x, y = U[:, 1], U[:, 2]
+
+        # make sure t1 and t2 obey right hand rule
+        z_hat = np.cross(x, y)
+        if z_hat.dot(direction) < 0:
+            y = -y
+        v = x
+        w = y
+
+        # redefine tangent x axis to automatically align with the object x axis
+        if align_axes:
+            max_ip = 0
+            max_theta = 0
+            target = np.array([1, 0, 0])
+            theta = 0
+            d_theta = 2 * np.pi / float(max_samples)
+            for i in range(max_samples):
+                v = np.cos(theta) * x + np.sin(theta) * y
+                if v.dot(target) > max_ip:
+                    max_ip = v.dot(target)
+                    max_theta = theta
+                theta = theta + d_theta
+
+            v = np.cos(max_theta) * x + np.sin(max_theta) * y
+            w = np.cross(direction.ravel(), v)
+        return np.squeeze(direction), v, w
+
+    def reference_frame(self, align_axes=True):
+        """Returns the local reference frame of the contact.
+        Z axis in the in direction (or surface normal if not specified)
+        X and Y axes in the tangent plane to the direction
+
+        Parameters
+        ----------
+        align_axes : bool
+            whether or not to align to the object axes
+
+        Returns
+        -------
+        :obj:`RigidTransform`
+            rigid transformation from contact frame to object frame
+        """
+        t_obj_contact = self.point
+        rz, rx, ry = self.tangents(self.in_direction_, align_axes=align_axes)
+        R_obj_contact = np.array([rx, ry, rz]).T
+        T_contact_obj = RigidTransform(rotation=R_obj_contact,
+                                       translation=t_obj_contact,
+                                       from_frame='contact', to_frame='obj')
+        return T_contact_obj
+
+    def normal_force_magnitude(self):
+        """ Returns the component of the force that the contact would apply along the normal direction.
+
+        Returns
+        -------
+        float
+            magnitude of force along object surface normal
+        """
+        normal_force_mag = 1.0
+        if self.in_direction_ is not None and self.normal_ is not None:
+            in_normal = -self.normal_
+            in_direction_norm = self.in_direction_ / np.linalg.norm(self.in_direction_)
+            normal_force_mag = np.dot(in_direction_norm, in_normal)
+        return max(normal_force_mag, 0.0)
+
+    def friction_cone(self, num_cone_faces=8, friction_coef=0.5):
+        """ Computes the friction cone and normal for a contact point.
+
+        Parameters
+        ----------
+        num_cone_faces : int
+            number of cone faces to use in discretization
+        friction_coef : float 
+            coefficient of friction at contact point
+        
+        Returns
+        -------
+        success : bool
+            False when cone can't be computed
+        cone_support : :obj:`numpy.ndarray`
+            array where each column is a vector on the boundary of the cone
+        normal : normalized 3x1 :obj:`numpy.ndarray`
+            outward facing surface normal
+        """
+        if self.friction_cone_ is not None and self.normal_ is not None:
+            return True, self.friction_cone_, self.normal_
+
+        # get normal and tangents
+        in_normal, t1, t2 = self.tangents()
+        if in_normal is None:
+            return False, self.friction_cone_, self.normal_
+
+        friction_cone_valid = True
+
+        # check whether contact would slip, which is whether or not the tangent force is always
+        # greater than the frictional force
+        if self.in_direction_ is not None:
+            in_direction_norm = self.in_direction_ / np.linalg.norm(self.in_direction_)
+            normal_force_mag = self.normal_force_magnitude()
+            tan_force_x = np.dot(in_direction_norm, t1)
+            tan_force_y = np.dot(in_direction_norm, t2)
+            tan_force_mag = np.sqrt(tan_force_x ** 2 + tan_force_y ** 2)
+            friction_force_mag = friction_coef * normal_force_mag
+
+            if friction_force_mag < tan_force_mag:
+                logging.debug('Contact would slip')
+                return False, self.friction_cone_, self.normal_
+
+        # set up friction cone
+        tan_len = friction_coef
+        force = in_normal
+        cone_support = np.zeros((3, num_cone_faces))
+
+        # find convex combinations of tangent vectors
+        for j in range(num_cone_faces):
+            tan_vec = t1 * np.cos(2 * np.pi * (float(j) / num_cone_faces)) + t2 * np.sin(
+                2 * np.pi * (float(j) / num_cone_faces))
+            cone_support[:, j] = force + friction_coef * tan_vec
+
+        self.friction_cone_ = cone_support
+        return True, self.friction_cone_, self.normal_
+
+    def torques(self, forces):
+        """
+        Get the torques that can be applied by a set of force vectors at the contact point.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            the forces applied at the contact
+
+        Returns
+        -------
+        success : bool
+            whether or not computation was successful
+        torques : 3xN :obj:`numpy.ndarray`
+            the torques that can be applied by given forces at the contact
+        """
+        as_grid = self.graspable.sdf.transform_pt_obj_to_grid(self.point)
+        on_surface, _ = self.graspable.sdf.on_surface(as_grid)
+        if not on_surface:
+            logging.debug('Contact point not on surface')
+            return False, None
+
+        num_forces = forces.shape[1]
+        torques = np.zeros([3, num_forces])
+        moment_arm = self.graspable.moment_arm(self.point)
+        for i in range(num_forces):
+            torques[:, i] = np.cross(moment_arm, forces[:, i])
+
+        return True, torques
+
+    def surface_window_sdf(self, width=1e-2, num_steps=21):
+        """Returns a window of SDF values on the tangent plane at a contact point.
+        Used for patch computation.
+
+        Parameters
+        ----------
+        width : float
+            width of the window in obj frame
+        num_steps : int
+            number of steps to use along the contact in direction
+
+        Returns
+        -------
+        window : NUM_STEPSxNUM_STEPS :obj:`numpy.ndarray`
+            array of distances from tangent plane to obj along in direction, False if surface window can't be computed
+        """
+        in_normal, t1, t2 = self.tangents()
+        if in_normal is None:  # normal and tangents not found
+            return False
+
+        scales = np.linspace(-width / 2.0, width / 2.0, num_steps)
+        window = np.zeros(num_steps ** 2)
+        for i, (c1, c2) in enumerate(it.product(scales, repeat=2)):
+            curr_loc = self.point + c1 * t1 + c2 * t2
+            curr_loc_grid = self.graspable.sdf.transform_pt_obj_to_grid(curr_loc)
+            if self.graspable.sdf.is_out_of_bounds(curr_loc_grid):
+                window[i] = -1e-2
+                continue
+
+            window[i] = self.graspable.sdf[curr_loc_grid]
+        return window.reshape((num_steps, num_steps))
+
+    def _compute_surface_window_projection(self, u1=None, u2=None, width=1e-2,
+                                           num_steps=21, max_projection=0.1, back_up=0, samples_per_grid=2.0,
+                                           sigma_range=0.1, sigma_spatial=1, direction=None, vis=False,
+                                           compute_weighted_covariance=False,
+                                           disc=False, num_radial_steps=5, debug_objs=None):
+        """Compute the projection window onto the basis defined by u1 and u2.
+        Params:
+            u1, u2 - orthogonal numpy 3 arrays
+
+            width - float width of the window in obj frame
+            num_steps - int number of steps
+            max_projection - float maximum amount to search forward for a
+                contact (meters)
+
+            back_up - amount in meters to back up before projecting
+            samples_per_grid - float number of samples per grid when finding contacts
+            sigma - bandwidth of gaussian filter on window
+            direction - dir to do the projection along
+            compute_weighted_covariance - whether to return the weighted
+               covariance matrix, along with the window
+        Returns:
+            window - numpy NUM_STEPSxNUM_STEPS array of distances from tangent
+                plane to obj, False if surface window can't be computed
+        """
+        direction, t1, t2 = self.tangents(direction)
+        if direction is None:  # normal and tangents not found
+            raise ValueError('Direction could not be computed')
+        if u1 is not None and u2 is not None:  # use given basis
+            t1, t2 = u1, u2
+
+        # number of samples used when looking for contacts
+        no_contact = NO_CONTACT_DIST
+        num_samples = int(samples_per_grid * (max_projection + back_up) / self.graspable.sdf.resolution)
+        window = np.zeros(num_steps ** 2)
+
+        res = width / num_steps
+        scales = np.linspace(-width / 2.0 + res / 2.0, width / 2.0 - res / 2.0, num_steps)
+        scales_it = it.product(scales, repeat=2)
+        if disc:
+            scales_it = []
+            for i in range(num_steps):
+                theta = 2.0 * np.pi / i
+                for j in range(num_radial_steps):
+                    r = (j + 1) * width / num_radial_steps
+                    p = (r * np.cos(theta), r * np.sin(theta))
+                    scales_it.append(p)
+
+        # start computing weighted covariance matrix
+        if compute_weighted_covariance:
+            cov = np.zeros((3, 3))
+            cov_weight = 0
+
+        if vis:
+            ax = plt.gca(projection='3d')
+            self.graspable_.sdf.scatter()
+
+        for i, (c1, c2) in enumerate(scales_it):
+            curr_loc = self.point + c1 * t1 + c2 * t2
+            curr_loc_grid = self.graspable.sdf.transform_pt_obj_to_grid(curr_loc)
+            if self.graspable.sdf.is_out_of_bounds(curr_loc_grid):
+                window[i] = no_contact
+                continue
+
+            if vis:
+                ax.scatter(curr_loc_grid[0], curr_loc_grid[1], curr_loc_grid[2], s=130, c='y')
+
+            found, projection_contact = self.graspable._find_projection(
+                curr_loc, direction, max_projection, back_up, num_samples, vis=vis)
+
+            if found:
+                # logging.debug('%d found.' %(i))
+                sign = direction.dot(projection_contact.point - curr_loc)
+                projection = (sign / abs(sign)) * np.linalg.norm(projection_contact.point - curr_loc)
+                projection = min(projection, max_projection)
+
+                if compute_weighted_covariance:
+                    # weight according to SHOT: R - d_i
+                    weight = width / np.sqrt(2) - np.sqrt(c1 ** 2 + c2 ** 2)
+                    diff = (projection_contact.point - self.point).reshape((3, 1))
+                    cov += weight * np.dot(diff, diff.T)
+                    cov_weight += weight
+            else:
+                logging.debug('%d not found.' % (i))
+                projection = no_contact
+
+            window[i] = projection
+
+        if vis:
+            plt.show()
+
+        if not disc:
+            window = window.reshape((num_steps, num_steps)).T  # transpose to make x-axis along columns
+            if debug_objs is not None:
+                debug_objs.append(window)
+            # apply bilateral filter
+            if sigma_range > 0.0 and sigma_spatial > 0.0:
+                window_min_val = np.min(window)
+                window_pos = window - window_min_val
+                window_pos_blur = denoise_bilateral(window_pos, sigma_range=sigma_range, sigma_spatial=sigma_spatial,
+                                                    mode='nearest')
+                window = window_pos_blur + window_min_val
+            if compute_weighted_covariance:
+                if cov_weight > 0:
+                    return window, cov / cov_weight
+                return window, cov
+        return window
+
+    def surface_window_projection_unaligned(self, width=1e-2, num_steps=21,
+                                            max_projection=0.1, back_up=0.0, samples_per_grid=2.0,
+                                            sigma=1.5, direction=None, vis=False):
+        """Projects the local surface onto the tangent plane at a contact point. Deprecated.
+        """
+        return self._compute_surface_window_projection(width=width,
+                                                       num_steps=num_steps, max_projection=max_projection,
+                                                       back_up=back_up, samples_per_grid=samples_per_grid,
+                                                       sigma=sigma, direction=direction, vis=vis)
+
+    def surface_window_projection(self, width=1e-2, num_steps=21,
+                                  max_projection=0.1, back_up=0.0, samples_per_grid=2.0,
+                                  sigma_range=0.1, sigma_spatial=1, direction=None, compute_pca=False, vis=False,
+                                  debug_objs=None):
+        """Projects the local surface onto the tangent plane at a contact point.
+
+        Parameters
+        ----------
+        width : float
+            width of the window in obj frame
+        num_steps : int 
+            number of steps to use along the in direction
+        max_projection : float
+            maximum amount to search forward for a contact (meters)
+        back_up : float
+            amount to back up before finding a contact in meters
+        samples_per_grid : float
+            number of samples per grid when finding contacts
+        sigma_range : float
+            bandwidth of bilateral range filter on window
+        sigma_spatial : float
+            bandwidth of gaussian spatial filter of bilateral filter
+        direction : 3x1 :obj:`numpy.ndarray`
+            dir to do the projection along
+
+        Returns
+        -------
+        window : NUM_STEPSxNUM_STEPS :obj:`numpy.ndarray`
+            array of distances from tangent plane to obj, False if surface window can't be computed
+        """
+        # get initial projection
+        direction, t1, t2 = self.tangents(direction)
+        window, cov = self._compute_surface_window_projection(t1, t2,
+                                                              width=width, num_steps=num_steps,
+                                                              max_projection=max_projection,
+                                                              back_up=back_up, samples_per_grid=samples_per_grid,
+                                                              sigma_range=sigma_range, sigma_spatial=sigma_spatial,
+                                                              direction=direction,
+                                                              vis=False, compute_weighted_covariance=True,
+                                                              debug_objs=debug_objs)
+
+        if not compute_pca:
+            return window
+
+        # compute principal axis
+        pca = PCA()
+        pca.fit(cov)
+        R = pca.components_
+        principal_axis = R[0, :]
+        if np.isclose(abs(np.dot(principal_axis, direction)), 1):
+            # principal axis is aligned with direction of projection, use secondary axis
+            principal_axis = R[1, :]
+
+        if vis:
+            # reshape window
+            window = window.reshape((num_steps, num_steps))
+
+            # project principal axis onto tangent plane (t1, t2) to get u1
+            u1t = np.array([np.dot(principal_axis, t1), np.dot(principal_axis, t2)])
+            u2t = np.array([-u1t[1], u1t[0]])
+            if sigma > 0:
+                window = spfilt.gaussian_filter(window, sigma)
+            plt.figure()
+            plt.title('Principal Axis')
+            plt.imshow(window, extent=[0, num_steps - 1, num_steps - 1, 0],
+                       interpolation='none', cmap=plt.cm.binary)
+            plt.colorbar()
+            plt.clim(-WIN_DIST_LIM, WIN_DIST_LIM)  # fixing color range for visual comparisons
+            center = num_steps // 2
+            plt.scatter([center, center * u1t[0] + center], [center, -center * u1t[1] + center], color='blue')
+            plt.scatter([center, center * u2t[0] + center], [center, -center * u2t[1] + center], color='green')
+
+        u1 = np.dot(principal_axis, t1) * t1 + np.dot(principal_axis, t2) * t2
+        u2 = np.cross(direction, u1)  # u2 must be orthogonal to u1 on plane
+        u1 = u1 / np.linalg.norm(u1)
+        u2 = u2 / np.linalg.norm(u2)
+
+        window = self._compute_surface_window_projection(u1, u2,
+                                                         width=width, num_steps=num_steps,
+                                                         max_projection=max_projection,
+                                                         back_up=back_up, samples_per_grid=samples_per_grid,
+                                                         sigma=sigma, direction=direction, vis=False)
+
+        # arbitrarily require that right_avg > left_avg (inspired by SHOT)
+        left_avg = np.average(window[:, :num_steps // 2])
+        right_avg = np.average(window[:, num_steps // 2:])
+        if left_avg > right_avg:
+            # need to flip both u1 and u2, i.e. rotate 180 degrees
+            window = np.rot90(window, k=2)
+
+        if vis:
+            if sigma > 0:
+                window = spfilt.gaussian_filter(window, sigma)
+            plt.figure()
+            plt.title('Tfd')
+            plt.imshow(window, extent=[0, num_steps - 1, num_steps - 1, 0],
+                       interpolation='none', cmap=plt.cm.binary)
+            plt.colorbar()
+            plt.clim(-WIN_DIST_LIM, WIN_DIST_LIM)  # fixing color range for visual comparisons
+            plt.show()
+
+        return window
+
+    def surface_information(self, width, num_steps, sigma_range=0.1, sigma_spatial=1,
+                            back_up=0.0, max_projection=0.1, direction=None, debug_objs=None, samples_per_grid=2):
+        """
+        Returns the local surface window, gradient, and curvature for a single contact.
+
+        Parameters
+        ----------
+        width : float
+            width of surface window in object frame
+        num_steps : int 
+            number of steps to use along the in direction
+        sigma_range : float
+            bandwidth of bilateral range filter on window
+        sigma_spatial : float
+            bandwidth of gaussian spatial filter of bilateral filter
+        back_up : float
+            amount to back up before finding a contact in meters
+        max_projection : float
+            maximum amount to search forward for a contact (meters)
+        direction : 3x1 :obj:`numpy.ndarray`
+            direction along width to render the window
+        debug_objs : :obj:`list`
+            list to put debugging info into
+        samples_per_grid : float
+            number of samples per grid when finding contacts
+        
+        Returns
+        -------
+        surface_window : :obj:`SurfaceWindow`
+            window information for local surface patch of contact on the given object
+        """
+        if self.surface_info_ is not None:
+            return self.surface_info_
+
+        if direction is None:
+            direction = self.in_direction_
+
+        proj_window = self.surface_window_projection(width, num_steps,
+                                                     sigma_range=sigma_range, sigma_spatial=sigma_spatial,
+                                                     back_up=back_up, max_projection=max_projection,
+                                                     samples_per_grid=samples_per_grid,
+                                                     direction=direction, vis=False, debug_objs=debug_objs)
+
+        if proj_window is None:
+            raise ValueError('Surface window could not be computed')
+
+        grad_win = np.gradient(proj_window)
+        hess_x = np.gradient(grad_win[0])
+        hess_y = np.gradient(grad_win[1])
+
+        gauss_curvature = np.zeros(proj_window.shape)
+        for i in range(num_steps):
+            for j in range(num_steps):
+                local_hess = np.array([[hess_x[0][i, j], hess_x[1][i, j]],
+                                       [hess_y[0][i, j], hess_y[1][i, j]]])
+                # symmetrize
+                local_hess = (local_hess + local_hess.T) / 2.0
+                # curvature
+                gauss_curvature[i, j] = np.linalg.det(local_hess)
+
+        return SurfaceWindow(proj_window, grad_win, hess_x, hess_y, gauss_curvature)
+
+    def plot_friction_cone(self, color='y', scale=1.0):
+        success, cone, in_normal = self.friction_cone()
+
+        ax = plt.gca(projection='3d')
+        self.graspable.sdf.scatter()  # object
+        x, y, z = self.graspable.sdf.transform_pt_obj_to_grid(self.point)
+        nx, ny, nz = self.graspable.sdf.transform_pt_obj_to_grid(in_normal, direction=True)
+        ax.scatter([x], [y], [z], c=color, s=60)  # contact
+        ax.scatter([x - nx], [y - ny], [z - nz], c=color, s=60)  # normal
+        if success:
+            ax.scatter(x + scale * cone[0], y + scale * cone[1], z + scale * cone[2], c=color, s=40)  # cone
+
+        ax.set_xlim3d(0, self.graspable.sdf.dims_[0])
+        ax.set_ylim3d(0, self.graspable.sdf.dims_[1])
+        ax.set_zlim3d(0, self.graspable.sdf.dims_[2])
+
+        return plt.Rectangle((0, 0), 1, 1, fc=color)  # return a proxy for legend
+
+
+class SurfaceWindow:
+    """Struct for encapsulating local surface window features.
+
+    Attributes
+    ----------
+    proj_win : NxN :obj:`numpy.ndarray`
+        the window of distances to a surface (depth image created by orthographic projection)
+    grad : NxN :obj:`numpy.ndarray`
+        X and Y gradients of the projection window
+    hess_x : NxN :obj:`numpy.ndarray`
+        hessian, partial derivatives of the X gradient window
+    hess_y : NxN :obj:`numpy.ndarray`
+        hessian, partial derivatives of the Y gradient window
+    gauss_curvature : NxN :obj:`numpy.ndarray`
+        gauss curvature at each point (function of hessian determinant)
+    """
+
+    def __init__(self, proj_win, grad, hess_x, hess_y, gauss_curvature):
+        self.proj_win_ = proj_win
+        self.grad_ = grad
+        self.hess_x_ = hess_x
+        self.hess_y_ = hess_y
+        self.gauss_curvature_ = gauss_curvature
+
+    @property
+    def proj_win_2d(self):
+        return self.proj_win_
+
+    @property
+    def proj_win(self):
+        return self.proj_win_.flatten()
+
+    @property
+    def grad_x(self):
+        return self.grad_[0].flatten()
+
+    @property
+    def grad_y(self):
+        return self.grad_[1].flatten()
+
+    @property
+    def grad_x_2d(self):
+        return self.grad_[0]
+
+    @property
+    def grad_y_2d(self):
+        return self.grad_[1]
+
+    @property
+    def curvature(self):
+        return self.gauss_curvature_.flatten()
+
+    def asarray(self, proj_win_weight=0.0, grad_x_weight=0.0,
+                grad_y_weight=0.0, curvature_weight=0.0):
+        proj_win = proj_win_weight * self.proj_win
+        grad_x = grad_x_weight * self.grad_x
+        grad_y = grad_y_weight * self.grad_y
+        curvature = curvature_weight * self.gauss_curvature
+        return np.append([], [proj_win, grad_x, grad_y, curvature])

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/grasp.py

@@ -0,0 +1,1127 @@
+# -*- coding: utf-8 -*-
+# """
+# Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+# Permission to use, copy, modify, and distribute this software and its documentation for educational,
+# research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+# hereby granted, provided that the above copyright notice, this paragraph and the following two
+# paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+# Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+# 7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+#
+# IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+# THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+# HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+# MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+# """
+# """
+# Grasp class that implements gripper endpoints and grasp functions
+# Authors: Jeff Mahler, with contributions from Jacky Liang and Nikhil Sharma
+# """
+from abc import ABCMeta, abstractmethod
+from copy import deepcopy
+import IPython
+import logging
+import matplotlib.pyplot as plt
+import numpy as np
+from numpy.linalg import inv, norm
+import time
+
+from autolab_core import Point, RigidTransform
+from .meshpy import Sdf3D, StablePose
+
+
+from ..abstractstatic import abstractstatic
+from .contacts import Contact3D
+from .graspable_object import GraspableObject3D
+
+
+# class Grasp(object, metaclass=ABCMeta):
+class Grasp(object):
+    """ Abstract grasp class.
+
+    Attributes
+    ----------
+    configuration : :obj:`numpy.ndarray`
+        vector specifying the parameters of the grasp (e.g. hand pose, opening width, joint angles, etc)
+    frame : :obj:`str`
+        string name of grasp reference frame (defaults to obj)
+    """
+    __metaclass__ = ABCMeta
+    samples_per_grid = 2  # global resolution for line of action
+
+    @abstractmethod
+    def close_fingers(self, obj):
+        """ Finds the contact points by closing on the given object.
+        
+        Parameters
+        ----------
+        obj : :obj:`GraspableObject3D`
+            object to find contacts on
+        """
+        pass
+
+    @abstractmethod
+    def configuration(self):
+        """ Returns the numpy array representing the hand configuration """
+        pass
+
+    @abstractmethod
+    def frame(self):
+        """ Returns the string name of the grasp reference frame  """
+        pass
+
+    @abstractstatic
+    def params_from_configuration(configuration):
+        """ Convert configuration vector to a set of params for the class """
+        pass
+
+    @abstractstatic
+    def configuration_from_params(*params):
+        """ Convert param list to a configuration vector for the class """
+        pass
+
+
+# class PointGrasp(Grasp, metaclass=ABCMeta):
+class PointGrasp(Grasp):
+    """ Abstract grasp class for grasps with a point contact model.
+
+    Attributes
+    ----------
+    configuration : :obj:`numpy.ndarray`
+        vector specifying the parameters of the grasp (e.g. hand pose, opening width, joint angles, etc)
+    frame : :obj:`str`
+        string name of grasp reference frame (defaults to obj)
+    """
+    __metaclass__ = ABCMeta
+
+    @abstractmethod
+    def create_line_of_action(g, axis, width, obj, num_samples):
+        """ Creates a line of action, or the points in space that the grasp traces out, from a point g in world coordinates on an object.
+
+        Returns
+        -------
+        bool
+            whether or not successful
+        :obj:`list` of :obj:`numpy.ndarray`
+            points in 3D space along the line of action
+        """
+        pass
+
+    # NOTE: implementation of close_fingers must return success, array of contacts (one per column)
+
+
+class ParallelJawPtGrasp3D(PointGrasp):
+    """ Parallel Jaw point grasps in 3D space.
+    """
+
+    def __init__(self, configuration, max_grasp_depth=0, frame='object', grasp_id=None):
+        # get parameters from configuration array
+        grasp_center, grasp_axis, grasp_width, grasp_angle, jaw_width, min_grasp_width = \
+            ParallelJawPtGrasp3D.params_from_configuration(configuration)
+
+        self.center_ = grasp_center
+        self.axis_ = grasp_axis / np.linalg.norm(grasp_axis)
+        self.max_grasp_width_ = grasp_width
+        self.jaw_width_ = jaw_width
+        self.min_grasp_width_ = min_grasp_width
+        self.approach_angle_ = grasp_angle
+        self.frame_ = frame
+        self.grasp_id_ = grasp_id
+        self.max_grasp_depth = max_grasp_depth
+
+    @property
+    def center(self):
+        """ :obj:`numpy.ndarray` : 3-vector specifying the center of the jaws """
+        return self.center_
+
+    @center.setter
+    def center(self, x):
+        self.center_ = x
+
+    @property
+    def axis(self):
+        """ :obj:`numpy.ndarray` : normalized 3-vector specifying the line between the jaws """
+        return self.axis_
+
+    @property
+    def open_width(self):
+        """ float : maximum opening width of the jaws """
+        return self.max_grasp_width_
+
+    @property
+    def close_width(self):
+        """ float : minimum opening width of the jaws """
+        return self.min_grasp_width_
+
+    @property
+    def jaw_width(self):
+        """ float : width of the jaws in the tangent plane to the grasp axis """
+        return self.jaw_width_
+
+    @property
+    def approach_angle(self):
+        """ float : approach angle of the grasp """
+        return self.approach_angle_
+
+    @property
+    def configuration(self):
+        """ :obj:`numpy.ndarray` : vector specifying the parameters of the grasp as follows
+        (grasp_center, grasp_axis, grasp_angle, grasp_width, jaw_width) """
+        return ParallelJawPtGrasp3D.configuration_from_params(self.center_, self.axis_, self.max_grasp_width_,
+                                                              self.approach_angle_, self.jaw_width_,
+                                                              self.min_grasp_width_)
+
+    @property
+    def frame(self):
+        """ :obj:`str` : name of grasp reference frame """
+        return self.frame_
+
+    @property
+    def id(self):
+        """ int : id of grasp """
+        return self.grasp_id_
+
+    @frame.setter
+    def frame(self, f):
+        self.frame_ = f
+
+    @approach_angle.setter
+    def approach_angle(self, angle):
+        """ Set the grasp approach angle """
+        self.approach_angle_ = angle
+
+    @property
+    def endpoints(self):
+        """
+        Returns
+        -------
+        :obj:`numpy.ndarray`
+            location of jaws in 3D space at max opening width """
+        return self.center_ - (self.max_grasp_width_ / 2.0) * self.axis_, self.center_ + (
+                self.max_grasp_width_ / 2.0) * self.axis_,
+
+    @staticmethod
+    def distance(g1, g2, alpha=0.05):
+        """ Evaluates the distance between two grasps.
+
+        Parameters
+        ----------
+        g1 : :obj:`ParallelJawPtGrasp3D`
+            the first grasp to use
+        g2 : :obj:`ParallelJawPtGrasp3D`
+            the second grasp to use
+        alpha : float
+            parameter weighting rotational versus spatial distance
+
+        Returns
+        -------
+        float
+            distance between grasps g1 and g2
+        """
+        center_dist = np.linalg.norm(g1.center - g2.center)
+        axis_dist = (2.0 / np.pi) * np.arccos(np.abs(g1.axis.dot(g2.axis)))
+        return center_dist + alpha * axis_dist
+
+    @staticmethod
+    def configuration_from_params(center, axis, width, angle=0, jaw_width=0, min_width=0):
+        """ Converts grasp parameters to a configuration vector. """
+        if np.abs(np.linalg.norm(axis) - 1.0) > 1e-5:
+            raise ValueError('Illegal grasp axis. Must be norm one')
+        configuration = np.zeros(10)
+        configuration[0:3] = center
+        configuration[3:6] = axis
+        configuration[6] = width
+        configuration[7] = angle
+        configuration[8] = jaw_width
+        configuration[9] = min_width
+        return configuration
+
+    @staticmethod
+    def params_from_configuration(configuration):
+        """ Converts configuration vector into grasp parameters.
+        
+        Returns
+        -------
+        grasp_center : :obj:`numpy.ndarray`
+            center of grasp in 3D space
+        grasp_axis : :obj:`numpy.ndarray`
+            normalized axis of grasp in 3D space
+        max_width : float
+            maximum opening width of jaws
+        angle : float
+            approach angle
+        jaw_width : float
+            width of jaws
+        min_width : float
+            minimum closing width of jaws
+        """
+        if not isinstance(configuration, np.ndarray) or (configuration.shape[0] != 9 and configuration.shape[0] != 10):
+            raise ValueError('Configuration must be numpy ndarray of size 9 or 10')
+        if configuration.shape[0] == 9:
+            min_grasp_width = 0
+        else:
+            min_grasp_width = configuration[9]
+        if np.abs(np.linalg.norm(configuration[3:6]) - 1.0) > 1e-5:
+            raise ValueError('Illegal grasp axis. Must be norm one')
+        return configuration[0:3], configuration[3:6], configuration[6], configuration[7], configuration[
+            8], min_grasp_width
+
+    @staticmethod
+    def center_from_endpoints(g1, g2):
+        """ Grasp center from endpoints as np 3-arrays """
+        grasp_center = (g1 + g2) / 2
+        return grasp_center
+
+    @staticmethod
+    def axis_from_endpoints(g1, g2):
+        """ Normalized axis of grasp from endpoints as np 3-arrays """
+        grasp_axis = g2 - g1
+        if np.linalg.norm(grasp_axis) == 0:
+            return grasp_axis
+        return grasp_axis / np.linalg.norm(grasp_axis)
+
+    @staticmethod
+    def width_from_endpoints(g1, g2):
+        """ Width of grasp from endpoints """
+        grasp_axis = g2 - g1
+        return np.linalg.norm(grasp_axis)
+
+    @staticmethod
+    def grasp_from_endpoints(g1, g2, width=None, approach_angle=0, close_width=0):
+        """ Create a grasp from given endpoints in 3D space, making the axis the line between the points.
+
+        Parameters
+        ---------
+        g1 : :obj:`numpy.ndarray`
+            location of the first jaw
+        g2 : :obj:`numpy.ndarray`
+            location of the second jaw
+        width : float
+            maximum opening width of jaws
+        approach_angle : float
+            approach angle of grasp
+        close_width : float
+            width of gripper when fully closed
+        """
+        x = ParallelJawPtGrasp3D.center_from_endpoints(g1, g2)
+        v = ParallelJawPtGrasp3D.axis_from_endpoints(g1, g2)
+        if width is None:
+            width = ParallelJawPtGrasp3D.width_from_endpoints(g1, g2)
+        return ParallelJawPtGrasp3D(
+            ParallelJawPtGrasp3D.configuration_from_params(x, v, width, min_width=close_width, angle=approach_angle))
+
+    @property
+    def unrotated_full_axis(self):
+        """ Rotation matrix from canonical grasp reference frame to object reference frame. X axis points out of the
+        gripper palm along the 0-degree approach direction, Y axis points between the jaws, and the Z axs is orthogonal.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray`
+            rotation matrix of grasp
+        """
+        grasp_axis_y = self.axis
+        grasp_axis_x = np.array([grasp_axis_y[1], -grasp_axis_y[0], 0])
+        if np.linalg.norm(grasp_axis_x) == 0:
+            grasp_axis_x = np.array([1, 0, 0])
+        grasp_axis_x = grasp_axis_x / norm(grasp_axis_x)
+        grasp_axis_z = np.cross(grasp_axis_x, grasp_axis_y)
+
+        R = np.c_[grasp_axis_x, np.c_[grasp_axis_y, grasp_axis_z]]
+        return R
+
+    @property
+    def rotated_full_axis(self):
+        """ Rotation matrix from canonical grasp reference frame to object reference frame. X axis points out of the
+        gripper palm along the grasp approach angle, Y axis points between the jaws, and the Z axs is orthogonal.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray`
+            rotation matrix of grasp
+        """
+        R = ParallelJawPtGrasp3D._get_rotation_matrix_y(self.approach_angle)
+        R = self.unrotated_full_axis.dot(R)
+        return R
+
+    @property
+    def T_grasp_obj(self):
+        """ Rigid transformation from grasp frame to object frame.
+        Rotation matrix is X-axis along approach direction, Y axis pointing between the jaws, and Z-axis orthogonal.
+        Translation vector is the grasp center.
+
+        Returns
+        -------
+        :obj:`RigidTransform`
+            transformation from grasp to object coordinates
+        """
+        T_grasp_obj = RigidTransform(self.rotated_full_axis, self.center, from_frame='grasp', to_frame='obj')
+        return T_grasp_obj
+
+    @staticmethod
+    def _get_rotation_matrix_y(theta):
+        cos_t = np.cos(theta)
+        sin_t = np.sin(theta)
+        R = np.c_[[cos_t, 0, sin_t], np.c_[[0, 1, 0], [-sin_t, 0, cos_t]]]
+        return R
+
+    def gripper_pose(self, gripper=None):
+        """ Returns the RigidTransformation from the gripper frame to the object frame when the gripper is executing the
+        given grasp.
+        Differs from the grasp reference frame because different robots use different conventions for the gripper
+        reference frame.
+        
+        Parameters
+        ----------
+        gripper : :obj:`RobotGripper`
+            gripper to get the pose for
+
+        Returns
+        -------
+        :obj:`RigidTransform`
+            transformation from gripper frame to object frame
+        """
+        if gripper is None:
+            T_gripper_grasp = RigidTransform(from_frame='gripper', to_frame='grasp')
+        else:
+            T_gripper_grasp = gripper.T_grasp_gripper
+
+        T_gripper_obj = self.T_grasp_obj * T_gripper_grasp
+        return T_gripper_obj
+
+    def grasp_angles_from_stp_z(self, stable_pose):
+        """ Get angles of the the grasp from the table plane:
+        1) the angle between the grasp axis and table normal
+        2) the angle between the grasp approach axis and the table normal
+        
+        Parameters
+        ----------
+        stable_pose : :obj:`StablePose` or :obj:`RigidTransform`
+            the stable pose to compute the angles for
+
+        Returns
+        -------
+        psi : float
+            grasp y axis rotation from z axis in stable pose
+        phi : float
+            grasp x axis rotation from z axis in stable pose
+        """
+        T_grasp_obj = self.T_grasp_obj
+
+        if isinstance(stable_pose, StablePose):
+            R_stp_obj = stable_pose.r
+        else:
+            R_stp_obj = stable_pose.rotation
+        T_stp_obj = RigidTransform(R_stp_obj, from_frame='obj', to_frame='stp')
+
+        T_stp_grasp = T_stp_obj * T_grasp_obj
+
+        stp_z = np.array([0, 0, 1])
+        grasp_axis_angle = np.arccos(stp_z.dot(T_stp_grasp.y_axis))
+        grasp_approach_angle = np.arccos(abs(stp_z.dot(T_stp_grasp.x_axis)))
+        nu = stp_z.dot(T_stp_grasp.z_axis)
+
+        return grasp_axis_angle, grasp_approach_angle, nu
+
+    def close_fingers(self, obj, vis=False, check_approach=True, approach_dist=1.0):
+        """ Steps along grasp axis to find the locations of contact with an object
+
+        Parameters
+        ----------
+        obj : :obj:`GraspableObject3D`
+            object to close fingers on
+        vis : bool
+            whether or not to plot the line of action and contact points
+        check_approach : bool
+            whether or not to check if the contact points can be reached
+        approach_dist : float
+            how far back to check the approach distance, only if checking the approach is set
+        
+        Returns
+        -------
+        success : bool
+            whether or not contacts were found
+        c1 : :obj:`Contact3D`
+            the contact point for jaw 1
+        c2 : :obj:`Contact3D`
+            the contact point for jaw 2
+        """
+        if vis:
+            plt.figure()
+            plt.clf()
+            h = plt.gcf()
+            plt.ion()
+        # compute num samples to use based on sdf resolution
+        grasp_width_grid = obj.sdf.transform_pt_obj_to_grid(self.max_grasp_width_)
+        num_samples = int(Grasp.samples_per_grid * float(grasp_width_grid) / 2)  # at least 1 sample per grid
+
+        # get grasp endpoints in sdf frame
+        g1_world, g2_world = self.endpoints
+
+        # check for contact along approach
+        if check_approach:
+            approach_dist_grid = obj.sdf.transform_pt_obj_to_grid(approach_dist)
+            num_approach_samples = int(Grasp.samples_per_grid * approach_dist_grid / 2)  # at least 1 sample per grid
+            approach_axis = self.rotated_full_axis[:, 0]
+            approach_loa1 = ParallelJawPtGrasp3D.create_line_of_action(g1_world, -approach_axis, approach_dist, obj,
+                                                                       num_approach_samples, min_width=0)
+            approach_loa2 = ParallelJawPtGrasp3D.create_line_of_action(g2_world, -approach_axis, approach_dist, obj,
+                                                                       num_approach_samples, min_width=0)
+            c1_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa1, obj, vis=vis, strict=True)
+            c2_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa2, obj, vis=vis, strict=True)
+            approach_collision = c1_found or c2_found
+            if approach_collision:
+                plt.clf()
+                return False, None
+
+        # get line of action            
+        line_of_action1 = ParallelJawPtGrasp3D.create_line_of_action(g1_world, self.axis_, self.open_width, obj,
+                                                                     num_samples, min_width=self.close_width)
+        line_of_action2 = ParallelJawPtGrasp3D.create_line_of_action(g2_world, -self.axis_, self.open_width, obj,
+                                                                     num_samples, min_width=self.close_width)
+
+        if vis:
+            ax = plt.gca(projection='3d')
+            surface = obj.sdf.surface_points()[0]
+            surface = surface[np.random.choice(surface.shape[0], 1000, replace=False)]
+            ax.scatter(surface[:, 0], surface[:, 1], surface[:, 2], '.',
+                       s=np.ones_like(surface[:, 0]) * 0.3, c='b')
+
+        # find contacts
+        c1_found, c1 = ParallelJawPtGrasp3D.find_contact(line_of_action1, obj, vis=vis)
+        c2_found, c2 = ParallelJawPtGrasp3D.find_contact(line_of_action2, obj, vis=vis)
+
+        if vis:
+            ax = plt.gca(projection='3d')
+            ax.set_xlim3d(0, obj.sdf.dims_[0])
+            ax.set_ylim3d(0, obj.sdf.dims_[1])
+            ax.set_zlim3d(0, obj.sdf.dims_[2])
+            plt.draw()
+
+        contacts_found = c1_found and c2_found
+        return contacts_found, [c1, c2]
+
+    def close_fingers_with_contacts(self, obj, contacts, vis=False, check_approach=True, approach_dist=0.5):
+        """ Steps along grasp axis to find the locations of contact with an object
+
+        Parameters
+        ----------
+        obj : :obj:`GraspableObject3D`
+            object to close fingers on
+        vis : bool
+            whether or not to plot the line of action and contact points
+        check_approach : bool
+            whether or not to check if the contact points can be reached
+        approach_dist : float
+            how far back to check the approach distance, only if checking the approach is set
+        
+        Returns
+        -------
+        success : bool
+            whether or not contacts were found
+        c1 : :obj:`Contact3D`
+            the contact point for jaw 1
+        c2 : :obj:`Contact3D`
+            the contact point for jaw 2
+        """
+        if vis:
+            plt.figure()
+            plt.clf()
+            h = plt.gcf()
+            plt.ion()
+        # compute num samples to use based on sdf resolution
+        grasp_width_grid = obj.sdf.transform_pt_obj_to_grid(self.max_grasp_width_)
+        num_samples = int(Grasp.samples_per_grid * float(grasp_width_grid) / 2)  # at least 1 sample per grid
+
+        # get grasp endpoints in sdf frame
+        g1_world, g2_world = self.endpoints
+        c1_world, c2_world = contacts
+        # print(g1_world, g2_world)
+        # print(c1_world, c2_world)
+        c1_world = c1_world - 0.01 * self.axis_
+        c2_world = c2_world + 0.01 * self.axis_
+
+        # check for contact along approach
+        if check_approach:
+            approach_dist_grid = obj.sdf.transform_pt_obj_to_grid(approach_dist)
+            num_approach_samples = int(Grasp.samples_per_grid * approach_dist_grid / 2)  # at least 1 sample per grid
+            approach_axis = self.rotated_full_axis[:, 0]
+            approach_loa1 = ParallelJawPtGrasp3D.create_line_of_action(g1_world, -approach_axis, approach_dist, obj,
+                                                                       num_approach_samples, min_width=0)
+            approach_loa2 = ParallelJawPtGrasp3D.create_line_of_action(g2_world, -approach_axis, approach_dist, obj,
+                                                                       num_approach_samples, min_width=0)
+            c1_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa1, obj, vis=vis, strict=True)
+            c2_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa2, obj, vis=vis, strict=True)
+            approach_collision = c1_found or c2_found
+            if approach_collision:
+                # print('collision')
+                plt.clf()
+                return False, None
+
+        # get line of action            
+        line_of_action1 = ParallelJawPtGrasp3D.create_line_of_action(c1_world, self.axis_, self.open_width + 0.01, obj,
+                                                                     num_samples, min_width=self.close_width,
+                                                                     convert_grid=False)
+        line_of_action2 = ParallelJawPtGrasp3D.create_line_of_action(c2_world, -self.axis_, self.open_width + 0.01, obj,
+                                                                     num_samples, min_width=self.close_width,
+                                                                     convert_grid=False)
+
+        if vis:
+            ax = plt.gca(projection='3d')
+            surface = obj.sdf.surface_points()[0]
+            surface = surface[np.random.choice(surface.shape[0], 1000, replace=False)]
+            ax.scatter(surface[:, 0], surface[:, 1], surface[:, 2], '.',
+                       s=np.ones_like(surface[:, 0]) * 0.3, c='b')
+
+        # find contacts
+        
+        c1_found, c1 = ParallelJawPtGrasp3D.find_contact(line_of_action1, obj, vis=vis)
+        c2_found, c2 = ParallelJawPtGrasp3D.find_contact(line_of_action2, obj, vis=vis)
+        '''
+        for loa1_point in line_of_action1:
+            approach_dist_grid = obj.sdf.transform_pt_obj_to_grid(self.max_grasp_depth)
+            num_approach_samples = int(Grasp.samples_per_grid * approach_dist_grid / 2)  # at least 1 sample per grid
+            approach_axis = self.rotated_full_axis[:, 0]
+            approach_loa1 = ParallelJawPtGrasp3D.create_line_of_action(loa1_point, -approach_axis, self.max_grasp_depth, obj,
+                                                                       num_approach_samples, min_width=0)
+            c1_found, c1 = ParallelJawPtGrasp3D.find_contact(approach_loa1, obj, vis=vis, strict=False)
+            if c1_found:
+                break
+        for loa2_point in line_of_action2:
+            approach_dist_grid = obj.sdf.transform_pt_obj_to_grid(self.max_grasp_depth)
+            num_approach_samples = int(Grasp.samples_per_grid * approach_dist_grid / 2)  # at least 1 sample per grid
+            approach_axis = self.rotated_full_axis[:, 0]
+            approach_loa1 = ParallelJawPtGrasp3D.create_line_of_action(loa2_point, -approach_axis, self.max_grasp_depth, obj,
+                                                                       num_approach_samples, min_width=0)
+            c2_found, c2 = ParallelJawPtGrasp3D.find_contact(approach_loa1, obj, vis=vis, strict=False)
+            if c2_found:
+                break
+        '''
+        # if c1_found and c2_found:
+        #     print('yes')
+        # else:
+        #     print('no')
+        if vis:
+            ax = plt.gca(projection='3d')
+            ax.set_xlim3d(0, obj.sdf.dims_[0])
+            ax.set_ylim3d(0, obj.sdf.dims_[1])
+            ax.set_zlim3d(0, obj.sdf.dims_[2])
+            plt.draw()
+
+        contacts_found = c1_found and c2_found
+        return contacts_found, [c1, c2]
+
+    def vis_grasp(self, obj, *args, **kwargs):
+        if 'keep' not in kwargs or not kwargs['keep']:
+            plt.clf()
+
+        ax = plt.gca(projection='3d')
+        if 'show_obj' in kwargs and kwargs['show_obj']:
+            # plot the obj
+            surface = obj.sdf.surface_points()[0]
+            surface = surface[np.random.choice(surface.shape[0], 1000, replace=False)]
+            ax.scatter(surface[:, 0], surface[:, 1], surface[:, 2], '.',
+                       s=np.ones_like(surface[:, 0]) * 0.3, c='b')
+
+        # plot the center of grasp using grid
+        grasp_center_grid = obj.sdf.transform_pt_obj_to_grid(self.center)
+        ax.scatter(grasp_center_grid[0], grasp_center_grid[1], grasp_center_grid[2], marker='x', c='r')
+
+        # compute num samples to use based on sdf resolution
+        grasp_width_grid = obj.sdf.transform_pt_obj_to_grid(self.max_grasp_width_)
+        num_samples = int(Grasp.samples_per_grid * float(grasp_width_grid) / 2)  # at least 1 sample per grid
+
+        # get grasp endpoints in sdf frame
+        g1_world, g2_world = self.endpoints
+
+        # check for contact along approach
+        approach_dist = 0.1
+        approach_dist_grid = obj.sdf.transform_pt_obj_to_grid(approach_dist)
+        num_approach_samples = int(approach_dist_grid / 2)  # at least 1 sample per grid
+        approach_axis = self.rotated_full_axis[:, 0]
+        approach_loa1 = ParallelJawPtGrasp3D.create_line_of_action(g1_world, -approach_axis, approach_dist, obj,
+                                                                   num_approach_samples, min_width=0)
+        approach_loa2 = ParallelJawPtGrasp3D.create_line_of_action(g2_world, -approach_axis, approach_dist, obj,
+                                                                   num_approach_samples, min_width=0)
+        end1, end2 = approach_loa1[-1], approach_loa2[-1]
+        begin1, begin2 = approach_loa1[0], approach_loa2[0]
+        ax.plot([end1[0], end2[0]], [end1[1], end2[1]], [end1[2], end2[2]], 'r-', linewidth=5)
+        ax.plot([end1[0], begin1[0]], [end1[1], begin1[1]], [end1[2], begin1[2]], 'r-', linewidth=5)
+        ax.plot([begin2[0], end2[0]], [begin2[1], end2[1]], [begin2[2], end2[2]], 'r-', linewidth=5)
+        c1_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa1, obj, vis=False, strict=True)
+        c2_found, _ = ParallelJawPtGrasp3D.find_contact(approach_loa2, obj, vis=False, strict=True)
+        approach_collision = c1_found or c2_found
+        if approach_collision:
+            plt.clf()
+            return False
+
+        # get line of action
+        line_of_action1 = ParallelJawPtGrasp3D.create_line_of_action(g1_world, self.axis_, self.open_width, obj,
+                                                                     num_samples, min_width=self.close_width)
+        line_of_action2 = ParallelJawPtGrasp3D.create_line_of_action(g2_world, -self.axis_, self.open_width, obj,
+                                                                     num_samples, min_width=self.close_width)
+
+        # find contacts
+        c1_found, c1 = ParallelJawPtGrasp3D.find_contact(line_of_action1, obj, vis=False)
+        c2_found, c2 = ParallelJawPtGrasp3D.find_contact(line_of_action2, obj, vis=False)
+        begin1, begin2 = line_of_action1[0], line_of_action2[0]
+        end1, end2 = obj.sdf.transform_pt_obj_to_grid(c1.point), obj.sdf.transform_pt_obj_to_grid(c2.point)
+        print(end1, end2)
+        ax.plot([end1[0], begin1[0]], [end1[1], begin1[1]], [end1[2], begin1[2]], 'r-', linewidth=5)
+        ax.plot([begin2[0], end2[0]], [begin2[1], end2[1]], [begin2[2], end2[2]], 'r-', linewidth=5)
+        ax.scatter(end1[0], end1[1], end1[2], s=80, c='g')
+        ax.scatter(end2[0], end2[1], end2[2], s=80, c='g')
+
+        ax.set_xlim3d(0, obj.sdf.dims_[0])
+        ax.set_ylim3d(0, obj.sdf.dims_[1])
+        ax.set_zlim3d(0, obj.sdf.dims_[2])
+        plt.title(','.join([str(i) for i in args]))
+        plt.draw()
+
+        contacts_found = c1_found and c2_found
+        return contacts_found
+
+    @staticmethod
+    def create_line_of_action(g, axis, width, obj, num_samples, min_width=0, convert_grid=True):
+        """
+        Creates a straight line of action, or list of grid points, from a given point and direction in world or grid coords
+
+        Parameters
+        ----------
+        g : 3x1 :obj:`numpy.ndarray`
+            start point to create the line of action
+        axis : normalized 3x1 :obj:`numpy.ndarray`
+            normalized numpy 3 array of grasp direction
+        width : float
+            the grasp width
+        num_samples : int
+            number of discrete points along the line of action
+        convert_grid : bool
+            whether or not the points are specified in world coords
+
+        Returns
+        -------
+        line_of_action : :obj:`list` of 3x1 :obj:`numpy.ndarrays`
+            coordinates to pass through in 3D space for contact checking
+        """
+        num_samples = max(num_samples, 3)  # always at least 3 samples
+        line_of_action = [g + t * axis for t in
+                          np.linspace(0, float(width) / 2 - float(min_width) / 2, num=num_samples)]
+        if convert_grid:
+            as_array = np.array(line_of_action).T
+            transformed = obj.sdf.transform_pt_obj_to_grid(as_array)
+            line_of_action = list(transformed.T)
+        return line_of_action
+
+    @staticmethod
+    def find_contact(line_of_action, obj, vis=False, strict=False):
+        """
+        Find the point at which a point traveling along a given line of action hits a surface.
+
+        Parameters
+        ----------
+        line_of_action : :obj:`list` of 3x1 :obj:`numpy.ndarray`
+            the points visited as the fingers close (grid coords)
+        obj : :obj:`GraspableObject3D`
+            to check contacts on
+        vis : bool
+            whether or not to display the contact check (for debugging)
+
+        Returns
+        -------
+        contact_found : bool
+            whether or not the point contacts the object surface
+        contact : :obj:`Contact3D`
+            found along line of action (None if contact not found)
+        """
+        contact_found = False
+        pt_zc = None
+        pt_zc_world = None
+        contact = None
+        num_pts = len(line_of_action)
+        sdf_here = 0
+        sdf_before = 0
+        pt_grid = None
+        pt_before = None
+
+        # step along line of action, get points on surface when possible
+        i = 0
+        while i < num_pts and not contact_found:
+            # update loop vars
+            pt_before_before = pt_before
+            pt_before = pt_grid
+            sdf_before_before = sdf_before
+            sdf_before = sdf_here
+            pt_grid = line_of_action[i]
+
+            # visualize
+            if vis:
+                ax = plt.gca(projection='3d')
+                ax.scatter(pt_grid[0], pt_grid[1], pt_grid[2], c='r')
+
+            # check surface point
+            on_surface, sdf_here = obj.sdf.on_surface(pt_grid)
+            if on_surface:
+                contact_found = True
+                if strict:
+                    return contact_found, None
+
+                # quadratic approximation to find actual zero crossing
+                if i == 0:
+                    pt_after = line_of_action[i + 1]
+                    sdf_after = obj.sdf[pt_after]
+                    pt_after_after = line_of_action[i + 2]
+                    sdf_after_after = obj.sdf[pt_after_after]
+
+                    pt_zc = Sdf3D.find_zero_crossing_quadratic(pt_grid, sdf_here, pt_after, sdf_after, pt_after_after,
+                                                               sdf_after_after)
+
+                    # contact not yet found if next sdf value is smaller
+                    if pt_zc is None or np.abs(sdf_after) < np.abs(sdf_here):
+                        contact_found = False
+
+                elif i == len(line_of_action) - 1:
+                    pt_zc = Sdf3D.find_zero_crossing_quadratic(pt_before_before, sdf_before_before, pt_before,
+                                                               sdf_before, pt_grid, sdf_here)
+
+                    if pt_zc is None:
+                        contact_found = False
+
+                else:
+                    pt_after = line_of_action[i + 1]
+                    sdf_after = obj.sdf[pt_after]
+                    pt_zc = Sdf3D.find_zero_crossing_quadratic(pt_before, sdf_before, pt_grid, sdf_here, pt_after,
+                                                               sdf_after)
+
+                    # contact not yet found if next sdf value is smaller
+                    if pt_zc is None or np.abs(sdf_after) < np.abs(sdf_here):
+                        contact_found = False
+            i = i + 1
+
+        # visualization
+        if vis and contact_found:
+            ax = plt.gca(projection='3d')
+            ax.scatter(pt_zc[0], pt_zc[1], pt_zc[2], s=80, c='g')
+
+        if contact_found:
+            pt_zc_world = obj.sdf.transform_pt_grid_to_obj(pt_zc)
+            in_direction_grid = line_of_action[-1] - line_of_action[0]
+            in_direction_grid = in_direction_grid / np.linalg.norm(in_direction_grid)
+            in_direction = obj.sdf.transform_pt_grid_to_obj(in_direction_grid, direction=True)
+            contact = Contact3D(obj, pt_zc_world, in_direction=in_direction)
+            if contact.normal is None:
+                contact_found = False
+        return contact_found, contact
+
+    def _angle_aligned_with_stable_pose(self, stable_pose):
+        """
+        Returns the y-axis rotation angle that'd allow the current pose to align with stable pose.
+        """
+
+        def _argmin(f, a, b, n):
+            # finds the argmax x of f(x) in the range [a, b) with n samples
+            delta = (b - a) / n
+            min_y = f(a)
+            min_x = a
+            for i in range(1, n):
+                x = i * delta
+                y = f(x)
+                if y <= min_y:
+                    min_y = y
+                    min_x = x
+            return min_x
+
+        def _get_matrix_product_x_axis(grasp_axis, normal):
+            def matrix_product(theta):
+                R = ParallelJawPtGrasp3D._get_rotation_matrix_y(theta)
+                grasp_axis_rotated = np.dot(R, grasp_axis)
+                return abs(np.dot(normal, grasp_axis_rotated))
+
+            return matrix_product
+
+        stable_pose_normal = stable_pose.r[2, :]
+
+        theta = _argmin(
+            _get_matrix_product_x_axis(np.array([1, 0, 0]), np.dot(inv(self.unrotated_full_axis), stable_pose_normal)),
+            0, 2 * np.pi, 1000)
+        return theta
+
+    def grasp_y_axis_offset(self, theta):
+        """ Return a new grasp with the given approach angle.
+        
+        Parameters
+        ----------
+        theta : float
+            approach angle for the new grasp
+
+        Returns
+        -------
+        :obj:`ParallelJawPtGrasp3D`
+            grasp with the given approach angle
+        """
+        new_grasp = deepcopy(self)
+        new_grasp.approach_angle = theta + self.approach_angle
+        return new_grasp
+
+    def parallel_table(self, stable_pose):
+        """
+        Returns a grasp with approach_angle set to be perpendicular to the table normal specified in the given stable pose.
+
+        Parameters
+        ----------
+        stable_pose : :obj:`StablePose`
+            the pose specifying the table
+
+        Returns
+        -------
+        :obj:`ParallelJawPtGrasp3D`
+            aligned grasp
+        """
+        theta = self._angle_aligned_with_stable_pose(stable_pose)
+        new_grasp = deepcopy(self)
+        new_grasp.approach_angle = theta
+        return new_grasp
+
+    def _angle_aligned_with_table(self, table_normal):
+        """
+        Returns the y-axis rotation angle that'd allow the current pose to align with the table normal.
+        """
+
+        def _argmax(f, a, b, n):
+            # finds the argmax x of f(x) in the range [a, b) with n samples
+            delta = (b - a) / n
+            max_y = f(a)
+            max_x = a
+            for i in range(1, n):
+                x = i * delta
+                y = f(x)
+                if y >= max_y:
+                    max_y = y
+                    max_x = x
+            return max_x
+
+        def _get_matrix_product_x_axis(grasp_axis, normal):
+            def matrix_product(theta):
+                R = ParallelJawPtGrasp3D._get_rotation_matrix_y(theta)
+                grasp_axis_rotated = np.dot(R, grasp_axis)
+                return np.dot(normal, grasp_axis_rotated)
+
+            return matrix_product
+
+        theta = _argmax(
+            _get_matrix_product_x_axis(np.array([1, 0, 0]), np.dot(inv(self.unrotated_full_axis), -table_normal)), 0,
+            2 * np.pi, 64)
+        return theta
+
+    def perpendicular_table(self, stable_pose):
+        """
+        Returns a grasp with approach_angle set to be aligned width the table normal specified in the given stable pose.
+
+        Parameters
+        ----------
+        stable_pose : :obj:`StablePose` or :obj:`RigidTransform`
+            the pose specifying the orientation of the table
+
+        Returns
+        -------
+        :obj:`ParallelJawPtGrasp3D`
+            aligned grasp
+        """
+        if isinstance(stable_pose, StablePose):
+            table_normal = stable_pose.r[2, :]
+        else:
+            table_normal = stable_pose.rotation[2, :]
+        theta = self._angle_aligned_with_table(table_normal)
+        new_grasp = deepcopy(self)
+        new_grasp.approach_angle = theta
+        return new_grasp
+
+    def project_camera(self, T_obj_camera, camera_intr):
+        """ Project a grasp for a given gripper into the camera specified by a set of intrinsics.
+        
+        Parameters
+        ----------
+        T_obj_camera : :obj:`autolab_core.RigidTransform`
+            rigid transformation from the object frame to the camera frame
+        camera_intr : :obj:`perception.CameraIntrinsics`
+            intrinsics of the camera to use
+        """
+        # compute pose of grasp in camera frame
+        T_grasp_camera = T_obj_camera * self.T_grasp_obj
+        y_axis_camera = T_grasp_camera.y_axis[:2]
+        if np.linalg.norm(y_axis_camera) > 0:
+            y_axis_camera = y_axis_camera / np.linalg.norm(y_axis_camera)
+
+        # compute grasp axis rotation in image space
+        rot_z = np.arccos(y_axis_camera[0])
+        if y_axis_camera[1] < 0:
+            rot_z = -rot_z
+        while rot_z < 0:
+            rot_z += 2 * np.pi
+        while rot_z > 2 * np.pi:
+            rot_z -= 2 * np.pi
+
+        # compute grasp center in image space
+        t_grasp_camera = T_grasp_camera.translation
+        p_grasp_camera = Point(t_grasp_camera, frame=camera_intr.frame)
+        u_grasp_camera = camera_intr.project(p_grasp_camera)
+        d_grasp_camera = t_grasp_camera[2]
+        return Grasp2D(u_grasp_camera, rot_z, d_grasp_camera,
+                       width=self.open_width,
+                       camera_intr=camera_intr)
+
+    @staticmethod
+    def grasp_from_contact_and_axis_on_grid(obj, grasp_c1_world, grasp_axis_world, grasp_width_world, grasp_angle=0,
+                                            jaw_width_world=0,
+                                            min_grasp_width_world=0, vis=False, backup=0.5):
+        """
+        Creates a grasp from a single contact point in grid coordinates and direction in grid coordinates.
+        
+        Parameters
+        ----------
+        obj : :obj:`GraspableObject3D`
+            object to create grasp for
+        grasp_c1_grid : 3x1 :obj:`numpy.ndarray`
+            contact point 1 in world
+        grasp_axis : normalized 3x1 :obj:`numpy.ndarray`
+           normalized direction of the grasp in world
+        grasp_width_world : float
+            grasp_width in world coords
+        jaw_width_world : float
+            width of jaws in world coords
+        min_grasp_width_world : float
+            min closing width of jaws
+        vis : bool
+            whether or not to visualize the grasp
+        
+        Returns
+        -------
+        g : :obj:`ParallelJawGrasp3D`
+            grasp created by finding the second contact
+        c1 : :obj:`Contact3D`
+            first contact point on the object
+        c2 : :obj:`Contact3D`
+            second contact point on the object
+        """
+        # transform to grid basis
+        grasp_axis_world = grasp_axis_world / np.linalg.norm(grasp_axis_world)
+        grasp_axis_grid = obj.sdf.transform_pt_obj_to_grid(grasp_axis_world, direction=True)
+        grasp_width_grid = obj.sdf.transform_pt_obj_to_grid(grasp_width_world)
+        min_grasp_width_grid = obj.sdf.transform_pt_obj_to_grid(min_grasp_width_world)
+        grasp_c1_grid = obj.sdf.transform_pt_obj_to_grid(
+            grasp_c1_world) - backup * grasp_axis_grid  # subtract to find true point
+        num_samples = int(2 * grasp_width_grid)  # at least 2 samples per grid
+        g2 = grasp_c1_grid + (grasp_width_grid - backup) * grasp_axis_grid
+
+        # get line of action
+        line_of_action1 = ParallelJawPtGrasp3D.create_line_of_action(grasp_c1_grid, grasp_axis_grid, grasp_width_grid,
+                                                                     obj, num_samples,
+                                                                     min_width=min_grasp_width_grid, convert_grid=False)
+        line_of_action2 = ParallelJawPtGrasp3D.create_line_of_action(g2, -grasp_axis_grid, 2 * grasp_width_grid, obj,
+                                                                     num_samples,
+                                                                     min_width=0, convert_grid=False)
+        if vis:
+            obj.sdf.scatter()
+            ax = plt.gca(projection='3d')
+            ax.scatter(grasp_c1_grid[0] - grasp_axis_grid[0], grasp_c1_grid[1] - grasp_axis_grid[1],
+                       grasp_c1_grid[2] - grasp_axis_grid[2], c='r')
+            ax.scatter(grasp_c1_grid[0], grasp_c1_grid[1], grasp_c1_grid[2], s=80, c='b')
+
+        # compute the contact points on the object
+        contact1_found, c1 = ParallelJawPtGrasp3D.find_contact(line_of_action1, obj, vis=vis)
+        contact2_found, c2 = ParallelJawPtGrasp3D.find_contact(line_of_action2, obj, vis=vis)
+
+        if vis:
+            ax.set_xlim3d(0, obj.sdf.dims_[0])
+            ax.set_ylim3d(0, obj.sdf.dims_[1])
+            ax.set_zlim3d(0, obj.sdf.dims_[2])
+            plt.draw()
+        if not contact1_found or not contact2_found or np.linalg.norm(c1.point - c2.point) <= min_grasp_width_world:
+            logging.debug('No contacts found for grasp')
+            return None, None, None
+
+        # create grasp
+        grasp_center = ParallelJawPtGrasp3D.center_from_endpoints(c1.point, c2.point)
+        grasp_axis = ParallelJawPtGrasp3D.axis_from_endpoints(c1.point, c2.point)
+        configuration = ParallelJawPtGrasp3D.configuration_from_params(grasp_center, grasp_axis, grasp_width_world,
+                                                                       grasp_angle, jaw_width_world)
+        return ParallelJawPtGrasp3D(configuration), c1, c2  # relative to object
+
+    def surface_information(self, graspable, width=2e-2, num_steps=21, direction=None):
+        """ Return the patch surface information at the contacts that this grasp makes on a graspable.
+
+        Parameters
+        ----------
+        graspable : :obj:`GraspableObject3D`
+            object to get surface information for
+        width : float
+            width of the window in obj frame
+        num_steps : int
+            number of steps
+
+        Returns
+        -------
+        :obj:`list` of :obj:`SurfaceWindow`
+             surface patches, one for each contact
+        """
+        return graspable.surface_information(self, width, num_steps, direction1=self.axis_, direction2=-self.axis_)
+
+
+class VacuumPoint(Grasp):
+    """ Defines a vacuum target point and axis in 3D space (5 DOF)
+    """
+
+    def __init__(self, configuration, frame='object', grasp_id=None):
+        center, axis = VacuumPoint.params_from_configuration(configuration)
+        self._center = center
+        self._axis = axis
+        self.frame_ = frame
+
+    @property
+    def center(self):
+        return self._center
+
+    @property
+    def axis(self):
+        return self._axis
+
+    @property
+    def frame(self):
+        return self._frame
+
+    @property
+    def configuration(self):
+        return VacuumPoint.configuration_from_params(self._center, self._axis)
+
+    @staticmethod
+    def configuration_from_params(center, axis):
+        """ Converts grasp parameters to a configuration vector. """
+        if np.abs(np.linalg.norm(axis) - 1.0) > 1e-5:
+            raise ValueError('Illegal vacuum axis. Must be norm one')
+        configuration = np.zeros(6)
+        configuration[0:3] = center
+        configuration[3:6] = axis
+        return configuration
+
+    @staticmethod
+    def params_from_configuration(configuration):
+        """ Converts configuration vector into vacuum grasp parameters.
+        
+        Returns
+        -------
+        center : :obj:`numpy.ndarray`
+            center of grasp in 3D space
+        axis : :obj:`numpy.ndarray`
+            normalized axis of grasp in 3D space
+        """
+        if not isinstance(configuration, np.ndarray) or configuration.shape[0] != 6:
+            raise ValueError('Configuration must be numpy ndarray of size 6')
+        if np.abs(np.linalg.norm(configuration[3:6]) - 1.0) > 1e-5:
+            raise ValueError('Illegal vacuum axis. Must be norm one')
+        return configuration[0:3], configuration[3:6]

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/grasp_quality_config.py

@@ -0,0 +1,201 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+"""
+Configurations for grasp quality computation.
+Author: Jeff Mahler
+"""
+from abc import ABCMeta, abstractmethod
+
+import copy
+import itertools as it
+import logging
+import matplotlib.pyplot as plt
+try:
+    import mayavi.mlab as mlab
+except:
+    # logging.warning('Failed to import mayavi')
+    pass
+
+import numpy as np
+import os
+import sys
+import time
+
+import IPython
+
+# class GraspQualityConfig(object, metaclass=ABCMeta):
+class GraspQualityConfig(object):
+    """
+    Base wrapper class for parameters used in grasp quality computation.
+    Used to elegantly enforce existence and type of required parameters.
+
+    Attributes
+    ----------
+    config : :obj:`dict`
+        dictionary mapping parameter names to parameter values
+    """
+    __metaclass__ = ABCMeta
+    def __init__(self, config):
+        # check valid config
+        self.check_valid(config)
+
+        # parse config
+        for key, value in list(config.items()):
+            setattr(self, key, value)
+
+    def contains(self, key):
+        """ Checks whether or not the key is supported """
+        if key in list(self.__dict__.keys()):
+            return True
+        return False
+
+    def __getattr__(self, key):
+        if self.contains(key):
+            return object.__getattribute__(self, key)
+        return None
+
+    def __getitem__(self, key):
+        if self.contains(key):
+            return object.__getattribute__(self, key)
+        raise KeyError('Key %s not found' %(key))
+    
+    def keys(self):
+        return list(self.__dict__.keys())
+
+    @abstractmethod
+    def check_valid(self, config):
+        """ Raise an exception if the config is missing required keys """
+        pass
+
+class QuasiStaticGraspQualityConfig(GraspQualityConfig):
+    """
+    Parameters for quasi-static grasp quality computation.
+
+    Attributes
+    ----------
+    config : :obj:`dict`
+        dictionary mapping parameter names to parameter values
+
+    Notes
+    -----
+    Required configuration key-value pairs in Other Parameters.
+
+    Other Parameters
+    ----------------
+    quality_method : :obj:`str`
+        string name of quasi-static quality metric
+    friction_coef : float
+        coefficient of friction at contact point
+    num_cone_faces : int
+        number of faces to use in friction cone approximation
+    soft_fingers : bool
+        whether to use a soft finger model
+    quality_type : :obj:`str`
+        string name of grasp quality type (e.g. quasi-static, robust quasi-static)
+    check_approach : bool
+        whether or not to check the approach direction
+    """
+    REQUIRED_KEYS = ['quality_method',
+                     'friction_coef',
+                     'num_cone_faces',
+                     'soft_fingers',
+                     'quality_type',
+                     'check_approach',
+                     'all_contacts_required']
+
+    def __init__(self, config):
+        GraspQualityConfig.__init__(self, config)
+
+    def __copy__(self):
+        """ Makes a copy of the config """
+        obj_copy = QuasiStaticGraspQualityConfig(self.__dict__)
+        return obj_copy
+
+    def check_valid(self, config):
+        for key in QuasiStaticGraspQualityConfig.REQUIRED_KEYS:
+            if key not in list(config.keys()):
+                raise ValueError('Invalid configuration. Key %s must be specified' %(key))
+
+class RobustQuasiStaticGraspQualityConfig(GraspQualityConfig):
+    """
+    Parameters for quasi-static grasp quality computation.
+
+    Attributes
+    ----------
+    config : :obj:`dict`
+        dictionary mapping parameter names to parameter values
+
+    Notes
+    -----
+    Required configuration key-value pairs in Other Parameters.
+
+    Other Parameters
+    ----------------
+    quality_method : :obj:`str`
+        string name of quasi-static quality metric
+    friction_coef : float
+        coefficient of friction at contact point
+    num_cone_faces : int
+        number of faces to use in friction cone approximation
+    soft_fingers : bool
+        whether to use a soft finger model
+    quality_type : :obj:`str`
+        string name of grasp quality type (e.g. quasi-static, robust quasi-static)
+    check_approach : bool
+        whether or not to check the approach direction
+    num_quality_samples : int
+        number of samples to use
+    """
+    ROBUST_REQUIRED_KEYS = ['num_quality_samples']
+
+    def __init__(self, config):
+        GraspQualityConfig.__init__(self, config)
+
+    def __copy__(self):
+        """ Makes a copy of the config """
+        obj_copy = RobustQuasiStaticGraspQualityConfig(self.__dict__)
+        return obj_copy
+        
+    def check_valid(self, config):
+        required_keys = QuasiStaticGraspQualityConfig.REQUIRED_KEYS + \
+            RobustQuasiStaticGraspQualityConfig.ROBUST_REQUIRED_KEYS
+        for key in required_keys:
+            if key not in list(config.keys()):
+                raise ValueError('Invalid configuration. Key %s must be specified' %(key))        
+
+class GraspQualityConfigFactory:
+    """ Helper class to automatically create grasp quality configurations of different types. """
+    @staticmethod
+    def create_config(config):
+        """ Automatically create a quality config from a dictionary.
+
+        Parameters
+        ----------
+        config : :obj:`dict`
+            dictionary mapping parameter names to parameter values
+        """
+        if config['quality_type'] == 'quasi_static':
+            return QuasiStaticGraspQualityConfig(config)
+        elif config['quality_type'] == 'robust_quasi_static':
+            return RobustQuasiStaticGraspQualityConfig(config)
+        else:
+            raise ValueError('Quality config type %s not supported' %(config['type']))

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/grasp_quality_function.py

@@ -0,0 +1,226 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+"""
+User-friendly functions for computing grasp quality metrics.
+Author: Jeff Mahler
+"""
+from abc import ABCMeta, abstractmethod
+
+import copy
+import itertools as it
+import logging
+import matplotlib.pyplot as plt
+
+import numpy as np
+import os
+import scipy.stats
+import sys
+import time
+
+from .grasp import Grasp
+from .graspable_object import GraspableObject
+from .graspable_object import GraspQualityConfig
+from .robust_grasp_quality import RobustPointGraspMetrics3D
+from .random_variables import GraspableObjectPoseGaussianRV, ParallelJawGraspPoseGaussianRV, ParamsGaussianRV
+from .quality import PointGraspMetrics3D
+
+from autolab_core import RigidTransform
+import IPython
+
+class GraspQualityResult:
+    """ Stores the results of grasp quality computation.
+
+    Attributes
+    ----------
+    quality : float
+        value of quality
+    uncertainty : float
+        uncertainty estimate of the quality value
+    quality_config : :obj:`GraspQualityConfig`
+    """
+    def __init__(self, quality, uncertainty=0.0, quality_config=None):
+        self.quality = quality
+        self.uncertainty = uncertainty
+        self.quality_config = quality_config            
+
+# class GraspQualityFunction(object, metaclass=ABCMeta):
+class GraspQualityFunction(object):
+    """
+    Abstraction for grasp quality functions to make scripts for labeling with quality functions simple and readable.
+
+    Attributes
+    ----------
+    graspable : :obj:`GraspableObject3D`
+        object to evaluate grasp quality on
+    quality_config : :obj:`GraspQualityConfig`
+        set of parameters to evaluate grasp quality
+    """
+    __metaclass__ = ABCMeta
+
+
+    def __init__(self, graspable, quality_config):
+        # check valid types
+        if not isinstance(graspable, GraspableObject):
+            raise ValueError('Must provide GraspableObject')
+        if not isinstance(quality_config, GraspQualityConfig):
+            raise ValueError('Must provide GraspQualityConfig')
+
+        # set member variables
+        self.graspable_ = graspable
+        self.quality_config_ = quality_config
+
+        self._setup()
+
+    def __call__(self, grasp):
+        return self.quality(grasp)
+
+    @abstractmethod
+    def _setup(self):
+        """ Sets up common variables for grasp quality evaluations """
+        pass
+
+    @abstractmethod
+    def quality(self, grasp):
+        """ Compute grasp quality.
+
+        Parameters
+        ----------
+        grasp : :obj:`GraspableObject3D`
+            grasp to quality quality on
+
+        Returns
+        -------
+        :obj:`GraspQualityResult`
+            result of quality computation
+        """
+        pass
+        
+class QuasiStaticQualityFunction(GraspQualityFunction):
+    """ Grasp quality metric using a quasi-static model.
+    """
+    def __init__(self, graspable, quality_config):
+        GraspQualityFunction.__init__(self, graspable, quality_config)
+
+    @property
+    def graspable(self):
+        return self.graspable_
+
+    @graspable.setter
+    def graspable(self, obj):
+        self.graspable_ = obj
+
+    def _setup(self):
+        if self.quality_config_.quality_type != 'quasi_static':
+            raise ValueError('Quality configuration must be quasi static')
+
+    def quality(self, grasp):
+        """ Compute grasp quality using a quasistatic method.
+
+        Parameters
+        ----------
+        grasp : :obj:`GraspableObject3D`
+            grasp to quality quality on
+
+        Returns
+        -------
+        :obj:`GraspQualityResult`
+            result of quality computation
+        """
+        if not isinstance(grasp, Grasp):
+            raise ValueError('Must provide Grasp object to compute quality')
+
+        quality = PointGraspMetrics3D.grasp_quality(grasp, self.graspable_,
+                                                    self.quality_config_)
+        return GraspQualityResult(quality, quality_config=self.quality_config_)
+
+class RobustQuasiStaticQualityFunction(GraspQualityFunction):
+    """ Grasp quality metric using a robust quasi-static model (average over random perturbations)
+    """
+    def __init__(self, graspable, quality_config, T_obj_world=RigidTransform(from_frame='obj', to_frame='world')):
+        self.T_obj_world_ = T_obj_world
+        GraspQualityFunction.__init__(self, graspable, quality_config)
+
+    @property
+    def graspable(self):
+        return self.graspable_
+
+    @graspable.setter
+    def graspable(self, obj):
+        self.graspable_ = obj
+        self._setup()
+
+    def _setup(self):
+        if self.quality_config_.quality_type != 'robust_quasi_static':
+            raise ValueError('Quality configuration must be robust quasi static')
+        self.graspable_rv_ = GraspableObjectPoseGaussianRV(self.graspable_,
+                                                           self.T_obj_world_,
+                                                           self.quality_config_.obj_uncertainty)
+        self.params_rv_ = ParamsGaussianRV(self.quality_config_,
+                                           self.quality_config_.params_uncertainty)
+
+    def quality(self, grasp):
+        """ Compute grasp quality using a robust quasistatic method.
+
+        Parameters
+        ----------
+        grasp : :obj:`GraspableObject3D`
+            grasp to quality quality on
+
+        Returns
+        -------
+        :obj:`GraspQualityResult`
+            result of quality computation
+        """
+        if not isinstance(grasp, Grasp):
+            raise ValueError('Must provide Grasp object to compute quality')
+        grasp_rv = ParallelJawGraspPoseGaussianRV(grasp,
+                                                  self.quality_config_.grasp_uncertainty)
+        mean_q, std_q = RobustPointGraspMetrics3D.expected_quality(grasp_rv,
+                                                                   self.graspable_rv_,
+                                                                   self.params_rv_,
+                                                                   self.quality_config_)
+        return GraspQualityResult(mean_q, std_q, quality_config=self.quality_config_)
+
+class GraspQualityFunctionFactory:
+    @staticmethod
+    def create_quality_function(graspable, quality_config):
+        """ Creates a quality function for a particular object based on a configuration, which can be passed directly from a configuration file.
+
+        Parameters
+        ----------
+        graspable : :obj:`GraspableObject3D`
+            object to create quality function for
+        quality_config : :obj:`GraspQualityConfig`
+            parameters for quality function
+        """
+        # check valid types
+        if not isinstance(graspable, GraspableObject):
+            raise ValueError('Must provide GraspableObject')
+        if not isinstance(quality_config, GraspQualityConfig):
+            raise ValueError('Must provide GraspQualityConfig')
+        
+        if quality_config.quality_type == 'quasi_static':
+            return QuasiStaticQualityFunction(graspable, quality_config)
+        elif quality_config.quality_type == 'robust_quasi_static':
+            return RobustQuasiStaticQualityFunction(graspable, quality_config)
+        else:
+            raise ValueError('Grasp quality type %s not supported' %(quality_config.quality_type))

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/graspable_object.py

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+"""
+Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+Permission to use, copy, modify, and distribute this software and its documentation for educational,
+research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+hereby granted, provided that the above copyright notice, this paragraph and the following two
+paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+
+IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+"""
+"""
+Encapsulates data and operations on a 2D or 3D object that can be grasped
+Author: Jeff Mahler
+"""
+from abc import ABCMeta, abstractmethod
+
+import copy
+import logging
+import numpy as np
+
+from .meshpy import mesh as m
+from .meshpy import sdf as s
+
+import IPython
+import matplotlib.pyplot as plt
+
+from autolab_core import RigidTransform, SimilarityTransform
+
+
+# class GraspableObject(metaclass=ABCMeta):
+class GraspableObject:
+    """ Encapsulates geometric structures for computing contact in grasping.
+    
+    Attributes
+    ----------
+    sdf : :obj:`Sdf3D`
+        signed distance field, for quickly computing contact points
+    mesh : :obj:`Mesh3D`
+        3D triangular mesh to specify object geometry, should match SDF
+    key : :obj:`str`
+        object identifier, usually given from the database
+    model_name : :obj:`str`
+        name of the object mesh as a .obj file, for use in collision checking
+    mass : float
+        mass of the object
+    convex_pieces : :obj:`list` of :obj:`Mesh3D`
+        convex decomposition of the object geom for collision checking
+    """
+    __metaclass__ = ABCMeta
+
+    def __init__(self, sdf, mesh, key='', model_name='', mass=1.0, convex_pieces=None):
+        self.sdf_ = sdf
+        self.mesh_ = mesh
+
+        self.key_ = key
+        self.model_name_ = model_name # for OpenRave usage, gross!
+        self.mass_ = mass
+        self.convex_pieces_ = convex_pieces
+
+    @property
+    def sdf(self):
+        return self.sdf_
+
+    @property
+    def mesh(self):
+        return self.mesh_
+
+    @property
+    def mass(self):
+        return self.mass_
+
+    @property
+    def key(self):
+        return self.key_
+
+    @property
+    def model_name(self):
+        return self.model_name_
+
+    @property
+    def convex_pieces(self):
+        return self.convex_pieces_
+
+class GraspableObject3D(GraspableObject):
+    """ 3D Graspable object for computing contact in grasping.
+    
+    Attributes
+    ----------
+    sdf : :obj:`Sdf3D`
+        signed distance field, for quickly computing contact points
+    mesh : :obj:`Mesh3D`
+        3D triangular mesh to specify object geometry, should match SDF
+    key : :obj:`str`
+        object identifier, usually given from the database
+    model_name : :obj:`str`
+        name of the object mesh as a .obj file, for use in collision checking
+    mass : float
+        mass of the object
+    convex_pieces : :obj:`list` of :obj:`Mesh3D`
+        convex decomposition of the object geom for collision checking
+    """
+    def __init__(self, sdf, mesh, key='',
+                 model_name='', mass=1.0,
+                 convex_pieces=None):
+        if not isinstance(sdf, s.Sdf3D):
+            raise ValueError('Must initialize 3D graspable object with 3D sdf')
+        if not isinstance(mesh, m.Mesh3D):
+            raise ValueError('Must initialize 3D graspable object with 3D mesh')
+
+        GraspableObject.__init__(self, sdf, mesh, key=key,
+                                 model_name=model_name, mass=mass,
+                                 convex_pieces=convex_pieces)
+
+    def moment_arm(self, x):
+        """ Computes the moment arm to a point x.
+
+        Parameters
+        ----------
+        x : 3x1 :obj:`numpy.ndarray`
+            point to get moment arm for
+        
+        Returns
+        -------
+        3x1 :obj:`numpy.ndarray`
+        """
+        return x - self.mesh.center_of_mass
+
+    def rescale(self, scale):
+        """ Rescales uniformly by a given factor.
+
+        Parameters
+        ----------
+        scale : float
+            the amount to scale the object
+
+        Returns
+        -------
+        :obj:`GraspableObject3D`
+            the graspable object rescaled by the given factor
+        """
+        stf = SimilarityTransform(scale=scale)
+        sdf_rescaled = self.sdf_.rescale(scale)
+        mesh_rescaled = self.mesh_.transform(stf)
+        convex_pieces_rescaled = None
+        if self.convex_pieces_ is not None:
+            convex_pieces_rescaled = []
+            for convex_piece in self.convex_pieces_:
+                convex_piece_rescaled = convex_piece.transform(stf)
+                convex_pieces_rescaled.append(convex_piece_rescaled)
+        return GraspableObject3D(sdf_rescaled, mesh_rescaled, key=self.key,
+                                 model_name=self.model_name, mass=self.mass,
+                                 convex_pieces=convex_pieces_rescaled)
+
+    def transform(self, delta_T):
+        """ Transform by a delta transform.
+
+
+        Parameters
+        ----------
+        delta_T : :obj:`RigidTransform`
+            the transformation from the current reference frame to the alternate reference frame
+        
+        Returns
+        -------
+        :obj:`GraspableObject3D`
+             graspable object trasnformed by the delta
+        """
+        sdf_tf = self.sdf_.transform(delta_T)
+        mesh_tf = self.mesh_.transform(delta_T)
+        convex_pieces_tf = None
+        if self.convex_pieces_ is not None:
+            convex_pieces_tf = []
+            for convex_piece in self.convex_pieces_:
+                convex_piece_tf = convex_piece.transform(delta_T)
+                convex_pieces_tf.append(convex_piece_tf)
+        return GraspableObject3D(sdf_tf, mesh_tf, key=self.key,
+                                 model_name=self.model_name, mass=self.mass,
+                                 convex_pieces=convex_pieces_tf)
+
+    def surface_information(self, grasp, width, num_steps, plot=False, direction1=None, direction2=None):
+        """ Returns the patches on this object for a given grasp.
+
+        Parameters
+        ----------
+        grasp : :obj:`ParallelJawPtGrasp3D`
+            grasp to get the patch information for
+        width : float
+            width of jaw opening
+        num_steps : int
+            number of steps
+        plot : bool
+            whether to plot the intermediate computation, for debugging
+        direction1 : normalized 3x1 :obj:`numpy.ndarray`
+            direction along which to compute the surface information for the first jaw, if None then defaults to grasp axis
+        direction2 : normalized 3x1 :obj:`numpy.ndarray`
+            direction along which to compute the surface information for the second jaw, if None then defaults to grasp axis
+       
+        Returns
+        -------
+        :obj:`list` of :obj:`SurfaceWindow`
+             surface patches, one for each contact
+       """
+        contacts_found, contacts = grasp.close_fingers(self)#, vis=True)
+        if not contacts_found:
+            raise ValueError('Failed to find contacts')
+        contact1, contact2 = contacts
+
+        if plot:
+            plt.figure()
+            contact1.plot_friction_cone()
+            contact2.plot_friction_cone()
+
+            ax = plt.gca(projection = '3d')
+            ax.set_xlim3d(0, self.sdf.dims_[0])
+            ax.set_ylim3d(0, self.sdf.dims_[1])
+            ax.set_zlim3d(0, self.sdf.dims_[2])
+
+        window1 = contact1.surface_information(width, num_steps, direction=direction1)
+        window2 = contact2.surface_information(width, num_steps, direction=direction2)
+        return window1, window2, contact1, contact2
+

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2017 Berkeley AUTOLAB & University of California, Berkeley
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/__init__.py

@@ -0,0 +1,26 @@
+# try:
+#     # from meshpy import meshrender
+#     import meshrender
+# except:
+#     print('Unable to import meshrender shared library! Rendering will not work. Likely due to missing Boost.Numpy')
+#     print('Boost.Numpy can be installed following the instructions in https://github.com/ndarray/Boost.NumPy')
+from .mesh import Mesh3D
+# from .image_converter import ImageToMeshConverter
+from .obj_file import ObjFile
+# from .off_file import OffFile
+# from .render_modes import RenderMode
+from .sdf import Sdf, Sdf3D
+from .sdf_file import SdfFile
+from .stable_pose import StablePose
+from . import mesh
+from . import obj_file
+from . import sdf_file
+# from .stp_file import StablePoseFile
+# from .urdf_writer import UrdfWriter, convex_decomposition
+# from .lighting import MaterialProperties, LightingProperties
+
+# from .mesh_renderer import ViewsphereDiscretizer, PlanarWorksurfaceDiscretizer, VirtualCamera, SceneObject
+# from .random_variables import CameraSample, RenderSample, UniformViewsphereRandomVariable, \
+    # UniformPlanarWorksurfaceRandomVariable, UniformPlanarWorksurfaceImageRandomVariable
+
+__all__ = ['Mesh3D','ObjFile','Sdf','Sdf3D','SdfFile','StablePose','mesh','obj_file','sdf_file']

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/mesh.py

@@ -0,0 +1,1957 @@
+"""
+Encapsulates mesh for grasping operations
+Authors: Jeff Mahler and Matt Matl
+"""
+import math
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+import os
+import random
+from subprocess import Popen
+import sys
+
+import numpy as np
+import scipy.spatial as ss
+import sklearn.decomposition
+import trimesh as tm
+
+from autolab_core import RigidTransform, Point, Direction, PointCloud, NormalCloud
+
+from . import obj_file
+from . import stable_pose as sp
+
+
+class Mesh3D(object):
+    """A triangular mesh for a three-dimensional shape representation.
+
+    Attributes
+    ----------
+    vertices : :obj:`numpy.ndarray` of float
+        A #verts by 3 array, where each row contains an ordered
+        [x,y,z] set that describes one vertex.
+    triangles : :obj:`numpy.ndarray`  of int
+        A #tris by 3 array, where each row contains indices of vertices in
+        the `vertices` array that are part of the triangle.
+    normals : :obj:`numpy.ndarray` of float
+        A #normals by 3 array, where each row contains a normalized
+        vector. This list should contain one norm per vertex.
+    density : float
+        The density of the mesh.
+    center_of_mass : :obj:`numpy.ndarray` of float
+        The 3D location of the mesh's center of mass.
+    mass : float
+        The mass of the mesh (read-only).
+    inertia : :obj:`numpy.ndarray` of float
+        The 3x3 inertial matrix of the mesh (read-only).
+    bb_center : :obj:`numpy.ndarray` of float
+        The 3D location of the center of the mesh's minimal bounding box
+        (read-only).
+    centroid : :obj:`numpy.ndarray` of float
+        The 3D location of the mesh's vertex mean (read-only).
+    """
+
+    ScalingTypeMin = 0
+    ScalingTypeMed = 1
+    ScalingTypeMax = 2
+    ScalingTypeRelative = 3
+    ScalingTypeDiag = 4
+    OBJ_EXT = '.obj'
+    PROC_TAG = '_proc'
+    C_canonical = np.array([[1.0 / 60.0, 1.0 / 120.0, 1.0 / 120.0],
+                            [1.0 / 120.0, 1.0 / 60.0, 1.0 / 120.0],
+                            [1.0 / 120.0, 1.0 / 120.0, 1.0 / 60.0]])
+
+    def __init__(self, vertices, triangles, normals=None,
+                 density=1.0, center_of_mass=None,
+                 trimesh=None, T_obj_world=RigidTransform(from_frame='obj', to_frame='world')):
+        """Construct a 3D triangular mesh.
+
+        Parameters
+        ----------
+        vertices : :obj:`numpy.ndarray` of float
+            A #verts by 3 array, where each row contains an ordered
+            [x,y,z] set that describes one vertex.
+        triangles : :obj:`numpy.ndarray`  of int
+            A #tris by 3 array, where each row contains indices of vertices in
+            the `vertices` array that are part of the triangle.
+        normals : :obj:`numpy.ndarray` of float
+            A #normals by 3 array, where each row contains a normalized
+            vector. This list should contain one norm per vertex.
+        density : float
+            The density of the mesh.
+        center_of_mass : :obj:`numpy.ndarray` of float
+            The 3D location of the mesh's center of mass.
+        uniform_com : bool
+            Whether or not to assume a uniform mass density for center of mass comp
+        """
+        if vertices is not None:
+            vertices = np.array(vertices)
+        self.vertices_ = vertices
+
+        if triangles is not None:
+            triangles = np.array(triangles)
+        self.triangles_ = triangles
+
+        if normals is not None:
+            normals = np.array(normals)
+            if normals.shape[0] == 3:
+                normals = normals.T
+        self.normals_ = normals
+
+        self.density_ = density
+
+        self.center_of_mass_ = center_of_mass
+
+        # Read-Only parameter initialization
+        self.mass_ = None
+        self.inertia_ = None
+        self.bb_center_ = self._compute_bb_center()
+        self.centroid_ = self._compute_centroid()
+        self.surface_area_ = None
+        self.face_dag_ = None
+        self.trimesh_ = trimesh
+        self.T_obj_world_ = T_obj_world
+
+        if self.center_of_mass_ is None:
+            if self.is_watertight:
+                self.center_of_mass_ = np.array(self._compute_com_uniform())
+            else:
+                self.center_of_mass_ = np.array(self.bb_center_)
+
+    ##################################################################
+    # Properties
+    ##################################################################
+
+    # =============================================
+    # Read-Write Properties
+    # =============================================
+    @property
+    def vertices(self):
+        """:obj:`numpy.ndarray` of float : A #verts by 3 array,
+        where each row contains an ordered
+        [x,y,z] set that describes one vertex.
+        """
+        return self.vertices_
+
+    @vertices.setter
+    def vertices(self, v):
+        self.vertices_ = np.array(v)
+        self.mass_ = None
+        self.inertia_ = None
+        self.normals_ = None
+        self.surface_area_ = None
+        self.bb_center_ = self._compute_bb_center()
+        self.centroid_ = self._compute_centroid()
+
+    @property
+    def triangles(self):
+        """:obj:`numpy.ndarray` of int : A #tris by 3 array,
+        where each row contains indices of vertices in
+        the `vertices` array that are part of the triangle.
+        """
+        return self.triangles_
+
+    @triangles.setter
+    def triangles(self, t):
+        self.triangles_ = np.array(t)
+        self.mass_ = None
+        self.inertia_ = None
+        self.surface_area_ = None
+
+    @property
+    def normals(self):
+        """:obj:`numpy.ndarray` of float :
+        A #normals by 3 array, where each row contains a normalized
+        vector. This list should contain one norm per vertex.
+        """
+        return self.normals_
+
+    @normals.setter
+    def normals(self, n):
+        self.normals_ = np.array(n)
+
+    @property
+    def density(self):
+        """float : The density of the mesh.
+        """
+        return self.density_
+
+    @density.setter
+    def density(self, d):
+        self.density_ = d
+        self.mass_ = None
+        self.inertia_ = None
+
+    @property
+    def center_of_mass(self):
+        """:obj:`numpy.ndarray` of float :
+        The 3D location of the mesh's center of mass.
+        """
+        return self.center_of_mass_
+
+    @center_of_mass.setter
+    def center_of_mass(self, com):
+        self.center_of_mass_ = com
+        self.inertia_ = None
+
+    @property
+    def num_vertices(self):
+        """ :obj:`int`:
+        The number of total vertices
+        """
+        return self.vertices.shape[0]
+
+    @property
+    def num_triangles(self):
+        """ :obj:`int`:
+        The number of total triangles
+        """
+        return self.triangles.shape[0]
+
+    # =============================================
+    # Read-Only Properties
+    # =============================================
+    @property
+    def mass(self):
+        """float : The mass of the mesh (read-only).
+        """
+        if self.mass_ is None:
+            self.mass_ = self._compute_mass()
+        return self.mass_
+
+    @property
+    def inertia(self):
+        """:obj:`numpy.ndarray` of float :
+        The 3x3 inertial matrix of the mesh (read-only).
+        """
+        if self.inertia_ is None:
+            self.inertia_ = self._compute_inertia()
+        return self.inertia_
+
+    @property
+    def bb_center(self):
+        """:obj:`numpy.ndarray` of float :
+        The 3D location of the center of the mesh's minimal bounding box
+        (read-only).
+        """
+        return self.bb_center_
+
+    @property
+    def centroid(self):
+        """:obj:`numpy.ndarray` of float :
+        The 3D location of the mesh's vertex mean (read-only).
+        """
+        return self.centroid_
+
+    ##################################################################
+    # Public Class Methods
+    ##################################################################
+
+    def min_coords(self):
+        """Returns the minimum coordinates of the mesh.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A 3-ndarray of floats that represents the minimal
+            x, y, and z coordinates represented in the mesh.
+        """
+        return np.min(self.vertices_, axis=0)
+
+    def max_coords(self):
+        """Returns the maximum coordinates of the mesh.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A 3-ndarray of floats that represents the minimal
+            x, y, and z coordinates represented in the mesh.
+        """
+        return np.max(self.vertices_, axis=0)
+
+    def bounding_box(self):
+        """Returns the mesh's bounding box corners.
+
+        Returns
+        -------
+        :obj:`tuple` of :obj:`numpy.ndarray` of float
+            A 2-tuple of 3-ndarrays of floats. The first 3-array
+            contains the vertex of the smallest corner of the bounding box,
+            and the second 3-array contains the largest corner of the bounding
+            box.
+        """
+        return self.min_coords(), self.max_coords()
+
+    def bounding_box_mesh(self):
+        """Returns the mesh bounding box as a mesh.
+
+        Returns
+        -------
+        :obj:`Mesh3D`
+            A Mesh3D representation of the mesh's bounding box.
+        """
+        min_vert, max_vert = self.bounding_box()
+        xs, ys, zs = list(zip(max_vert, min_vert))
+        vertices = []
+        for x in xs:
+            for y in ys:
+                for z in zs:
+                    vertices.append([x, y, z])
+        triangles = (np.array([
+            [5, 7, 3], [5, 3, 1],
+            [2, 4, 8], [2, 8, 6],
+            [6, 8, 7], [6, 7, 5],
+            [1, 3, 4], [1, 4, 2],
+            [6, 5, 1], [6, 1, 2],
+            [7, 8, 4], [7, 4, 3],
+        ]) - 1)
+        return Mesh3D(vertices, triangles)
+
+    def principal_dims(self):
+        """Returns the maximal span of the mesh's coordinates.
+
+        The maximal span is the maximum coordinate value minus
+        the minimal coordinate value in each principal axis.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A 3-ndarray of floats that represents the maximal
+            x, y, and z spans of the mesh.
+        """
+        return self.max_coords() - self.min_coords()
+
+    def support(self, direction):
+        """Returns the support function in the given direction
+
+        Parameters
+        ----------
+        direction : :obj:`numpy.ndarray` of float
+            A 3-ndarray of floats that is a unit vector in
+            the direction of the desired support.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A 3-ndarray of floats that represents the support.
+        """
+        ip = self.vertices_.dot(direction)
+        index = np.where(ip == np.max(ip))[0][0]
+        x0 = self.vertices_[index, :]
+        n = direction
+        com_proj = x0.dot(n) * n
+        return com_proj
+
+    def tri_centers(self):
+        """Returns an array of the triangle centers as 3D points.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of :obj:`numpy.ndarray` of float
+            An ndarray of 3-ndarrays of floats, where each 3-ndarray
+            represents the 3D point at the center of the corresponding
+            mesh triangle.
+        """
+        centers = []
+        for tri in self.triangles_:
+            centers.append(self._center_of_tri(tri))
+        return np.array(centers)
+
+    def tri_normals(self, align_to_hull=False):
+        """Returns a list of the triangle normals.
+
+        Parameters
+        ----------
+        align_to_hull : bool
+            If true, we re-orient the normals to point outward from
+            the mesh by using the convex hull.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A #triangles by 3 array of floats, where each 3-ndarray
+            represents the 3D normal vector of the corresponding triangle.
+        """
+        # compute normals
+        v0 = self.vertices_[self.triangles_[:, 0], :]
+        v1 = self.vertices_[self.triangles_[:, 1], :]
+        v2 = self.vertices_[self.triangles_[:, 2], :]
+        n = np.cross(v1 - v0, v2 - v0)
+        normals = n / np.tile(np.linalg.norm(n, axis=1)[:, np.newaxis], [1, 3])
+
+        # reverse normal based on alignment with convex hull
+        if align_to_hull:
+            tri_centers = self.tri_centers()
+            hull = ss.ConvexHull(tri_centers)
+            hull_tris = hull.simplices
+            hull_vertex_ind = hull_tris[0][0]
+            hull_vertex = tri_centers[hull_vertex_ind]
+            hull_vertex_normal = normals[hull_vertex_ind]
+            v = hull_vertex.reshape([1, 3])
+            n = hull_vertex_normal
+            ip = (tri_centers - np.tile(hull_vertex,
+                                        [tri_centers.shape[0], 1])).dot(n)
+            if ip[0] > 0:
+                normals = -normals
+        return normals
+
+    def surface_area(self):
+        """Return the surface area of the mesh.
+
+        Returns
+        -------
+        float
+            The surface area of the mesh.
+        """
+        if self.surface_area_ is None:
+            area = 0.0
+            for tri in self.triangles:
+                tri_area = self._area_of_tri(tri)
+                area += tri_area
+            self.surface_area_ = area
+        return self.surface_area_
+
+    def total_volume(self):
+        """Return the total volume of the mesh.
+
+        Returns
+        -------
+        float
+            The total volume of the mesh.
+        """
+        total_volume = 0
+        for tri in self.triangles_:
+            volume = self._signed_volume_of_tri(tri)
+            total_volume = total_volume + volume
+
+        # Correct for flipped triangles
+        if total_volume < 0:
+            total_volume = -total_volume
+        return total_volume
+
+    def covariance(self):
+        """Return the total covariance of the mesh's triangles.
+
+        Returns
+        -------
+        float
+            The total covariance of the mesh's triangles.
+        """
+        C_sum = np.zeros([3, 3])
+        for tri in self.triangles_:
+            C = self._covariance_of_tri(tri)
+            C_sum = C_sum + C
+        return C_sum
+
+    def remove_bad_tris(self):
+        """Remove triangles with out-of-bounds vertices from the mesh.
+        """
+        new_tris = []
+        num_v = self.vertices_.shape[0]
+        for t in self.triangles_:
+            if (t[0] >= 0 and t[0] < num_v and
+                    t[1] >= 0 and t[1] < num_v and
+                    t[2] >= 0 and t[2] < num_v):
+                new_tris.append(t)
+        self.triangles = np.array(new_tris)
+
+    def remove_unreferenced_vertices(self):
+        """Remove any vertices that are not part of a triangular face.
+
+        Note
+        ----
+        This method will fail if any bad triangles are present, so run
+        remove_bad_tris() first if you're unsure if bad triangles are present.
+
+        Returns
+        -------
+        bool
+            Returns True if vertices were removed, False otherwise.
+
+        """
+        num_v = self.vertices_.shape[0]
+
+        # Fill in a 1 for each referenced vertex
+        reffed_array = np.zeros([num_v, 1])
+        for f in self.triangles_:
+            reffed_array[f[0]] = 1
+            reffed_array[f[1]] = 1
+            reffed_array[f[2]] = 1
+
+        # Trim out vertices that are not referenced
+        reffed_v_old_ind = np.where(reffed_array == 1)
+        reffed_v_old_ind = reffed_v_old_ind[0]
+
+        # Count number of referenced vertices before each index
+        reffed_v_new_ind = np.cumsum(reffed_array).astype(np.int) - 1
+
+        try:
+            self.vertices = self.vertices_[reffed_v_old_ind, :]
+            if self.normals is not None:
+                self.normals = self.normals[reffed_v_old_ind, :]
+        except IndexError:
+            return False
+
+        # create new face indices
+        new_triangles = []
+        for f in self.triangles_:
+            new_triangles.append([reffed_v_new_ind[f[0]],
+                                  reffed_v_new_ind[f[1]],
+                                  reffed_v_new_ind[f[2]]])
+        self.triangles = np.array(new_triangles)
+        return True
+
+    def center_vertices_avg(self):
+        """Center the mesh's vertices at the centroid.
+
+        This shifts the mesh without rotating it so that
+        the centroid (mean) of all vertices is at the origin.
+        """
+        centroid = np.mean(self.vertices_, axis=0)
+        self.vertices = self.vertices_ - centroid
+
+    def center_vertices_bb(self):
+        """Center the mesh's vertices at the center of its bounding box.
+
+        This shifts the mesh without rotating it so that
+        the center of its bounding box is at the origin.
+        """
+        min_vertex = self.min_coords()
+        max_vertex = self.max_coords()
+        center = (max_vertex + min_vertex) / 2
+        self.vertices = self.vertices_ - center
+
+    def center_vertices(self):
+        """Center the mesh's vertices on the mesh center of mass.
+
+        This shifts the mesh without rotating it so that
+        the center of its bounding box is at the origin.
+        """
+        self.vertices = self.vertices_ - self.center_of_mass_
+        self.trimesh_ = None  # flag re-comp of trimesh
+
+    def normalize_vertices(self):
+        """Normalize the mesh's orientation along its principal axes.
+
+        Transforms the vertices and normals of the mesh
+        such that the origin of the resulting mesh's coordinate frame
+        is at the center of the bounding box and the principal axes (as determined
+        from PCA) are aligned with the vertical Z, Y, and X axes in that order.
+        """
+
+        self.center_vertices_bb()
+
+        # Find principal axes
+        pca = sklearn.decomposition.PCA(n_components=3)
+        pca.fit(self.vertices_)
+
+        # Count num vertices on side of origin wrt principal axes
+        # to determine correct orientation
+        comp_array = pca.components_
+        norm_proj = self.vertices_.dot(comp_array.T)
+        opposite_aligned = np.sum(norm_proj < 0, axis=0)
+        same_aligned = np.sum(norm_proj >= 0, axis=0)
+
+        # create rotation from principal axes to standard basis
+        z_axis = comp_array[0, :]
+        y_axis = comp_array[1, :]
+        if opposite_aligned[2] > same_aligned[2]:
+            z_axis = -z_axis
+        if opposite_aligned[1] > same_aligned[1]:
+            y_axis = -y_axis
+        x_axis = np.cross(y_axis, z_axis)
+        R_pc_obj = np.c_[x_axis, y_axis, z_axis]
+
+        # rotate vertices, normals and reassign to the mesh
+        self.vertices = (R_pc_obj.T.dot(self.vertices.T)).T
+        self.center_vertices_bb()
+
+        # TODO JEFF LOOK HERE (BUG IN INITIAL CODE FROM MESHPROCESSOR)
+        if self.normals_ is not None:
+            self.normals = (R_pc_obj.T.dot(self.normals.T)).T
+
+    def compute_vertex_normals(self):
+        """ Get normals from triangles"""
+        normals = []
+        # weighted average of triangle normal for each vertex
+        for i in range(len(self.vertices)):
+            inds = np.where(self.triangles == i)
+            tris = self.triangles[inds[0], :]
+            normal = np.zeros(3)
+            for tri in tris:
+                # compute triangle normal
+                t = self.vertices[tri, :]
+                v0 = t[1, :] - t[0, :]
+                v1 = t[2, :] - t[0, :]
+                if np.linalg.norm(v0) == 0:
+                    continue
+                v0 = v0 / np.linalg.norm(v0)
+                if np.linalg.norm(v1) == 0:
+                    continue
+                v1 = v1 / np.linalg.norm(v1)
+                n = np.cross(v0, v1)
+                if np.linalg.norm(n) == 0:
+                    continue
+                n = n / np.linalg.norm(n)
+
+                # compute weight by area of triangle
+                w_area = self._area_of_tri(tri)
+
+                # compute weight by edge angle
+                vertex_ind = np.where(tri == i)[0][0]
+                if vertex_ind == 0:
+                    e0 = t[1, :] - t[0, :]
+                    e1 = t[2, :] - t[0, :]
+                elif vertex_ind == 1:
+                    e0 = t[0, :] - t[1, :]
+                    e1 = t[2, :] - t[1, :]
+                elif vertex_ind == 2:
+                    e0 = t[0, :] - t[2, :]
+                    e1 = t[1, :] - t[2, :]
+                if np.linalg.norm(e0) == 0:
+                    continue
+                if np.linalg.norm(e1) == 0:
+                    continue
+                e0 = e0 / np.linalg.norm(e0)
+                e1 = e1 / np.linalg.norm(e1)
+                w_angle = np.arccos(e0.dot(e1))
+
+                # weighted update
+                # www.bytehazard.com/articles/vertnorm.html
+                normal += w_area * w_angle * n
+
+            # normalize
+            if np.linalg.norm(normal) == 0:
+                normal = np.array([1, 0, 0])
+            normal = normal / np.linalg.norm(normal)
+            normals.append(normal)
+
+        # set numpy array
+        self.normals = np.array(normals)
+
+        # reverse normals based on alignment with convex hull
+        hull = ss.ConvexHull(self.vertices)
+        hull_tris = hull.simplices.tolist()
+        hull_vertex_inds = np.unique(hull_tris)
+
+        num_aligned = 0
+        num_misaligned = 0
+        for hull_vertex_ind in hull_vertex_inds:
+            hull_vertex = self.vertices[hull_vertex_ind, :]
+            hull_vertex_normal = normals[hull_vertex_ind]
+            ip = (hull_vertex - self.vertices).dot(hull_vertex_normal)
+            num_aligned += np.sum(ip > 0)
+            num_misaligned += np.sum(ip <= 0)
+
+        if num_misaligned > num_aligned:
+            self.normals = -self.normals
+
+    def flip_normals(self):
+        """ Flips the mesh normals. """
+        if self.normals is not None:
+            self.normals = -self.normals
+            return True
+        return False
+
+    def scale_principal_eigenvalues(self, new_evals):
+        self.normalize_vertices()
+
+        pca = sklearn.decomposition.PCA(n_components=3)
+        pca.fit(self.vertices_)
+
+        evals = pca.explained_variance_
+        if len(new_evals) == 3:
+            self.vertices[:, 0] *= new_evals[2] / np.sqrt(evals[2])
+            self.vertices[:, 1] *= new_evals[1] / np.sqrt(evals[1])
+            self.vertices[:, 2] *= new_evals[0] / np.sqrt(evals[0])
+        elif len(new_evals) == 2:
+            self.vertices[:, 1] *= new_evals[1] / np.sqrt(evals[1])
+            self.vertices[:, 2] *= new_evals[0] / np.sqrt(evals[0])
+        elif len(new_evals) == 1:
+            self.vertices[:, 0] *= new_evals[0] / np.sqrt(evals[0])
+            self.vertices[:, 1] *= new_evals[0] / np.sqrt(evals[0])
+            self.vertices[:, 2] *= new_evals[0] / np.sqrt(evals[0])
+
+        self.center_vertices_bb()
+        return evals
+
+    def copy(self):
+        """Return a copy of the mesh.
+
+        Note
+        ----
+        This method only copies the vertices and triangles of the mesh.
+        """
+        return Mesh3D(np.copy(self.vertices_), np.copy(self.triangles_))
+
+    def subdivide(self, min_tri_length=np.inf):
+        """Return a copy of the mesh that has been subdivided by one iteration.
+
+        Note
+        ----
+        This method only copies the vertices and triangles of the mesh.
+        """
+        new_vertices = self.vertices.tolist()
+        old_triangles = self.triangles.tolist()
+
+        new_triangles = []
+        tri_queue = queue.Queue()
+
+        for j, triangle in enumerate(old_triangles):
+            tri_queue.put((j, triangle))
+
+        num_subdivisions_per_tri = np.zeros(len(old_triangles))
+        while not tri_queue.empty():
+            tri_index_pair = tri_queue.get()
+            j = tri_index_pair[0]
+            triangle = tri_index_pair[1]
+
+            if (np.isinf(min_tri_length) and num_subdivisions_per_tri[j] == 0) or \
+                    (Mesh3D._max_edge_length(triangle, new_vertices) > min_tri_length):
+
+                # subdivide
+                t_vertices = np.array([new_vertices[i] for i in triangle])
+                edge01 = 0.5 * (t_vertices[0, :] + t_vertices[1, :])
+                edge12 = 0.5 * (t_vertices[1, :] + t_vertices[2, :])
+                edge02 = 0.5 * (t_vertices[0, :] + t_vertices[2, :])
+
+                i_01 = len(new_vertices)
+                i_12 = len(new_vertices) + 1
+                i_02 = len(new_vertices) + 2
+                new_vertices.append(edge01)
+                new_vertices.append(edge12)
+                new_vertices.append(edge02)
+
+                num_subdivisions_per_tri[j] += 1
+
+                for triplet in [[triangle[0], i_01, i_02],
+                                [triangle[1], i_12, i_01],
+                                [triangle[2], i_02, i_12],
+                                [i_01, i_12, i_02]]:
+                    tri_queue.put((j, triplet))
+
+            else:
+                # add to final list
+                new_triangles.append(triangle)
+
+        return Mesh3D(np.array(new_vertices), np.array(new_triangles),
+                      center_of_mass=self.center_of_mass)
+
+    def transform(self, T):
+        """Return a copy of the mesh that has been transformed by T.
+
+        Parameters
+        ----------
+        T : :obj:`RigidTransform`
+            The RigidTransform by which the mesh is transformed.
+
+        Note
+        ----
+        This method only copies the vertices and triangles of the mesh.
+        """
+        vertex_cloud = PointCloud(self.vertices_.T, frame=T.from_frame)
+        vertex_cloud_tf = T * vertex_cloud
+        vertices = vertex_cloud_tf.data.T
+        if self.normals_ is not None:
+            normal_cloud = NormalCloud(self.normals_.T, frame=T.from_frame)
+            normal_cloud_tf = T * normal_cloud
+            normals = normal_cloud_tf.data.T
+        com = Point(self.center_of_mass_, frame=T.from_frame)
+        com_tf = T * com
+
+        if self.normals_ is not None:
+            return Mesh3D(vertices.copy(), self.triangles.copy(), normals=normals.copy(), center_of_mass=com_tf.data)
+        return Mesh3D(vertices.copy(), self.triangles.copy(), center_of_mass=com_tf.data)
+
+    def update_tf(self, delta_T):
+        """ Updates the mesh transformation. """
+        new_T_obj_world = self.T_obj_world * delta_T.inverse().as_frames('obj', 'obj')
+        return Mesh3D(self.vertices, self.triangles, normals=self.normals, trimesh=self.trimesh,
+                      T_obj_world=new_T_obj_world)
+
+    def random_points(self, n_points):
+        """Generate uniformly random points on the surface of the mesh.
+
+        Parameters
+        ----------
+        n_points : int
+            The number of random points to generate.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A n_points by 3 ndarray that contains the sampled 3D points.
+        """
+        probs = self._tri_area_percentages()
+        tri_inds = np.random.choice(list(range(len(probs))), n_points, p=probs)
+        points = []
+        for tri_ind in tri_inds:
+            tri = self.triangles[tri_ind]
+            points.append(self._rand_point_on_tri(tri))
+        return np.array(points)
+
+    def ray_intersections(self, ray, point, distance):
+        """Returns a list containing the indices of the triangles that
+        are intersected by the given ray emanating from the given point
+        within some distance.
+        """
+        ray = ray / np.linalg.norm(ray)
+        norms = self.tri_normals()
+        tri_point_pairs = []
+        for i, tri in enumerate(self.triangles):
+            if np.dot(ray, norms[i]) == 0.0:
+                continue
+            t = -1 * np.dot((point - self.vertices[tri[0]]), norms[i]) / (np.dot(ray, norms[i]))
+            if (t > 0 and t <= distance):
+                contact_point = point + t * ray
+                tri_verts = [self.vertices[j] for j in tri]
+                if Mesh3D._point_in_tri(tri_verts, contact_point):
+                    tri_point_pairs.append((i, contact_point))
+        return tri_point_pairs
+
+    def get_T_surface_obj(self, T_obj_surface, delta=0.0):
+        """ Gets the transformation that puts the object resting exactly on
+        the z=delta plane
+
+        Parameters
+        ----------
+        T_obj_surface : :obj:`RigidTransform`
+            The RigidTransform by which the mesh is transformed.
+        delta : float
+            Z-coordinate to rest the mesh on
+
+        Note
+        ----
+        This method copies the vertices and triangles of the mesh.
+        """
+        T_obj_surface_ori = T_obj_surface.copy()
+        T_obj_surface_ori.translation = np.zeros(3)
+        obj_tf = self.transform(T_obj_surface_ori)
+        mn, mx = obj_tf.bounding_box()
+
+        z = mn[2]
+        x0 = np.array([0, 0, -z + delta])
+
+        T_obj_surface = RigidTransform(rotation=T_obj_surface_ori.rotation,
+                                       translation=x0, from_frame='obj',
+                                       to_frame='surface')
+        return T_obj_surface
+
+    def rescale_dimension(self, scale, scaling_type=ScalingTypeMin):
+        """Rescales the vertex coordinates to scale using the given scaling_type.
+
+        Parameters
+        ----------
+        scale : float
+            The desired scaling factor of the selected dimension, if scaling_type
+            is ScalingTypeMin, ScalingTypeMed, ScalingTypeMax, or
+            ScalingTypeDiag. Otherwise, the overall scaling factor.
+
+        scaling_type : int
+            One of ScalingTypeMin, ScalingTypeMed, ScalingTypeMax,
+            ScalingTypeRelative, or ScalingTypeDiag.
+            ScalingTypeMin scales the smallest vertex extent (X, Y, or Z)
+            by scale, ScalingTypeMed scales the median vertex extent, and
+            ScalingTypeMax scales the maximum vertex extent. ScalingTypeDiag
+            scales the bounding box diagonal (divided by three), and
+            ScalingTypeRelative provides absolute scaling.
+        """
+        vertex_extent = self.principal_dims()
+
+        # Find minimal dimension
+        relative_scale = 1.0
+        if scaling_type == Mesh3D.ScalingTypeMin:
+            dim = np.where(vertex_extent == np.min(vertex_extent))[0][0]
+            relative_scale = vertex_extent[dim]
+        elif scaling_type == Mesh3D.ScalingTypeMed:
+            dim = np.where(vertex_extent == np.med(vertex_extent))[0][0]
+            relative_scale = vertex_extent[dim]
+        elif scaling_type == Mesh3D.ScalingTypeMax:
+            dim = np.where(vertex_extent == np.max(vertex_extent))[0][0]
+            relative_scale = vertex_extent[dim]
+        elif scaling_type == Mesh3D.ScalingTypeRelative:
+            relative_scale = 1.0
+        elif scaling_type == Mesh3D.ScalingTypeDiag:
+            diag = np.linalg.norm(vertex_extent)
+            relative_scale = diag / 3.0  # make the gripper size exactly one third of the diagonal
+
+        # Compute scale factor and rescale vertices
+        scale_factor = scale / relative_scale
+        self.vertices = scale_factor * self.vertices
+
+    def rescale(self, scale_factor):
+        """Rescales the vertex coordinates by scale_factor.
+
+        Parameters
+        ----------
+        scale_factor : float
+            The desired scale factor for the mesh's vertices.
+        """
+        self.vertices = scale_factor * self.vertices
+
+    def convex_hull(self):
+        """Return a 3D mesh that represents the convex hull of the mesh.
+        """
+        hull = ss.ConvexHull(self.vertices_)
+        hull_tris = hull.simplices
+        if self.normals_ is None:
+            cvh_mesh = Mesh3D(self.vertices_.copy(), hull_tris.copy(), center_of_mass=self.center_of_mass_)
+        else:
+            cvh_mesh = Mesh3D(self.vertices_.copy(), hull_tris.copy(), normals=self.normals_.copy(),
+                              center_of_mass=self.center_of_mass_)
+        cvh_mesh.remove_unreferenced_vertices()
+        return cvh_mesh
+
+    def stable_poses(self, min_prob=0.0):
+        """Computes all valid StablePose objects for the mesh.
+
+        Parameters
+        ----------
+        min_prob : float
+            stable poses that are less likely than this threshold will be discarded
+
+        Returns
+        -------
+        :obj:`list` of :obj:`StablePose`
+            A list of StablePose objects for the mesh.
+        """
+        # compute face dag if necessary
+        if self.face_dag_ is None:
+            self._compute_face_dag()
+        cvh_mesh = self.face_dag_.mesh
+        cvh_verts = self.face_dag_.mesh.vertices
+
+        # propagate probabilities
+        cm = self.center_of_mass
+        prob_map = Mesh3D._compute_prob_map(list(self.face_dag_.nodes.values()), cvh_verts, cm)
+
+        # compute stable poses
+        stable_poses = []
+        for face, p in list(prob_map.items()):
+            x0 = cvh_verts[face[0]]
+            r = cvh_mesh._compute_basis([cvh_verts[i] for i in face])
+            if p > min_prob:
+                stable_poses.append(sp.StablePose(p, r, x0, face=face))
+
+        return stable_poses
+
+    def resting_pose(self, T_obj_world, eps=1e-10):
+        """ Returns the stable pose that the mesh will rest on if it lands
+        on an infinite planar worksurface quasi-statically in the given
+        transformation (only the rotation is used).
+
+        Parameters
+        ----------
+        T_obj_world : :obj:`autolab_core.RigidTransform`
+            transformation from object to table basis (z-axis upward) specifying the orientation of the mesh
+        eps : float
+            numeric tolerance in cone projection solver
+        
+        Returns
+        -------
+        :obj:`StablePose`
+            stable pose specifying the face that the mesh will land on
+        """
+        # compute face dag if necessary
+        if self.face_dag_ is None:
+            self._compute_face_dag()
+
+        # adjust transform to place mesh in contact with table
+        T_obj_table = self.get_T_surface_obj(T_obj_world, delta=0.0)
+
+        # transform mesh
+        cvh_mesh = self.face_dag_.mesh
+        cvh_verts = cvh_mesh.vertices
+        mesh_tf = cvh_mesh.transform(T_obj_table)
+        vertices_tf = mesh_tf.vertices
+
+        # find the vertex with the minimum z value
+        min_z = np.min(vertices_tf[:, 2])
+        contact_ind = np.where(vertices_tf[:, 2] == min_z)[0]
+        if contact_ind.shape[0] == 0:
+            raise ValueError('Unable to find the vertex contacting the table!')
+        vertex_ind = contact_ind[0]
+
+        # project the center of mass onto the table plane
+        table_tri = np.array([[0, 0, 0],
+                              [1, 0, 0],
+                              [0, 1, 0]])
+        proj_cm = Mesh3D._proj_point_to_plane(table_tri, self.center_of_mass)
+        contact_vertex = vertices_tf[vertex_ind]
+        v_cm = proj_cm - contact_vertex
+        v_cm = v_cm[:2]
+
+        # compute which face the vertex will topple onto
+        # break loop when topple tri is found        
+        topple_tri = None
+        neighboring_tris = self.face_dag_.vertex_to_tri[vertex_ind]
+        random.shuffle(neighboring_tris)
+        for neighboring_tri in neighboring_tris:
+            # find indices of other two vertices
+            ind = [0, 1, 2]
+            for i, v in enumerate(neighboring_tri):
+                if np.allclose(contact_vertex, vertices_tf[v]):
+                    ind.remove(i)
+
+            # form edges in table plane
+            i1 = neighboring_tri[ind[0]]
+            i2 = neighboring_tri[ind[1]]
+            v1 = Mesh3D._proj_point_to_plane(table_tri, vertices_tf[i1])
+            v2 = Mesh3D._proj_point_to_plane(table_tri, vertices_tf[i2])
+            u1 = v1 - contact_vertex
+            u2 = v2 - contact_vertex
+            U = np.array([u1[:2], u2[:2]]).T
+
+            # solve linear subproblem to find cone coefficients
+            try:
+                alpha = np.linalg.solve(U + eps * np.eye(2), v_cm)
+
+                # exit loop with topple tri if found
+                if np.all(alpha >= 0):
+                    tri_normal = cvh_mesh._compute_basis([cvh_verts[i] for i in neighboring_tri])[2, :]
+                    if tri_normal[2] < 0:
+                        tri_normal = -tri_normal
+
+                    # check whether lower
+                    lower = True
+                    tri_center = np.mean([vertices_tf[i] for i in neighboring_tri], axis=0)
+                    if topple_tri is not None:
+                        topple_tri_center = np.mean([vertices_tf[i] for i in topple_tri], axis=0)
+                        lower = (tri_normal.dot(topple_tri_center - tri_center) > 0)
+                    if lower:
+                        topple_tri = neighboring_tri
+
+            except np.linalg.LinAlgError:
+                logging.warning('Failed to solve linear system')
+
+        # check solution
+        if topple_tri is None:
+            raise ValueError('Failed to find a valid topple triangle')
+
+        # compute the face that the mesh will eventually rest on
+        # by following the child nodes to a sink
+        cur_node = self.face_dag_.nodes[tuple(topple_tri)]
+        visited = []
+        while not cur_node.is_sink:
+            if cur_node in visited:
+                raise ValueError('Found loop!')
+            visited.append(cur_node)
+            cur_node = cur_node.children[0]
+
+        # create stable pose
+        resting_face = cur_node.face
+        x0 = cvh_verts[vertex_ind]
+        R = cvh_mesh._compute_basis([cvh_verts[i] for i in resting_face])
+
+        # align with axes with the original pose
+        best_theta = 0
+        best_dot = 0
+        cur_theta = 0
+        delta_theta = 0.01
+        px = R[:, 0].copy()
+        px[2] = 0
+        py = R[:, 1].copy()
+        py[2] = 0
+        align_x = True
+        if np.linalg.norm(py) > np.linalg.norm(px):
+            align_x = False
+        while cur_theta <= 2 * np.pi:
+            Rz = RigidTransform.z_axis_rotation(cur_theta)
+            Rp = Rz.dot(R)
+            dot_prod = Rp[:, 0].dot(T_obj_world.x_axis)
+            if not align_x:
+                dot_prod = Rp[:, 1].dot(T_obj_world.y_axis)
+            if dot_prod > best_dot:
+                best_dot = dot_prod
+                best_theta = cur_theta
+            cur_theta += delta_theta
+        R = RigidTransform.z_axis_rotation(best_theta).dot(R)
+        return sp.StablePose(0.0, R, x0, face=resting_face)
+
+    def merge(self, other_mesh):
+        """ Combines this mesh with another mesh.
+        
+        Parameters
+        ----------
+        other_mesh : :obj:`Mesh3D`
+            the mesh to combine with
+
+        Returns
+        -------
+        :obj:`Mesh3D`
+            merged mesh
+        """
+        total_vertices = self.num_vertices + other_mesh.num_vertices
+        total_triangles = self.num_triangles + other_mesh.num_triangles
+        combined_vertices = np.zeros([total_vertices, 3])
+        combined_triangles = np.zeros([total_triangles, 3])
+
+        combined_vertices[:self.num_vertices, :] = self.vertices
+        combined_vertices[self.num_vertices:, :] = other_mesh.vertices
+
+        combined_triangles[:self.num_triangles, :] = self.triangles
+        combined_triangles[self.num_triangles:, :] = other_mesh.triangles + self.num_vertices
+
+        combined_normals = None
+        if self.normals is not None and other_mesh.normals is not None:
+            combined_normals = np.zeros([total_vertices, 3])
+            combined_normals[:self.num_vertices, :] = self.normals
+            combined_normals[self.num_vertices:, :] = other_mesh.normals
+        return Mesh3D(combined_vertices, combined_triangles.astype(np.int32), combined_normals)
+
+    def flip_tri_orientation(self):
+        """ Flips the orientation of all triangles. """
+        new_tris = self.triangles
+        new_tris[:, 1] = self.triangles[:, 2]
+        new_tris[:, 2] = self.triangles[:, 1]
+        return Mesh3D(self.vertices, new_tris, self.normals,
+                      center_of_mass=self.center_of_mass)
+
+    def find_contact(self, origin, direction):
+        """ Finds the contact location with the mesh, if it exists. """
+        # create points
+        origin_world = Point(origin, frame='world')
+        direction_world = Direction(direction, frame='world')
+
+        # find contact using trimesh ray intersector
+        origin_obj = self.T_obj_world.inverse() * origin_world
+        direction_obj = self.T_obj_world.inverse() * direction_world
+        locations, _, tri_indices = self.trimesh.ray.intersects_location([origin_obj.data], [direction_obj.data])
+
+        if len(locations) == 0:
+            return None, None
+
+        # return closest point
+        dists = np.linalg.norm(locations - origin_obj.data, axis=1)
+        closest_ind = np.where(dists == np.min(dists))[0][0]
+        point_obj = Point(locations[closest_ind, :], frame='obj')
+        normal_obj = Direction(self.trimesh.face_normals[tri_indices[closest_ind], :], frame='obj')
+        point_world = self.T_obj_world * point_obj
+        normal_world = self.T_obj_world * normal_obj
+
+        return point_world.data, normal_world.data
+
+    def visualize(self, color=(0.5, 0.5, 0.5), style='surface', opacity=1.0):
+        """Plots visualization of mesh using MayaVI.
+
+        Parameters
+        ----------
+        color : :obj:`tuple` of float
+            3-tuple of floats in [0,1] to give the mesh's color
+
+        style : :obj:`str`
+            Either 'surface', which produces an opaque surface, or
+            'wireframe', which produces a wireframe.
+
+        opacity : float
+            A value in [0,1] indicating the opacity of the mesh.
+            Zero is transparent, one is opaque.
+
+        Returns
+        -------
+        :obj:`mayavi.modules.surface.Surface`
+            The displayed surface.
+        """
+        surface = mv.triangular_mesh(self.vertices_[:, 0],
+                                     self.vertices_[:, 1],
+                                     self.vertices_[:, 2],
+                                     self.triangles_, representation=style,
+                                     color=color, opacity=opacity)
+        return surface
+
+    @staticmethod
+    def load(filename, cache_dir, preproc_script=None):
+        """Load a mesh from a file.
+
+        Note
+        ----
+        If the mesh is not already in .obj format, this requires
+        the installation of meshlab. Meshlab has a command called
+        meshlabserver that is used to convert the file into a .obj format.
+
+        Parameters
+        ----------
+        filename : :obj:`str`
+            Path to mesh file.
+        cache_dir : :obj:`str`
+            A directory to store a converted .obj file in, if
+            the file isn't already in .obj format.
+        preproc_script : :obj:`str`
+            The path to an optional script to run before converting
+            the mesh file to .obj if necessary.
+
+        Returns
+        -------
+        :obj:`Mesh3D`
+            A 3D mesh object read from the file.
+        """
+        file_path, file_root = os.path.split(filename)
+        file_root, file_ext = os.path.splitext(file_root)
+        obj_filename = filename
+
+        if file_ext != Mesh3D.OBJ_EXT:
+            obj_filename = os.path.join(cache_dir, file_root + Mesh3D.PROC_TAG + Mesh3D.OBJ_EXT)
+            if preproc_script is None:
+                meshlabserver_cmd = 'meshlabserver -i \"%s\" -o \"%s\"' % (filename, obj_filename)
+            else:
+                meshlabserver_cmd = 'meshlabserver -i \"%s\" -o \"%s\" -s \"%s\"' % (
+                filename, obj_filename, preproc_script)
+            os.system(meshlabserver_cmd)
+
+        if not os.path.exists(obj_filename):
+            raise ValueError('Unable to open file %s. It may not exist or meshlab may not be installed.' % (filename))
+
+        # Read mesh from obj file
+        return obj_file.ObjFile(obj_filename).read()
+
+    @property
+    def trimesh(self):
+        """ Convert to trimesh. """
+        if self.trimesh_ is None:
+            self.trimesh_ = tm.Trimesh(vertices=self.vertices,
+                                       faces=self.triangles,
+                                       vertex_normals=self.normals)
+        return self.trimesh_
+
+    @property
+    def is_watertight(self):
+        return self.trimesh.is_watertight
+
+    @property
+    def T_obj_world(self):
+        """ Return pose. """
+        return self.T_obj_world_
+
+    ##################################################################
+    # Private Class Methods
+    ##################################################################
+
+    def _compute_mass(self):
+        """Computes the mesh mass.
+
+        Note
+        ----
+            Only works for watertight meshes.
+
+        Returns
+        -------
+        float
+            The mass of the mesh.
+        """
+        return self.density_ * self.total_volume()
+
+    def _compute_inertia(self):
+        """Computes the mesh inertia matrix.
+
+        Note
+        ----
+            Only works for watertight meshes.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 3x3 inertial matrix.
+        """
+        C = self.covariance()
+        return self.density_ * (np.trace(C) * np.eye(3) - C)
+
+    def _compute_bb_center(self):
+        """Computes the center point of the bounding box.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            3-ndarray of floats that contains the coordinates
+            of the center of the bounding box.
+        """
+
+        bb_center = (self.min_coords() + self.max_coords()) / 2.0
+        return bb_center
+
+    def _compute_com_uniform(self):
+        """Computes the center of mass using a uniform mass distribution assumption.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            3-ndarray of floats that contains the coordinates
+            of the center of mass.
+        """
+        """
+        total_volume = 0
+        weighted_point_sum = np.zeros([1, 3])
+        for tri in self.triangles_:
+            volume = self._signed_volume_of_tri(tri)
+            center = self._center_of_tri(tri)
+            weighted_point_sum = weighted_point_sum + volume * center
+            total_volume = total_volume + volume
+        center_of_mass = weighted_point_sum / total_volume
+        return center_of_mass[0]
+        """
+        return self.trimesh.center_mass
+
+    def _compute_centroid(self):
+        """Computes the centroid (mean) of the mesh's vertices.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            3-ndarray of floats that contains the coordinates
+            of the centroid.
+        """
+        return np.mean(self.vertices_, axis=0)
+
+    def _signed_volume_of_tri(self, tri):
+        """Return the signed volume of the given triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle for which we wish to compute a signed volume.
+
+        Returns
+        -------
+        float
+            The signed volume associated with the triangle.
+        """
+        v1 = self.vertices_[tri[0], :]
+        v2 = self.vertices_[tri[1], :]
+        v3 = self.vertices_[tri[2], :]
+
+        volume = (1.0 / 6.0) * (v1.dot(np.cross(v2, v3)))
+        return volume
+
+    def _center_of_tri(self, tri):
+        """Return the center of the given triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle for which we wish to compute a signed volume.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 3D point at the center of the triangle
+        """
+        v1 = self.vertices_[tri[0], :]
+        v2 = self.vertices_[tri[1], :]
+        v3 = self.vertices_[tri[2], :]
+        center = (1.0 / 3.0) * (v1 + v2 + v3)
+        return center
+
+    def _covariance_of_tri(self, tri):
+        """Return the covariance matrix of the given triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle for which we wish to compute a covariance.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 3x3 covariance matrix of the given triangle.
+        """
+        v1 = self.vertices_[tri[0], :]
+        v2 = self.vertices_[tri[1], :]
+        v3 = self.vertices_[tri[2], :]
+
+        A = np.zeros([3, 3])
+        A[:, 0] = v1 - self.center_of_mass_
+        A[:, 1] = v2 - self.center_of_mass_
+        A[:, 2] = v3 - self.center_of_mass_
+        C = np.linalg.det(A) * A.dot(Mesh3D.C_canonical).dot(A.T)
+        return C
+
+    def _area_of_tri(self, tri):
+        """Return the area of the given triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle for which we wish to compute an area.
+
+        Returns
+        -------
+        float
+            The area of the triangle.
+        """
+        verts = [self.vertices[i] for i in tri]
+        ab = verts[1] - verts[0]
+        ac = verts[2] - verts[0]
+        return 0.5 * np.linalg.norm(np.cross(ab, ac))
+
+    def _tri_area_percentages(self):
+        """Return a list of the percent area each triangle contributes to the
+        mesh's surface area.
+
+        Returns
+        -------
+        :obj:`list` of float
+            A list of percentages in [0,1] for each face that represents its
+            total contribution to the area of the mesh.
+        """
+        probs = []
+        area = 0.0
+        for tri in self.triangles:
+            tri_area = self._area_of_tri(tri)
+            probs.append(tri_area)
+            area += tri_area
+        probs = probs / area
+        return probs
+
+    def _rand_point_on_tri(self, tri):
+        """Return a random point on the given triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle for which we wish to compute an area.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            A 3D point on the triangle.
+        """
+        verts = [self.vertices[i] for i in tri]
+        r1 = np.sqrt(np.random.uniform())
+        r2 = np.random.uniform()
+        p = (1 - r1) * verts[0] + r1 * (1 - r2) * verts[1] + r1 * r2 * verts[2]
+        return p
+
+    def _compute_proj_area(self, verts):
+        """Projects vertices onto the unit sphere from the center of mass
+        and computes the projected area.
+
+        Parameters
+        ----------
+        verts : `list` of `numpy.ndarray` of float
+            List of 3-ndarrays of floats that represent the vertices to be
+            projected onto the unit sphere.
+
+        Returns
+        -------
+        float
+            The total projected area on the unit sphere.
+        """
+        cm = self.center_of_mass
+        angles = []
+
+        proj_verts = [(v - cm) / np.linalg.norm(v - cm) for v in verts]
+
+        a = math.acos(min(1, max(-1, np.dot(proj_verts[0], proj_verts[1]) /
+                                 (np.linalg.norm(proj_verts[0]) * np.linalg.norm(proj_verts[1])))))
+        b = math.acos(min(1, max(-1, np.dot(proj_verts[0], proj_verts[2]) /
+                                 (np.linalg.norm(proj_verts[0]) * np.linalg.norm(proj_verts[2])))))
+        c = math.acos(min(1, max(-1, np.dot(proj_verts[1], proj_verts[2]) /
+                                 (np.linalg.norm(proj_verts[1]) * np.linalg.norm(proj_verts[2])))))
+        s = (a + b + c) / 2
+
+        try:
+            return 4 * math.atan(math.sqrt(math.tan(s / 2) * math.tan((s - a) / 2) *
+                                           math.tan((s - b) / 2) * math.tan((s - c) / 2)))
+        except:
+            s = s + 0.001
+            return 4 * math.atan(math.sqrt(math.tan(s / 2) * math.tan((s - a) / 2) *
+                                           math.tan((s - b) / 2) * math.tan((s - c) / 2)))
+
+    def _compute_basis(self, face_verts):
+        """Computes axes for a transformed basis relative to the plane in which input vertices lie.
+
+        Parameters
+        ----------
+        face_verts : :obj:`numpy.ndarray` of float
+            A set of three 3D points that form a plane.
+
+        Returns:
+        :obj:`numpy.ndarray` of float
+            A 3-by-3 ndarray whose rows are the new basis. This matrix
+            can be applied to the mesh to rotate the mesh to lie flat
+            on the input face.
+        """
+        centroid = np.mean(face_verts, axis=0)
+
+        z_o = np.cross(face_verts[1] - face_verts[0], face_verts[2] - face_verts[0])
+        z_o = z_o / np.linalg.norm(z_o)
+
+        # Ensure that all vertices are on the positive halfspace (aka above the table)
+        dot_product = (self.vertices - centroid).dot(z_o)
+        dot_product[np.abs(dot_product) < 1e-10] = 0.0
+        if np.any(dot_product < 0):
+            z_o = -z_o
+
+        x_o = np.array([-z_o[1], z_o[0], 0])
+        if np.linalg.norm(x_o) == 0.0:
+            x_o = np.array([1, 0, 0])
+        else:
+            x_o = x_o / np.linalg.norm(x_o)
+        y_o = np.cross(z_o, x_o)
+        y_o = y_o / np.linalg.norm(y_o)
+
+        R = np.array([np.transpose(x_o), np.transpose(y_o), np.transpose(z_o)])
+
+        # rotate the vertices and then align along the principal axes
+        rotated_vertices = R.dot(self.vertices.T)
+        xy_components = rotated_vertices[:2, :].T
+
+        pca = sklearn.decomposition.PCA(n_components=2)
+        pca.fit(xy_components)
+        comp_array = pca.components_
+        x_o = R.T.dot(np.array([comp_array[0, 0], comp_array[0, 1], 0]))
+        y_o = np.cross(z_o, x_o)
+        return np.array([np.transpose(x_o), np.transpose(y_o), np.transpose(z_o)])
+
+    def _compute_face_dag(self):
+        """ Computes a directed acyclic graph (DAG) specifying the
+        toppling structure of the mesh faces by:
+            1) Computing the mesh convex hull
+            2) Creating maps from vertices and edges to the triangles that share them 
+            3) Connecting each triangle in the convex hull to the face it will topple to, if landed on
+        Modifies the class variable self.face_dag_.
+        """
+        # compute convex hull
+        cm = self.center_of_mass
+        cvh_mesh = self.convex_hull()
+        cvh_tris = cvh_mesh.triangles
+        cvh_verts = cvh_mesh.vertices
+
+        # create vertex and edge maps, and create nodes of graph
+        nodes = {}  # mapping from triangle tuples to GraphVertex objects
+        vertex_to_tri = {}  # mapping from vertex indidces to adjacent triangle lists
+        edge_to_tri = {}  # mapping from edge tuples to adjacent triangle lists
+
+        for tri in cvh_tris:
+            # add vertex to tri mapping
+            for v in tri:
+                if v in vertex_to_tri:
+                    vertex_to_tri[v] += [tuple(tri)]
+                else:
+                    vertex_to_tri[v] = [tuple(tri)]
+
+            # add edges to tri mapping
+            tri_verts = [cvh_verts[i] for i in tri]
+            s1 = Mesh3D._Segment(tri_verts[0], tri_verts[1])
+            s2 = Mesh3D._Segment(tri_verts[0], tri_verts[2])
+            s3 = Mesh3D._Segment(tri_verts[1], tri_verts[2])
+            for seg in [s1, s2, s3]:
+                k = seg.tup
+                if k in edge_to_tri:
+                    edge_to_tri[k] += [tuple(tri)]
+                else:
+                    edge_to_tri[k] = [tuple(tri)]
+
+            # add triangle to graph with prior probability estimate
+            p = self._compute_proj_area(tri_verts) / (4 * math.pi)
+            nodes[tuple(tri)] = Mesh3D._GraphVertex(p, tri)
+
+        # connect nodes in the graph based on geometric toppling criteria
+        # a directed edge between two graph nodes implies that landing on one face will lead to toppling onto its successor
+        # an outdegree of 0 for any graph node implies it is a sink (the object will come to rest if it topples to this face)
+        for tri in cvh_tris:
+            # vertices
+            tri_verts = [cvh_verts[i] for i in tri]
+
+            # project the center of mass onto the triangle
+            proj_cm = Mesh3D._proj_point_to_plane(tri_verts, cm)
+
+            # update list of top vertices, add edges between vertices as needed
+            if not Mesh3D._point_in_tri(tri_verts, proj_cm):
+                # form segment objects
+                s1 = Mesh3D._Segment(tri_verts[0], tri_verts[1])
+                s2 = Mesh3D._Segment(tri_verts[0], tri_verts[2])
+                s3 = Mesh3D._Segment(tri_verts[1], tri_verts[2])
+
+                # compute the closest edges
+                closest_edges = Mesh3D._closest_segment(proj_cm, [s1, s2, s3])
+
+                # choose the closest edge based on the midpoint of the triangle segments
+                if len(closest_edges) == 1:
+                    closest_edge = closest_edges[0]
+                else:
+                    closest_edge = Mesh3D._closer_segment(proj_cm, closest_edges[0], closest_edges[1])
+
+                    # compute the topple face from the closest edge
+                for face in edge_to_tri[closest_edge.tup]:
+                    if list(face) != list(tri):
+                        topple_face = face
+                predecessor = nodes[tuple(tri)]
+                successor = nodes[tuple(topple_face)]
+                predecessor.add_edge(successor)
+
+        # save to class variable
+        self.face_dag_ = Mesh3D._FaceDAG(cvh_mesh, nodes, vertex_to_tri, edge_to_tri)
+
+    class _Segment:
+        """Object representation of a finite line segment in 3D space.
+
+        Attributes
+        ----------
+        p1 : :obj:`numpy.ndarray` of float
+            The first endpoint of the line segment
+        p2 : :obj:`numpy.ndarray` of float
+            The second endpoint of the line segment
+        tup : :obj:`tuple` of :obj:`tuple` of float
+            A tuple representation of the segment, with the two
+            endpoints arranged in lexicographical order.
+        """
+
+        def __init__(self, p1, p2):
+            """Creates a Segment with given endpoints.
+
+            Parameters
+            ----------
+            p1 : :obj:`numpy.ndarray` of float
+                The first endpoint of the line segment
+            p2 : :obj:`numpy.ndarray` of float
+                The second endpoint of the line segment
+            """
+            self.p1 = p1
+            self.p2 = p2
+            self.tup = self._ordered_tuple()
+
+        def dist_to_point(self, point):
+            """Computes the distance from the segment to the given 3D point.
+
+            Parameters
+            ----------
+            point : :obj:`numpy.ndarray` of float
+                The 3D point to measure distance to.
+
+            Returns
+            -------
+            float
+                The euclidean distance between the segment and the point.
+            """
+            p1, p2 = self.p1, self.p2
+            ap = point - p1
+            ab = p2 - p1
+            proj_point = p1 + (np.dot(ap, ab) / np.dot(ab, ab)) * ab
+            if self._contains_proj_point(proj_point):
+                return np.linalg.norm(point - proj_point)
+            else:
+                return min(np.linalg.norm(point - p1),
+                           np.linalg.norm(point - p2))
+
+        def _contains_proj_point(self, point):
+            """Is the given 3D point (assumed to be on the line that contains
+            the segment) actually within the segment?
+
+            Parameters
+            ----------
+            point : :obj:`numpy.ndarray` of float
+                The 3D point to check against.
+
+            Returns
+            -------
+            bool
+                True if the point was within the segment or False otherwise.
+            """
+            p1, p2 = self.p1, self.p2
+            return (point[0] >= min(p1[0], p2[0]) and point[0] <= max(p1[0], p2[0]) and
+                    point[1] >= min(p1[1], p2[1]) and point[1] <= max(p1[1], p2[1]) and
+                    point[2] >= min(p1[2], p2[2]) and point[2] <= max(p1[2], p2[2]))
+
+        def _ordered_tuple(self):
+            """Returns an ordered tuple that represents the segment.
+
+            The points within are ordered lexicographically.
+
+            Returns
+            -------
+
+            tup : :obj:`tuple` of :obj:`tuple` of float
+                A tuple representation of the segment, with the two
+                endpoints arranged in lexicographical order.
+            """
+            if (self.p1.tolist() > self.p2.tolist()):
+                return (tuple(self.p1), tuple(self.p2))
+            else:
+                return (tuple(self.p2), tuple(self.p1))
+
+    class _FaceDAG:
+        """ A directed acyclic graph specifying the topppling dependency structure
+        for faces of a given mesh geometry with a specific center of mass.
+        Useful for quasi-static stable pose analysis.
+
+        Attributes
+        ----------
+        mesh : :obj:`Mesh3D`
+            the 3D triangular mesh that the DAG refers to (usually the convex hull) 
+        nodes : :obj:`dict` mapping 3-`tuple` of integers (triangles) to :obj:`Mesh3D._GraphVertex`
+            the nodes in the DAG
+        vertex_to_tri : :obj:`dict` mapping :obj:`int` (vertex indices) to 3-`tuple` of integers (triangles)
+        edge_to_tri : :obj:`dict` mapping 2-`tuple` of integers (edges) to 3-`tuple` of integers (triangles)
+        """
+
+        def __init__(self, mesh, nodes, vertex_to_tri, edge_to_tri):
+            self.mesh = mesh
+            self.nodes = nodes
+            self.vertex_to_tri = vertex_to_tri
+            self.edge_to_tri = edge_to_tri
+
+    class _GraphVertex:
+        """A directed graph vertex that links a probability to a face.
+        """
+
+        def __init__(self, probability, face):
+            """Create a graph vertex with given probability and face.
+
+            Parameters
+            ----------
+            probability : float
+                Probability associated with this vertex.
+            face : :obj:`numpy.ndarray` of int
+                A 3x3 array that represents the face
+                associated with this vertex. Each row is a list
+                of vertices in one face.
+            """
+            self.probability = probability
+            self.children = []
+            self.parents = []
+            self.face = face
+            self.has_parent = False
+            self.num_parents = 0
+            self.sink = None
+
+        @property
+        def is_sink(self):
+            return len(self.children) == 0
+
+        def add_edge(self, child):
+            """Connects this vertex to the input child vertex.
+
+            Parameters
+            ----------
+            child : :obj:`_GraphVertex`
+                The child to link to.
+            """
+            self.children.append(child)
+            child.parents.append(self)
+            child.has_parent = True
+            child.num_parents += 1
+
+    @staticmethod
+    def _max_edge_length(tri, vertices):
+        """Compute the maximum edge length of a triangle.
+
+        Parameters
+        ----------
+        tri : :obj:`numpy.ndarray` of int
+            The triangle of interest.
+
+        vertices : :obj:`numpy.ndarray` of `numpy.ndarray` of float
+            The set of vertices which the face references.
+
+        Returns
+        -------
+        float
+            The max edge length of the triangle.
+        """
+        v0 = np.array(vertices[tri[0]])
+        v1 = np.array(vertices[tri[1]])
+        v2 = np.array(vertices[tri[2]])
+        max_edge_len = max(np.linalg.norm(v1 - v0),
+                           max(np.linalg.norm(v1 - v0),
+                               np.linalg.norm(v2 - v1)))
+        return max_edge_len
+
+    @staticmethod
+    def _proj_point_to_plane(tri_verts, point):
+        """Project the given point onto the plane containing the three points in
+        tri_verts.
+
+        Parameters
+        ----------
+        tri_verts : :obj:`numpy.ndarray` of float
+            A list of three 3D points that defines a plane.
+        point : :obj:`numpy.ndarray` of float
+            The 3D point to project onto the plane.
+        """
+
+        # Compute a normal vector to the triangle
+        v0 = tri_verts[2] - tri_verts[0]
+        v1 = tri_verts[1] - tri_verts[0]
+        n = np.cross(v0, v1)
+        n = n / np.linalg.norm(n)
+
+        # Compute distance from the point to the triangle's plane
+        # by projecting a vector from the plane to the point onto
+        # the normal vector
+        dist = np.dot(n, point - tri_verts[0])
+
+        # Project the point back along the normal vector
+        return (point - dist * n)
+
+    @staticmethod
+    def _point_in_tri(tri_verts, point):
+        """Is the given point contained in the given triangle?
+
+        Parameters
+        ----------
+        tri_verts : :obj:`list` of :obj:`numpy.ndarray` of float
+            A list of three 3D points that definie a triangle.
+
+        point : :obj:`numpy.ndarray` of float
+            A 3D point that should be coplanar with the triangle.
+
+        Returns
+        -------
+        bool
+            True if the point is in the triangle, False otherwise.
+        """
+        # Implementation provided by http://blackpawn.com/texts/pointinpoly/
+
+        # Compute vectors
+        v0 = tri_verts[2] - tri_verts[0]
+        v1 = tri_verts[1] - tri_verts[0]
+        v2 = point - tri_verts[0]
+
+        # Compute Dot Products
+        dot00 = np.dot(v0, v0)
+        dot01 = np.dot(v0, v1)
+        dot02 = np.dot(v0, v2)
+        dot11 = np.dot(v1, v1)
+        dot12 = np.dot(v1, v2)
+
+        # Compute Barycentric Coords
+        inv_denom = 1.0 / (dot00 * dot11 - dot01 * dot01)
+        u = (dot11 * dot02 - dot01 * dot12) * inv_denom
+        v = (dot00 * dot12 - dot01 * dot02) * inv_denom
+
+        # Check if point is in triangle
+        return (u >= 0.0 and v >= 0.0 and u + v <= 1.0)
+
+    @staticmethod
+    def _closest_segment(point, line_segments):
+        """Returns the finite line segment(s) the least distance from the input point.
+
+        Parameters
+        ----------
+        point : :obj:`numpy.ndarray` of float
+            The 3D point to measure distance to.
+        line_segments: :obj:`list` of :obj:`_Segments`
+            The list of line segments.
+
+        Returns
+        -------
+        :obj:`list` of :obj:`_Segments`
+            The list of line segments that were closest to the input point.
+        """
+        min_dist = sys.maxsize
+        min_segs = []
+        distances = []
+        segments = []
+        common_endpoint = None
+
+        for segment in line_segments:
+            dist = segment.dist_to_point(point)
+            distances.append(dist)
+            segments.append(segment)
+            if dist < min_dist:
+                min_dist = dist
+
+        for i in range(len(distances)):
+            if min_dist + 0.000001 >= distances[i]:
+                min_segs.append(segments[i])
+
+        return min_segs
+
+    @staticmethod
+    def _closer_segment(point, s1, s2):
+        """ Compute which segment is closer to a given point by seeing
+        which side of the midline between the two segments the point falls on.
+
+        Parameters
+        ----------
+        point : :obj:`numpy.ndarray`
+            3d array containing point projected onto plane spanned by s1, s1
+        s1 : :obj:`Mesh3D._Segment`
+            first segment to check
+        s2 : :obj:`Mesh3D._Segment`
+            second segment to check
+
+        Returns
+        -------
+        :obj:`Mesh3D._Segment`
+            best segment to check        
+        """
+        # find the shared vertex and compute the midline between the segments
+        if np.allclose(s1.p1, s2.p1):
+            p = s1.p1
+            l1 = s1.p2 - p
+            l2 = s2.p2 - p
+        elif np.allclose(s1.p2, s2.p1):
+            p = s1.p2
+            l1 = s1.p1 - p
+            l2 = s2.p2 - p
+        elif np.allclose(s1.p1, s2.p2):
+            p = s1.p1
+            l1 = s1.p2 - p
+            l2 = s2.p1 - p
+        else:
+            p = s1.p2
+            l1 = s1.p1 - p
+            l2 = s2.p1 - p
+        v = point - p
+        midline = 0.5 * (l1 + l2)
+
+        # compute projection onto the midline
+        if np.linalg.norm(midline) == 0:
+            raise ValueError('Illegal triangle')
+        alpha = midline.dot(v) / midline.dot(midline)
+        w = alpha * midline
+
+        # compute residual (component of query point orthogonal to midline)
+        x = v - w
+
+        # figure out which line is on the same side of the midline
+        # as the residual
+        d1 = x.dot(l1)
+        d2 = x.dot(l2)
+        closer_segment = s2
+        if d1 > d2:
+            closer_segment = s1
+        return closer_segment
+
+    @staticmethod
+    def _compute_prob_map(vertices, cvh_verts, cm):
+        """Creates a map from faces to static stability probabilities.
+
+        Parameters
+        ----------
+        vertices : :obj:`list` of :obj:`_GraphVertex`
+
+        Returns
+        -------
+        :obj:`dictionary` of :obj:`tuple` of int to float
+            Maps tuple representations of faces to probabilities.
+        """
+        # follow the child nodes of each vertex until a sink, then add in the resting probability
+        prob_mapping = {}
+        for vertex in vertices:
+            c = vertex
+            visited = []
+            while not c.is_sink:
+                if c in visited:
+                    break
+                visited.append(c)
+                c = c.children[0]
+
+            if tuple(c.face) not in list(prob_mapping.keys()):
+                prob_mapping[tuple(c.face)] = 0.0
+            prob_mapping[tuple(c.face)] += vertex.probability
+            vertex.sink = c
+
+        # set resting probabilities of faces to zero
+        for vertex in vertices:
+            if not vertex.is_sink:
+                prob_mapping[tuple(vertex.face)] = 0
+
+        return prob_mapping
+
+
+if __name__ == '__main__':
+    pass

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/obj_file.py

@@ -0,0 +1,150 @@
+"""
+File for loading and saving meshes from .OBJ files
+Author: Jeff Mahler
+"""
+import os
+try:
+    from . import mesh
+except ImportError:
+    import mesh
+
+
+class ObjFile(object):
+    """
+    A Wavefront .obj file reader and writer.
+
+    Attributes
+    ----------
+    filepath : :obj:`str`
+        The full path to the .obj file associated with this reader/writer.
+    """
+
+    def __init__(self, filepath):
+        """Construct and initialize a .obj file reader and writer.
+
+        Parameters
+        ----------
+        filepath : :obj:`str`
+            The full path to the desired .obj file
+
+        Raises
+        ------
+        ValueError
+            If the file extension is not .obj.
+        """
+        self.filepath_ = filepath
+        file_root, file_ext = os.path.splitext(self.filepath_)
+        if file_ext != '.obj':
+            raise ValueError('Extension %s invalid for OBJs' %(file_ext))
+
+    @property
+    def filepath(self):
+        """Returns the full path to the .obj file associated with this reader/writer.
+
+        Returns
+        -------
+        :obj:`str`
+            The full path to the .obj file associated with this reader/writer.
+        """
+        return self.filepath_
+
+    def read(self):
+        """Reads in the .obj file and returns a Mesh3D representation of that mesh.
+
+        Returns
+        -------
+        :obj:`Mesh3D`
+            A Mesh3D created from the data in the .obj file.
+        """
+        numVerts = 0  
+        verts = []
+        norms = None
+        faces = []
+        tex_coords = []
+        face_norms = []
+        f = open(self.filepath_, 'r')
+
+        for line in f:  
+            # Break up the line by whitespace
+            vals = line.split()
+            if len(vals) > 0:
+                # Look for obj tags (see http://en.wikipedia.org/wiki/Wavefront_.obj_file)
+                if vals[0] == 'v':
+                    # Add vertex
+                    v = list(map(float, vals[1:4]))
+                    verts.append(v)
+                if vals[0] == 'vn':
+                    # Add normal
+                    if norms is None:
+                        norms = []
+                    n = list(map(float, vals[1:4]))
+                    norms.append(n)  
+                if vals[0] == 'f':
+                    # Add faces (includes vertex indices, texture coordinates, and normals)
+                    vi = []
+                    vti = []
+                    nti = []
+                    if vals[1].find('/') == -1:
+                        vi = list(map(int, vals[1:]))
+                        vi = [i - 1 for i in vi]
+                    else:
+                        for j in range(1, len(vals)):
+                            # Break up like by / to read vert inds, tex coords, and normal inds
+                            val = vals[j]
+                            tokens = val.split('/')
+                            for i in range(len(tokens)):
+                                if i == 0:
+                                    vi.append(int(tokens[i]) - 1) # adjust for python 0 - indexing
+                                elif i == 1:
+                                    if tokens[i] != '':
+                                        vti.append(int(tokens[i]))
+                                elif i == 2:
+                                    nti.append(int(tokens[i]))
+                    faces.append(vi)
+                    # Below two lists are currently not in use
+                    tex_coords.append(vti)
+                    face_norms.append(nti)
+        f.close()
+
+        return mesh.Mesh3D(verts, faces, norms)
+
+    def write(self, mesh):
+        """Writes a Mesh3D object out to a .obj file format
+
+        Parameters
+        ----------
+        mesh : :obj:`Mesh3D`
+            The Mesh3D object to write to the .obj file.
+
+        Note
+        ----
+        Does not support material files or texture coordinates.
+        """
+        f = open(self.filepath_, 'w')
+        vertices = mesh.vertices
+        faces = mesh.triangles
+        normals = mesh.normals
+
+        # write human-readable header
+        f.write('###########################################################\n')
+        f.write('# OBJ file generated by UC Berkeley Automation Sciences Lab\n')
+        f.write('#\n')
+        f.write('# Num Vertices: %d\n' %(vertices.shape[0]))
+        f.write('# Num Triangles: %d\n' %(faces.shape[0]))
+        f.write('#\n')
+        f.write('###########################################################\n')
+        f.write('\n')
+
+        for v in vertices:
+            f.write('v %f %f %f\n' %(v[0], v[1], v[2]))
+
+        # write the normals list
+        if normals is not None and normals.shape[0] > 0:
+            for n in normals:
+                f.write('vn %f %f %f\n' %(n[0], n[1], n[2]))
+
+        # write the normals list
+        for t in faces:
+            f.write('f %d %d %d\n' %(t[0]+1, t[1]+1, t[2]+1)) # convert back to 1-indexing
+
+        f.close()

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/sdf.py

@@ -0,0 +1,773 @@
+"""
+Definition of SDF Class
+Author: Sahaana Suri, Jeff Mahler, and Matt Matl
+
+**Currently assumes clean input**
+"""
+from abc import ABCMeta, abstractmethod
+import logging
+import numpy as np
+from numbers import Number
+
+import time
+
+from autolab_core import RigidTransform, SimilarityTransform, PointCloud, Point, NormalCloud
+
+
+from sys import version_info
+if version_info[0] != 3:
+    range = xrange
+
+
+# class Sdf(metaclass=ABCMeta):  # work for python3
+class Sdf():
+    """ Abstract class for signed distance fields.
+    """
+    __metaclass__ = ABCMeta
+    ##################################################################
+    # General SDF Properties
+    ##################################################################
+    @property
+    def dimensions(self):
+        """SDF dimension information.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of int
+            The ndarray that contains the dimensions of the sdf.
+        """
+        return self.dims_
+
+    @property
+    def origin(self):
+        """The location of the origin in the SDF grid.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 2- or 3-ndarray that contains the location of
+            the origin of the mesh grid in real space.
+        """
+        return self.origin_
+
+    @property
+    def resolution(self):
+        """The grid resolution (how wide each grid cell is).
+
+        Returns
+        -------
+        float
+            The width of each grid cell.
+        """
+        return self.resolution_
+
+    @property
+    def center(self):
+        """Center of grid.
+
+        This basically transforms the world frame to grid center.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray`
+        """
+        return self.center_
+
+    @property
+    def gradients(self):
+        """Gradients of the SDF.
+
+        Returns
+        -------
+        :obj:`list` of :obj:`numpy.ndarray` of float
+            A list of ndarrays of the same dimension as the SDF. The arrays
+            are in axis order and specify the gradients for that axis
+            at each point.
+        """
+        return self.gradients_
+
+    @property
+    def data(self):
+        """The SDF data.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 2- or 3-dimensional ndarray that holds the grid of signed
+            distances.
+        """
+        return self.data_
+
+    ##################################################################
+    # General SDF Abstract Methods
+    ##################################################################
+    @abstractmethod
+    def transform(self, tf):
+        """Returns a new SDF transformed by similarity tf.
+        """
+        pass
+
+    @abstractmethod
+    def transform_pt_obj_to_grid(self, x_world, direction=False):
+        """Transforms points from world frame to grid frame
+        """
+        pass
+
+    @abstractmethod
+    def transform_pt_grid_to_obj(self, x_grid, direction=False):
+        """Transforms points from grid frame to world frame
+        """
+        pass
+
+    @abstractmethod
+    def surface_points(self):
+        """Returns the points on the surface.
+
+        Returns
+        -------
+        :obj:`tuple` of :obj:`numpy.ndarray` of int, :obj:`numpy.ndarray` of float
+            The points on the surface and the signed distances at those points.
+        """
+        pass
+
+    @abstractmethod
+    def __getitem__(self, coords):
+        """Returns the signed distance at the given coordinates.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 2- or 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        float
+            The signed distance at the given coords (interpolated).
+        """
+        pass
+
+    ##################################################################
+    # Universal SDF Methods
+    ##################################################################
+    def transform_to_world(self):
+        """Returns an sdf object with center in the world frame of reference.
+        """
+        return self.transform(self.pose_, scale=self.scale_)
+
+    def center_world(self):
+        """Center of grid (basically transforms world frame to grid center)
+        """
+        return self.transform_pt_grid_to_obj(self.center_)
+
+    def on_surface(self, coords):
+        """Determines whether or not a point is on the object surface.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 2- or 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        :obj:`tuple` of bool, float
+            Is the point on the object's surface, and what
+            is the signed distance at that point?
+        """
+        sdf_val = self[coords]
+        if np.abs(sdf_val) < self.surface_thresh_:
+            return True, sdf_val
+        return False, sdf_val
+
+    def is_out_of_bounds(self, coords):
+        """Returns True if coords is an out of bounds access.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 2- or 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        bool
+            Are the coordinates in coords out of bounds?
+        """
+        return np.array(coords < 0).any() or np.array(coords >= self.dims_).any()
+
+    def _compute_gradients(self):
+        """Computes the gradients of the SDF.
+
+        Returns
+        -------
+        :obj:`list` of :obj:`numpy.ndarray` of float
+            A list of ndarrays of the same dimension as the SDF. The arrays
+            are in axis order and specify the gradients for that axis
+            at each point.
+        """
+        self.gradients_ = np.gradient(self.data_)
+
+
+class Sdf3D(Sdf):
+    # static indexing vars
+    num_interpolants = 8
+    min_coords_x = [0, 2, 3, 5]
+    max_coords_x = [1, 4, 6, 7]
+    min_coords_y = [0, 1, 3, 6]
+    max_coords_y = [2, 4, 5, 7]
+    min_coords_z = [0, 1, 2, 4]
+    max_coords_z = [3, 5, 6, 7]
+
+    def __init__(self, sdf_data, origin, resolution, use_abs=False,
+                 T_sdf_world=RigidTransform(from_frame='sdf', to_frame='world')):
+        self.data_ = sdf_data
+        self.origin_ = origin
+        self.resolution_ = resolution
+        self.dims_ = self.data_.shape
+
+        # set up surface params
+        self.surface_thresh_ = self.resolution_ * np.sqrt(2) / 2
+        self.surface_points_ = None
+        self.surface_points_w_ = None
+        self.surface_vals_ = None
+        self._compute_surface_points()
+
+        # resolution is max dist from surface when surf is orthogonal to diagonal grid cells
+        spts, _ = self.surface_points()
+        self.center_ = 0.5 * (np.min(spts, axis=0) + np.max(spts, axis=0))
+        self.points_buf_ = np.zeros([Sdf3D.num_interpolants, 3], dtype=np.int)
+        self.coords_buf_ = np.zeros([3, ])
+        self.pts_ = None
+
+        # tranform sdf basis to grid (X and Z axes are flipped!)
+        t_world_grid = self.resolution_ * self.center_
+        s_world_grid = 1.0 / self.resolution_
+
+        # FIXME: Since in autolab_core==0.0.4, it applies (un)scale transformation before translation in SimilarityTransform
+        # here we shoule use unscaled origin to get the correct world coordinates
+        # PS: in world coordinate, the origin here is the left-bottom-down corner of the padded bounding squre box
+        t_grid_sdf = self.origin
+        self.T_grid_sdf_ = SimilarityTransform(translation=t_grid_sdf,
+                                               scale=self.resolution,
+                                               from_frame='grid',
+                                               to_frame='sdf')
+        self.T_sdf_world_ = T_sdf_world
+        self.T_grid_world_ = self.T_sdf_world_ * self.T_grid_sdf_
+
+        self.T_sdf_grid_ = self.T_grid_sdf_.inverse()
+        self.T_world_grid_ = self.T_grid_world_.inverse()
+        self.T_world_sdf_ = self.T_sdf_world_.inverse()
+
+        # optionally use only the absolute values (useful for non-closed meshes in 3D)
+        self.use_abs_ = use_abs
+        if use_abs:
+            self.data_ = np.abs(self.data_)
+
+        self._compute_gradients()
+        self.surface_points_w_ = self.transform_pt_grid_to_obj(self.surface_points_.T).T
+        surface, _ = self.surface_points(grid_basis=True)
+        self.surface_for_signed_val = surface[np.random.choice(len(surface), 1000)]  # FIXME: for speed
+
+    def transform(self, delta_T):
+        """ Creates a new SDF with a given pose with respect to world coordinates.
+
+        Parameters
+        ----------
+        delta_T : :obj:`autolab_core.RigidTransform`
+            transform from cur sdf to transformed sdf coords
+        """
+        new_T_sdf_world = self.T_sdf_world_ * delta_T.inverse().as_frames('sdf', 'sdf')
+        return Sdf3D(self.data_, self.origin_, self.resolution_, use_abs=self.use_abs_,
+                     T_sdf_world=new_T_sdf_world)
+
+    def _signed_distance(self, coords):
+        """Returns the signed distance at the given coordinates, interpolating
+        if necessary.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        float
+            The signed distance at the given coords (interpolated).
+
+        Raises
+        ------
+        IndexError
+            If the coords vector does not have three entries.
+        """
+        if len(coords) != 3:
+            raise IndexError('Indexing must be 3 dimensional')
+        if self.is_out_of_bounds(coords):
+            logging.debug('Out of bounds access. Snapping to SDF dims')
+            # find cloest surface point
+            surface = self.surface_for_signed_val
+            closest_surface_coord = surface[np.argmin(np.linalg.norm(surface - coords, axis=-1))]
+            sd = np.linalg.norm(self.transform_pt_grid_to_obj(closest_surface_coord) -
+                                self.transform_pt_grid_to_obj(coords)) + \
+                                self.data_[closest_surface_coord[0], closest_surface_coord[1], closest_surface_coord[2]]
+        else:
+            # snap to grid dims
+            self.coords_buf_[0] = max(0, min(coords[0], self.dims_[0] - 1))
+            self.coords_buf_[1] = max(0, min(coords[1], self.dims_[1] - 1))
+            self.coords_buf_[2] = max(0, min(coords[2], self.dims_[2] - 1))
+            # regular indexing if integers
+            if np.issubdtype(type(coords[0]), np.integer) and \
+               np.issubdtype(type(coords[1]), np.integer) and \
+               np.issubdtype(type(coords[2]), np.integer):
+                return self.data_[int(self.coords_buf_[0]), int(self.coords_buf_[1]), int(self.coords_buf_[2])]
+
+            # otherwise interpolate
+            min_coords = np.floor(self.coords_buf_)
+            max_coords = min_coords + 1  # assumed to be on grid
+            self.points_buf_[Sdf3D.min_coords_x, 0] = min_coords[0]
+            self.points_buf_[Sdf3D.max_coords_x, 0] = max_coords[0]
+            self.points_buf_[Sdf3D.min_coords_y, 1] = min_coords[1]
+            self.points_buf_[Sdf3D.max_coords_y, 1] = max_coords[1]
+            self.points_buf_[Sdf3D.min_coords_z, 2] = min_coords[2]
+            self.points_buf_[Sdf3D.max_coords_z, 2] = max_coords[2]
+
+            # bilinearly interpolate points
+            sd = 0.0
+            for i in range(Sdf3D.num_interpolants):
+                p = self.points_buf_[i, :]
+                if self.is_out_of_bounds(p):
+                    v = 0.0
+                else:
+                    v = self.data_[p[0], p[1], p[2]]
+                w = np.prod(-np.abs(p - self.coords_buf_) + 1)
+                sd = sd + w * v
+
+        return sd
+
+    def __getitem__(self, coords):
+        """Returns the signed distance at the given coordinates.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A or 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        float
+            The signed distance at the given coords (interpolated).
+
+        Raises
+        ------
+        IndexError
+            If the coords vector does not have three entries.
+        """
+        return self._signed_distance(coords)
+
+    def gradient(self, coords):
+        """Returns the SDF gradient at the given coordinates, interpolating if necessary
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        Returns
+        -------
+        float
+            The gradient at the given coords (interpolated).
+
+        Raises
+        ------
+        IndexError
+            If the coords vector does not have three entries.
+        """
+        if len(coords) != 3:
+            raise IndexError('Indexing must be 3 dimensional')
+
+        # log warning if out of bounds access
+        if self.is_out_of_bounds(coords):
+            logging.debug('Out of bounds access. Snapping to SDF dims')
+
+        # snap to grid dims
+        self.coords_buf_[0] = max(0, min(coords[0], self.dims_[0] - 1))
+        self.coords_buf_[1] = max(0, min(coords[1], self.dims_[1] - 1))
+        self.coords_buf_[2] = max(0, min(coords[2], self.dims_[2] - 1))
+
+        # regular indexing if integers
+        if type(coords[0]) is int and type(coords[1]) is int and type(coords[2]) is int:
+            self.coords_buf_ = self.coords_buf_.astype(np.int)
+            return self.data_[self.coords_buf_[0], self.coords_buf_[1], self.coords_buf_[2]]
+
+        # otherwise interpolate
+        min_coords = np.floor(self.coords_buf_)
+        max_coords = min_coords + 1
+        self.points_buf_[Sdf3D.min_coords_x, 0] = min_coords[0]
+        self.points_buf_[Sdf3D.max_coords_x, 0] = min_coords[0]
+        self.points_buf_[Sdf3D.min_coords_y, 1] = min_coords[1]
+        self.points_buf_[Sdf3D.max_coords_y, 1] = max_coords[1]
+        self.points_buf_[Sdf3D.min_coords_z, 2] = min_coords[2]
+        self.points_buf_[Sdf3D.max_coords_z, 2] = max_coords[2]
+
+        # bilinear interpolation
+        g = np.zeros(3)
+        gp = np.zeros(3)
+        w_sum = 0.0
+        for i in range(Sdf3D.num_interpolants):
+            p = self.points_buf_[i, :]
+            if self.is_out_of_bounds(p):
+                gp[0] = 0.0
+                gp[1] = 0.0
+                gp[2] = 0.0
+            else:
+                gp[0] = self.gradients_[0][p[0], p[1], p[2]]
+                gp[1] = self.gradients_[1][p[0], p[1], p[2]]
+                gp[2] = self.gradients_[2][p[0], p[1], p[2]]
+
+            w = np.prod(-np.abs(p - self.coords_buf_) + 1)
+            g = g + w * gp
+
+        return g
+
+    def curvature(self, coords, delta=0.001):
+        """
+        Returns an approximation to the local SDF curvature (Hessian) at the
+        given coordinate in grid basis.
+
+        Parameters
+        ---------
+        coords : numpy 3-vector
+            the grid coordinates at which to get the curvature
+        delta :
+        Returns
+        -------
+        curvature : 3x3 ndarray of the curvature at the surface points
+        """
+        # perturb local coords
+        coords_x_up = coords + np.array([delta, 0, 0])
+        coords_x_down = coords + np.array([-delta, 0, 0])
+        coords_y_up = coords + np.array([0, delta, 0])
+        coords_y_down = coords + np.array([0, -delta, 0])
+        coords_z_up = coords + np.array([0, 0, delta])
+        coords_z_down = coords + np.array([0, 0, -delta])
+
+        # get gradient
+        grad_x_up = self.gradient(coords_x_up)
+        grad_x_down = self.gradient(coords_x_down)
+        grad_y_up = self.gradient(coords_y_up)
+        grad_y_down = self.gradient(coords_y_down)
+        grad_z_up = self.gradient(coords_z_up)
+        grad_z_down = self.gradient(coords_z_down)
+
+        # finite differences
+        curvature_x = (grad_x_up - grad_x_down) / (4 * delta)
+        curvature_y = (grad_y_up - grad_y_down) / (4 * delta)
+        curvature_z = (grad_z_up - grad_z_down) / (4 * delta)
+        curvature = np.c_[curvature_x, np.c_[curvature_y, curvature_z]]
+        curvature = curvature + curvature.T
+        return curvature
+
+    def surface_normal(self, coords, delta=1.5):
+        """Returns the sdf surface normal at the given coordinates by
+        computing the tangent plane using SDF interpolation.
+
+        Parameters
+        ----------
+        coords : :obj:`numpy.ndarray` of int
+            A 3-dimensional ndarray that indicates the desired
+            coordinates in the grid.
+
+        delta : float
+            A radius for collecting surface points near the target coords
+            for calculating the surface normal.
+
+        Returns
+        -------
+        :obj:`numpy.ndarray` of float
+            The 3-dimensional ndarray that represents the surface normal.
+
+        Raises
+        ------
+        IndexError
+            If the coords vector does not have three entries.
+        """
+        if len(coords) != 3:
+            raise IndexError('Indexing must be 3 dimensional')
+
+        # log warning if out of bounds access
+        if self.is_out_of_bounds(coords):
+            logging.debug('Out of bounds access. Snapping to SDF dims')
+
+        # snap to grid dims
+        # coords[0] = max(0, min(coords[0], self.dims_[0] - 1))
+        # coords[1] = max(0, min(coords[1], self.dims_[1] - 1))
+        # coords[2] = max(0, min(coords[2], self.dims_[2] - 1))
+        index_coords = np.zeros(3)
+
+        # check points on surface
+        sdf_val = self[coords]
+        if np.abs(sdf_val) >= self.surface_thresh_:
+            logging.debug('Cannot compute normal. Point must be on surface')
+            return None
+
+        # collect all surface points within the delta sphere
+        X = []
+        d = np.zeros(3)
+        dx = -delta
+        while dx <= delta:
+            dy = -delta
+            while dy <= delta:
+                dz = -delta
+                while dz <= delta:
+                    d = np.array([dx, dy, dz])
+                    if dx != 0 or dy != 0 or dz != 0:
+                        d = delta * d / np.linalg.norm(d)
+                    index_coords[0] = coords[0] + d[0]
+                    index_coords[1] = coords[1] + d[1]
+                    index_coords[2] = coords[2] + d[2]
+                    sdf_val = self[index_coords]
+                    if np.abs(sdf_val) < self.surface_thresh_:
+                        X.append([index_coords[0], index_coords[1], index_coords[2], sdf_val])
+                    dz += delta
+                dy += delta
+            dx += delta
+
+        # fit a plane to the surface points
+        X.sort(key=lambda x: x[3])
+        X = np.array(X)[:, :3]
+        A = X - np.mean(X, axis=0)
+        try:
+            U, S, V = np.linalg.svd(A.T)
+            n = U[:, 2]
+        except:
+            logging.warning('Tangent plane does not exist. Returning None.')
+            return None
+        # make sure surface normal is outward
+        # referenced from Zhou Xian's github, but if the model is not watertight, this method may fail
+        # https://github.com/zhouxian/meshpy_berkeley/commit/96428f3b7af618a0828a7eb88f22541cdafacfc7
+        if self[coords + n * 0.01] < self[coords]:
+            n = -n
+        return n
+
+    def _compute_surface_points(self):
+        surface_points = np.where(np.abs(self.data_) < self.surface_thresh_)
+        x = surface_points[0]
+        y = surface_points[1]
+        z = surface_points[2]
+        self.surface_points_ = np.c_[x, np.c_[y, z]]
+        self.surface_vals_ = self.data_[self.surface_points_[:, 0], self.surface_points_[:, 1],
+                                        self.surface_points_[:, 2]]
+
+    def surface_points(self, grid_basis=True):
+        """Returns the points on the surface.
+
+        Parameters
+        ----------
+        grid_basis : bool
+            If False, the surface points are transformed to the world frame.
+            If True (default), the surface points are left in grid coordinates.
+
+        Returns
+        -------
+        :obj:`tuple` of :obj:`numpy.ndarray` of int, :obj:`numpy.ndarray` of float
+            The points on the surface and the signed distances at those points.
+        """
+        if not grid_basis:
+            return self.surface_points_w_, self.surface_vals_
+        return self.surface_points_, self.surface_vals_
+
+    def rescale(self, scale):
+        """ Rescale an SDF by a given scale factor.
+
+        Parameters
+        ----------
+        scale : float
+            the amount to scale the SDF
+
+        Returns
+        -------
+        :obj:`Sdf3D`
+            new sdf with given scale
+        """
+        resolution_tf = scale * self.resolution_
+        return Sdf3D(self.data_, self.origin_, resolution_tf, use_abs=self.use_abs_,
+                     T_sdf_world=self.T_sdf_world_)
+
+    def transform_dense(self, delta_T, detailed=False):
+        """ Transform the grid by pose T and scale with canonical reference
+        frame at the SDF center with axis alignment.
+
+        Parameters
+        ----------
+        delta_T : SimilarityTransform
+            the transformation from the current frame of reference to the new frame of reference
+        detailed : bool
+            whether or not to use interpolation
+
+        Returns
+        -------
+        :obj:`Sdf3D`
+            new sdf with grid warped by T
+        """
+        # map all surface points to their new location
+        start_t = time.clock()
+
+        # form points array
+        if self.pts_ is None:
+            [x_ind, y_ind, z_ind] = np.indices(self.dims_)
+            self.pts_ = np.c_[x_ind.flatten().T, np.c_[y_ind.flatten().T, z_ind.flatten().T]].astype(np.float32)
+
+        # transform points
+        num_pts = self.pts_.shape[0]
+        pts_sdf = self.T_grid_sdf_ * PointCloud(self.pts_.T, frame='grid')
+        pts_sdf_tf = delta_T.as_frames('sdf', 'sdf') * pts_sdf
+        pts_grid_tf = self.T_sdf_grid_ * pts_sdf_tf
+        pts_tf = pts_grid_tf.data.T
+        all_points_t = time.clock()
+
+        # transform the center
+        origin_sdf = self.T_grid_sdf_ * Point(self.origin_, frame='grid')
+        origin_sdf_tf = delta_T.as_frames('sdf', 'sdf') * origin_sdf
+        origin_tf = self.T_sdf_grid_ * origin_sdf_tf
+        origin_tf = origin_tf.data
+
+        # use same resolution (since indices will be rescaled)
+        resolution_tf = self.resolution_
+        origin_res_t = time.clock()
+
+        # add each point to the new pose
+        if detailed:
+            sdf_data_tf = np.zeros([num_pts, 1])
+            for i in range(num_pts):
+                sdf_data_tf[i] = self[pts_tf[i, 0], pts_tf[i, 1], pts_tf[i, 2]]
+        else:
+            pts_tf_round = np.round(pts_tf).astype(np.int64)
+
+            # snap to closest boundary
+            pts_tf_round[:, 0] = np.max(np.c_[np.zeros([num_pts, 1]), pts_tf_round[:, 0]], axis=1)
+            pts_tf_round[:, 0] = np.min(np.c_[(self.dims_[0] - 1) * np.ones([num_pts, 1]), pts_tf_round[:, 0]], axis=1)
+
+            pts_tf_round[:, 1] = np.max(np.c_[np.zeros([num_pts, 1]), pts_tf_round[:, 1]], axis=1)
+            pts_tf_round[:, 1] = np.min(np.c_[(self.dims_[1] - 1) * np.ones([num_pts, 1]), pts_tf_round[:, 1]], axis=1)
+
+            pts_tf_round[:, 2] = np.max(np.c_[np.zeros([num_pts, 1]), pts_tf_round[:, 2]], axis=1)
+            pts_tf_round[:, 2] = np.min(np.c_[(self.dims_[2] - 1) * np.ones([num_pts, 1]), pts_tf_round[:, 2]], axis=1)
+
+            sdf_data_tf = self.data_[pts_tf_round[:, 0], pts_tf_round[:, 1], pts_tf_round[:, 2]]
+
+        sdf_data_tf_grid = sdf_data_tf.reshape(self.dims_)
+        tf_t = time.clock()
+
+        logging.debug('Sdf3D: Time to transform coords: %f' % (all_points_t - start_t))
+        logging.debug('Sdf3D: Time to transform origin: %f' % (origin_res_t - all_points_t))
+        logging.debug('Sdf3D: Time to transfer sd: %f' % (tf_t - origin_res_t))
+        return Sdf3D(sdf_data_tf_grid, origin_tf, resolution_tf, use_abs=self._use_abs_, T_sdf_world=self.T_sdf_world_)
+
+    def transform_pt_obj_to_grid(self, x_sdf, direction=False):
+        """ Converts a point in sdf coords to the grid basis. If direction then don't translate.
+
+        Parameters
+        ----------
+        x_sdf : numpy 3xN ndarray or numeric scalar
+            points to transform from sdf basis in meters to grid basis
+        direction : bool
+        Returns
+        -------
+        x_grid : numpy 3xN ndarray or scalar
+            points in grid basis
+        """
+        if isinstance(x_sdf, Number):
+            return self.T_world_grid_.scale * x_sdf
+        if direction:
+            points_sdf = NormalCloud(x_sdf.astype(np.float32), frame='world')
+        else:
+            points_sdf = PointCloud(x_sdf.astype(np.float32), frame='world')
+        x_grid = self.T_world_grid_ * points_sdf
+        return x_grid.data
+
+    def transform_pt_grid_to_obj(self, x_grid, direction=False):
+        """ Converts a point in grid coords to the world basis. If direction then don't translate.
+        
+        Parameters
+        ----------
+        x_grid : numpy 3xN ndarray or numeric scalar
+            points to transform from grid basis to sdf basis in meters
+        direction : bool
+        Returns
+        -------
+        x_sdf : numpy 3xN ndarray
+            points in sdf basis (meters)
+        """
+        if isinstance(x_grid, Number):
+            return self.T_grid_world_.scale * x_grid
+        if direction:
+            points_grid = NormalCloud(x_grid.astype(np.float32), frame='grid')
+        else:
+            points_grid = PointCloud(x_grid.astype(np.float32), frame='grid')
+        x_sdf = self.T_grid_world_ * points_grid
+        return x_sdf.data
+
+    @staticmethod
+    def find_zero_crossing_linear(x1, y1, x2, y2):
+        """ Find zero crossing using linear approximation"""
+        # NOTE: use sparingly, approximations can be shoddy
+        d = x2 - x1
+        t1 = 0
+        t2 = np.linalg.norm(d)
+        v = d / t2
+
+        m = (y2 - y1) / (t2 - t1)
+        b = y1
+        t_zc = -b / m
+        x_zc = x1 + t_zc * v
+        return x_zc
+
+    @staticmethod
+    def find_zero_crossing_quadratic(x1, y1, x2, y2, x3, y3, eps=1.0):
+        """ Find zero crossing using quadratic approximation along 1d line"""
+        # compute coords along 1d line
+        v = x2 - x1
+        v = v / np.linalg.norm(v)
+        if v[v != 0].shape[0] == 0:
+            logging.error('Difference is 0. Probably a bug')
+
+        t1 = 0
+        t2 = (x2 - x1)[v != 0] / v[v != 0]
+        t2 = t2[0]
+        t3 = (x3 - x1)[v != 0] / v[v != 0]
+        t3 = t3[0]
+
+        # solve for quad approx
+        x1_row = np.array([t1 ** 2, t1, 1])
+        x2_row = np.array([t2 ** 2, t2, 1])
+        x3_row = np.array([t3 ** 2, t3, 1])
+        X = np.array([x1_row, x2_row, x3_row])
+        y_vec = np.array([y1, y2, y3])
+        try:
+            w = np.linalg.solve(X, y_vec)
+        except np.linalg.LinAlgError:
+            logging.error('Singular matrix. Probably a bug')
+            return None
+
+        # get positive roots
+        possible_t = np.roots(w)
+        t_zc = None
+        for i in range(possible_t.shape[0]):
+            if 0 <= possible_t[i] <= 10 and not np.iscomplex(possible_t[i]):
+                t_zc = possible_t[i]
+
+        # if no positive roots find min
+        if np.abs(w[0]) < 1e-10:
+            return None
+
+        if t_zc is None:
+            t_zc = -w[1] / (2 * w[0])
+
+        if t_zc < -eps or t_zc > eps:
+            return None
+
+        x_zc = x1 + t_zc * v
+        return x_zc

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/sdf_file.py

@@ -0,0 +1,127 @@
+'''
+Reads and writes sdfs to file
+Author: Jeff Mahler
+'''
+import numpy as np
+import os
+
+from . import sdf
+
+class SdfFile:
+    """
+    A Signed Distance Field .sdf file reader and writer.
+
+    Attributes
+    ----------
+    filepath : :obj:`str`
+        The full path to the .sdf or .csv file associated with this reader/writer.
+    """
+    def __init__(self, filepath):
+        """Construct and initialize a .sdf file reader and writer.
+
+        Parameters
+        ----------
+        filepath : :obj:`str`
+            The full path to the desired .sdf or .csv file
+
+        Raises
+        ------
+        ValueError
+            If the file extension is not .sdf of .csv.
+        """
+        self.filepath_ = filepath
+        file_root, file_ext = os.path.splitext(self.filepath_)
+
+        if file_ext == '.sdf':
+            self.use_3d_ = True
+        elif file_ext == '.csv':
+            self.use_3d_ = False
+        else:
+            raise ValueError('Extension %s invalid for SDFs' %(file_ext))
+
+    @property
+    def filepath(self):
+        """Returns the full path to the file associated with this reader/writer.
+
+        Returns
+        -------
+        :obj:`str`
+            The full path to the file associated with this reader/writer.
+        """
+        return self.filepath_
+
+    def read(self):
+        """Reads in the SDF file and returns a Sdf object.
+
+        Returns
+        -------
+        :obj:`Sdf`
+            A Sdf created from the data in the file.
+        """
+        if self.use_3d_:
+            return self._read_3d()
+        else:
+            return self._read_2d()
+
+
+    def _read_3d(self):
+        """Reads in a 3D SDF file and returns a Sdf object.
+
+        Returns
+        -------
+        :obj:`Sdf3D`
+            A 3DSdf created from the data in the file.
+        """
+        if not os.path.exists(self.filepath_):
+            return None
+
+        my_file = open(self.filepath_, 'r')
+        nx, ny, nz = [int(i) for i in my_file.readline().split()]     #dimension of each axis should all be equal for LSH
+        ox, oy, oz = [float(i) for i in my_file.readline().split()]   #shape origin
+        dims = np.array([nx, ny, nz])
+        origin = np.array([ox, oy, oz])
+
+        resolution = float(my_file.readline()) # resolution of the grid cells in original mesh coords
+        sdf_data = np.zeros(dims)
+
+        # loop through file, getting each value
+        count = 0
+        for k in range(nz):
+            for j in range(ny):
+                for i in range(nx):
+                    sdf_data[i][j][k] = float(my_file.readline())
+                    count += 1 
+        my_file.close()
+        return sdf.Sdf3D(sdf_data, origin, resolution)
+
+    def _read_2d(self):
+        """Reads in a 2D SDF file and returns a Sdf object.
+
+        Returns
+        -------
+        :obj:`Sdf2D`
+            A 2DSdf created from the data in the file.
+        """
+        if not os.path.exists(self.filepath_):
+            return None
+
+        sdf_data = np.loadtxt(self.filepath_, delimiter=',') 
+        return sdf.Sdf2D(sdf_data)
+
+    def write(self, sdf):
+        """Writes an SDF to a file.
+
+        Parameters
+        ----------
+        sdf : :obj:`Sdf`
+            An Sdf object to write out.
+
+        Note
+        ----
+            This is not currently implemented or supported.
+        """
+        pass
+
+if __name__ == '__main__':
+    pass
+

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/meshpy/stable_pose.py

@@ -0,0 +1,86 @@
+"""
+A basic struct-like Stable Pose class to make accessing pose probability and rotation matrix easier
+
+Author: Matt Matl and Nikhil Sharma
+"""
+import numpy as np
+
+from autolab_core import RigidTransform
+
+d_theta = np.deg2rad(1)
+
+class StablePose(object):
+    """A representation of a mesh's stable pose.
+
+    Attributes
+    ----------
+    p : float
+        Probability associated with this stable pose.
+    r : :obj:`numpy.ndarray` of :obj`numpy.ndarray` of float
+        3x3 rotation matrix that rotates the mesh into the stable pose from
+        standardized coordinates.
+    x0 : :obj:`numpy.ndarray` of float
+        3D point in the mesh that is resting on the table.
+    face : :obj:`numpy.ndarray`
+        3D vector of indices corresponding to vertices forming the resting face
+    stp_id : :obj:`str`
+        A string identifier for the stable pose
+    T_obj_table : :obj:`RigidTransform`
+        A RigidTransform representation of the pose's rotation matrix.
+    """
+    def __init__(self, p, r, x0, face=None, stp_id=-1):
+        """Create a new stable pose object.
+
+        Parameters
+        ----------
+        p : float
+            Probability associated with this stable pose.
+        r : :obj:`numpy.ndarray` of :obj`numpy.ndarray` of float
+            3x3 rotation matrix that rotates the mesh into the stable pose from
+            standardized coordinates.
+        x0 : :obj:`numpy.ndarray` of float
+            3D point in the mesh that is resting on the table.
+        face : :obj:`numpy.ndarray`
+            3D vector of indices corresponding to vertices forming the resting face
+        stp_id : :obj:`str`
+            A string identifier for the stable pose
+        """
+        self.p = p
+        self.r = r
+        self.x0 = x0
+        self.face = face
+        self.id = stp_id
+
+        # fix stable pose bug
+        if np.abs(np.linalg.det(self.r) + 1) < 0.01:
+            self.r[1,:] = -self.r[1,:]
+
+    def __eq__(self, other):
+        """ Check equivalence by rotation about the z axis """
+        if not isinstance(other, StablePose):
+            raise ValueError('Can only compare stable pose objects')
+        R0 = self.r
+        R1 = other.r
+        dR = R1.T.dot(R0)
+        theta = 0
+        while theta < 2 * np.pi:
+            Rz = RigidTransform.z_axis_rotation(theta)
+            dR = R1.T.dot(Rz).dot(R0)
+            if np.linalg.norm(dR - np.eye(3)) < 1e-5:
+                return True
+            theta += d_theta
+        return False
+
+    @property
+    def T_obj_table(self):
+        return RigidTransform(rotation=self.r, from_frame='obj', to_frame='table')
+
+
+    @property
+    def T_obj_world(self):
+        T_world_obj = RigidTransform(rotation=self.r.T,
+                                     translation=self.x0,
+                                     from_frame='world',
+                                     to_frame='obj')
+        return T_world_obj.inverse()
+    

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/dexnet/grasping/quality.py

@@ -0,0 +1,819 @@
+# -*- coding: utf-8 -*-
+# """
+# Copyright ©2017. The Regents of the University of California (Regents). All Rights Reserved.
+# Permission to use, copy, modify, and distribute this software and its documentation for educational,
+# research, and not-for-profit purposes, without fee and without a signed licensing agreement, is
+# hereby granted, provided that the above copyright notice, this paragraph and the following two
+# paragraphs appear in all copies, modifications, and distributions. Contact The Office of Technology
+# Licensing, UC Berkeley, 2150 Shattuck Avenue, Suite 510, Berkeley, CA 94720-1620, (510) 643-
+# 7201, otl@berkeley.edu, http://ipira.berkeley.edu/industry-info for commercial licensing opportunities.
+#
+# IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL,
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF
+# THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF REGENTS HAS BEEN
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIgit clone https://github.com/jeffmahler/Boost.NumPy.git
+# ED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE. THE SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
+# HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
+# MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+# """
+# """
+# Quasi-static point-based grasp quality metrics.
+# Author: Jeff Mahler and Brian Hou
+# """
+import logging
+# logging.root.setLevel(level=logging.DEBUG)
+import numpy as np
+
+try:
+    import pyhull.convex_hull as cvh
+except:
+    # logging.warning('Failed to import pyhull')
+    pass
+try:
+    import cvxopt as cvx
+except:
+    # logging.warning('Failed to import cvx')
+    pass
+import os
+import scipy.spatial as ss
+import sys
+import time
+
+from .grasp import PointGrasp
+from. graspable_object import GraspableObject3D
+from .grasp_quality_config import GraspQualityConfig
+
+from .meshpy import mesh as m
+from .meshpy import sdf as s
+
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+
+import IPython
+
+# turn off output logging
+cvx.solvers.options['show_progress'] = False
+
+
+class PointGraspMetrics3D:
+    """ Class to wrap functions for quasistatic point grasp quality metrics.
+    """
+
+    @staticmethod
+    def grasp_quality(grasp, obj, params, contacts=None, vis=False):
+        """
+        Computes the quality of a two-finger point grasps on a given object using a quasi-static model.
+
+        Parameters
+        ----------
+        grasp : :obj:`ParallelJawPtGrasp3D`
+            grasp to evaluate
+        obj : :obj:`GraspableObject3D`
+            object to evaluate quality on
+        params : :obj:`GraspQualityConfig`
+            parameters of grasp quality function
+        """
+        start = time.time()
+        if not isinstance(grasp, PointGrasp):
+            raise ValueError('Must provide a point grasp object')
+        if not isinstance(obj, GraspableObject3D):
+            raise ValueError('Must provide a 3D graspable object')
+        if not isinstance(params, GraspQualityConfig):
+            raise ValueError('Must provide GraspQualityConfig')
+
+        # read in params
+        method = params.quality_method
+        friction_coef = params.friction_coef
+        num_cone_faces = params.num_cone_faces
+        soft_fingers = params.soft_fingers
+        check_approach = params.check_approach
+        if not hasattr(PointGraspMetrics3D, method):
+            raise ValueError('Illegal point grasp metric %s specified' % (method))
+
+        # get point grasp contacts
+        contacts_start = time.time()
+        if contacts is None:
+            contacts_found, contacts = grasp.close_fingers(obj, check_approach=check_approach, vis=vis)
+            if not contacts_found:
+                logging.debug('Contacts not found')
+                return 0
+
+        if method == 'force_closure':
+            # Use fast force closure test (Nguyen 1988) if possible.
+            if len(contacts) == 2:
+                c1, c2 = contacts
+                return PointGraspMetrics3D.force_closure(c1, c2, friction_coef)
+
+            # Default to QP force closure test.
+            method = 'force_closure_qp'
+
+        # add the forces, torques, etc at each contact point
+        forces_start = time.time()
+        num_contacts = len(contacts)
+        forces = np.zeros([3, 0])
+        torques = np.zeros([3, 0])
+        normals = np.zeros([3, 0])
+        for i in range(num_contacts):
+            contact = contacts[i]
+            if vis:
+                if i == 0:
+                    contact.plot_friction_cone(color='y')
+                else:
+                    contact.plot_friction_cone(color='c')
+
+            # get contact forces
+            force_success, contact_forces, contact_outward_normal = contact.friction_cone(num_cone_faces, friction_coef)
+
+            if not force_success:
+                print('Force computation failed')
+                logging.debug('Force computation failed')
+                if params.all_contacts_required:
+                    return 0
+
+            # get contact torques
+            torque_success, contact_torques = contact.torques(contact_forces)
+            if not torque_success:
+                print('Torque computation failed')
+                logging.debug('Torque computation failed')
+                if params.all_contacts_required:
+                    return 0
+
+            # get the magnitude of the normal force that the contacts could apply
+            n = contact.normal_force_magnitude()
+
+            forces = np.c_[forces, n * contact_forces]
+            torques = np.c_[torques, n * contact_torques]
+            normals = np.c_[normals, n * -contact_outward_normal]  # store inward pointing normals
+
+        if normals.shape[1] == 0:
+            logging.debug('No normals')
+            print('No normals')
+            return 0
+
+        # normalize torques
+        if 'torque_scaling' not in list(params.keys()):
+            torque_scaling = 1.0
+            if method == 'ferrari_canny_L1':
+                mn, mx = obj.mesh.bounding_box()
+                torque_scaling = 1.0 / np.median(mx)
+                print("torque scaling", torque_scaling)
+            params.torque_scaling = torque_scaling
+
+        if vis:
+            ax = plt.gca()
+            ax.set_xlim3d(0, obj.sdf.dims_[0])
+            ax.set_ylim3d(0, obj.sdf.dims_[1])
+            ax.set_zlim3d(0, obj.sdf.dims_[2])
+            plt.show()
+
+        # evaluate the desired quality metric
+        quality_start = time.time()
+        Q_func = getattr(PointGraspMetrics3D, method)
+        quality = Q_func(forces, torques, normals,
+                         soft_fingers=soft_fingers,
+                         params=params)
+
+        end = time.time()
+        logging.debug('Contacts took %.3f sec' % (forces_start - contacts_start))
+        logging.debug('Forces took %.3f sec' % (quality_start - forces_start))
+        logging.debug('Quality eval took %.3f sec' % (end - quality_start))
+        logging.debug('Everything took %.3f sec' % (end - start))
+
+        return quality
+
+    @staticmethod
+    def grasp_matrix(forces, torques, normals, soft_fingers=False,
+                     finger_radius=0.005, params=None):
+        """ Computes the grasp map between contact forces and wrenchs on the object in its reference frame.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        finger_radius : float
+            the radius of the fingers to use
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        G : 6xM :obj:`numpy.ndarray`
+            grasp map
+        """
+        if params is not None and 'finger_radius' in list(params.keys()):
+            finger_radius = params.finger_radius
+        num_forces = forces.shape[1]
+        num_torques = torques.shape[1]
+        if num_forces != num_torques:
+            raise ValueError('Need same number of forces and torques')
+
+        num_cols = num_forces
+        if soft_fingers:
+            num_normals = 2
+            if normals.ndim > 1:
+                num_normals = 2 * normals.shape[1]
+            num_cols = num_cols + num_normals
+
+        G = np.zeros([6, num_cols])
+        for i in range(num_forces):
+            G[:3, i] = forces[:, i]
+            # print("liang", params.torque_scaling)
+            G[3:, i] = params.torque_scaling * torques[:, i]
+
+        if soft_fingers:
+            torsion = np.pi * finger_radius ** 2 * params.friction_coef * normals * params.torque_scaling
+            pos_normal_i = int(-num_normals)
+            neg_normal_i = int(-num_normals + num_normals / 2)
+            G[3:, pos_normal_i:neg_normal_i] = torsion
+            G[3:, neg_normal_i:] = -torsion
+
+        return G
+
+    @staticmethod
+    def force_closure(c1, c2, friction_coef, use_abs_value=True):
+        """" Checks force closure using the antipodality trick.
+
+        Parameters
+        ----------
+        c1 : :obj:`Contact3D`
+            first contact point
+        c2 : :obj:`Contact3D`
+            second contact point
+        friction_coef : float
+            coefficient of friction at the contact point
+        use_abs_value : bool
+            whether or not to use directoinality of the surface normal (useful when mesh is not oriented)
+
+        Returns
+        -------
+        int : 1 if in force closure, 0 otherwise
+        """
+        if c1.point is None or c2.point is None or c1.normal is None or c2.normal is None:
+            return 0
+        p1, p2 = c1.point, c2.point
+        n1, n2 = -c1.normal, -c2.normal  # inward facing normals
+
+        if (p1 == p2).all():  # same point
+            return 0
+
+        for normal, contact, other_contact in [(n1, p1, p2), (n2, p2, p1)]:
+            diff = other_contact - contact
+            normal_proj = normal.dot(diff) / np.linalg.norm(normal)
+            if use_abs_value:
+                normal_proj = abs(normal.dot(diff)) / np.linalg.norm(normal)
+
+            if normal_proj < 0:
+                return 0  # wrong side
+            alpha = np.arccos(normal_proj / np.linalg.norm(diff))
+            if alpha > np.arctan(friction_coef):
+                return 0  # outside of friction cone
+        return 1
+
+    @staticmethod
+    def force_closure_qp(forces, torques, normals, soft_fingers=False,
+                         wrench_norm_thresh=1e-3, wrench_regularizer=1e-10,
+                         params=None):
+        """ Checks force closure by solving a quadratic program (whether or not zero is in the convex hull)
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        int : 1 if in force closure, 0 otherwise
+        """
+        if params is not None:
+            if 'wrench_norm_thresh' in list(params.keys()):
+                wrench_norm_thresh = params.wrench_norm_thresh
+            if 'wrench_regularizer' in list(params.keys()):
+                wrench_regularizer = params.wrench_regularizer
+
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals, soft_fingers, params=params)
+        min_norm, _ = PointGraspMetrics3D.min_norm_vector_in_facet(G, wrench_regularizer=wrench_regularizer)
+        return 1 * (min_norm < wrench_norm_thresh)  # if greater than wrench_norm_thresh, 0 is outside of hull
+
+    @staticmethod
+    def partial_closure(forces, torques, normals, soft_fingers=False,
+                        wrench_norm_thresh=1e-3, wrench_regularizer=1e-10,
+                        params=None):
+        """ Evalutes partial closure: whether or not the forces and torques can resist a specific wrench.
+        Estimates resistance by sollving a quadratic program (whether or not the target wrench is in the convex hull).
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        int : 1 if in partial closure, 0 otherwise
+        """
+        force_limit = None
+        if params is None:
+            return 0
+        force_limit = params.force_limits
+        target_wrench = params.target_wrench
+        if 'wrench_norm_thresh' in list(params.keys()):
+            wrench_norm_thresh = params.wrench_norm_thresh
+        if 'wrench_regularizer' in list(params.keys()):
+            wrench_regularizer = params.wrench_regularizer
+
+        # reorganize the grasp matrix for easier constraint enforcement in optimization
+        num_fingers = normals.shape[1]
+        num_wrenches_per_finger = forces.shape[1] / num_fingers
+        G = np.zeros([6, 0])
+        for i in range(num_fingers):
+            start_i = num_wrenches_per_finger * i
+            end_i = num_wrenches_per_finger * (i + 1)
+            G_i = PointGraspMetrics3D.grasp_matrix(forces[:, start_i:end_i], torques[:, start_i:end_i],
+                                                   normals[:, i:i + 1],
+                                                   soft_fingers, params=params)
+            G = np.c_[G, G_i]
+
+        wrench_resisted, _ = PointGraspMetrics3D.wrench_in_positive_span(G, target_wrench, force_limit, num_fingers,
+                                                                         wrench_norm_thresh=wrench_norm_thresh,
+                                                                         wrench_regularizer=wrench_regularizer)
+        return 1 * wrench_resisted
+
+    @staticmethod
+    def wrench_resistance(forces, torques, normals, soft_fingers=False,
+                          wrench_norm_thresh=1e-3, wrench_regularizer=1e-10,
+                          finger_force_eps=1e-9, params=None):
+        """ Evalutes wrench resistance: the inverse norm of the contact forces required to resist a target wrench
+        Estimates resistance by sollving a quadratic program (min normal contact forces to produce a wrench).
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+        finger_force_eps : float
+            small float to prevent numeric issues in wrench resistance metric
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        float : value of wrench resistance metric
+        """
+        force_limit = None
+        if params is None:
+            return 0
+        force_limit = params.force_limits
+        target_wrench = params.target_wrench
+        if 'wrench_norm_thresh' in list(params.keys()):
+            wrench_norm_thresh = params.wrench_norm_thresh
+        if 'wrench_regularizer' in list(params.keys()):
+            wrench_regularizer = params.wrench_regularizer
+        if 'finger_force_eps' in list(params.keys()):
+            finger_force_eps = params.finger_force_eps
+
+        # reorganize the grasp matrix for easier constraint enforcement in optimization
+        num_fingers = normals.shape[1]
+        num_wrenches_per_finger = forces.shape[1] / num_fingers
+        G = np.zeros([6, 0])
+        for i in range(num_fingers):
+            start_i = num_wrenches_per_finger * i
+            end_i = num_wrenches_per_finger * (i + 1)
+            G_i = PointGraspMetrics3D.grasp_matrix(forces[:, start_i:end_i], torques[:, start_i:end_i],
+                                                   normals[:, i:i + 1],
+                                                   soft_fingers, params=params)
+            G = np.c_[G, G_i]
+
+        # compute metric from finger force norm
+        Q = 0
+        wrench_resisted, finger_force_norm = PointGraspMetrics3D.wrench_in_positive_span(G, target_wrench, force_limit,
+                                                                                         num_fingers,
+                                                                                         wrench_norm_thresh=wrench_norm_thresh,
+                                                                                         wrench_regularizer=wrench_regularizer)
+        if wrench_resisted:
+            Q = 1.0 / (finger_force_norm + finger_force_eps) - 1.0 / (2 * force_limit)
+        return Q
+
+    @staticmethod
+    def min_singular(forces, torques, normals, soft_fingers=False, params=None):
+        """ Min singular value of grasp matrix - measure of wrench that grasp is "weakest" at resisting.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        float : value of smallest singular value
+        """
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals, soft_fingers)
+        _, S, _ = np.linalg.svd(G)
+        min_sig = S[5]
+        return min_sig
+
+    @staticmethod
+    def wrench_volume(forces, torques, normals, soft_fingers=False, params=None):
+        """ Volume of grasp matrix singular values - score of all wrenches that the grasp can resist.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        float : value of wrench volume
+        """
+        k = 1
+        if params is not None and 'k' in list(params.keys()):
+            k = params.k
+
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals, soft_fingers)
+        _, S, _ = np.linalg.svd(G)
+        sig = S
+        return k * np.sqrt(np.prod(sig))
+
+    @staticmethod
+    def grasp_isotropy(forces, torques, normals, soft_fingers=False, params=None):
+        """ Condition number of grasp matrix - ratio of "weakest" wrench that the grasp can exert to the "strongest" one.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+
+        Returns
+        -------
+        float : value of grasp isotropy metric
+        """
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals, soft_fingers)
+        _, S, _ = np.linalg.svd(G)
+        max_sig = S[0]
+        min_sig = S[5]
+        isotropy = min_sig / max_sig
+        if np.isnan(isotropy) or np.isinf(isotropy):
+            return 0
+        return isotropy
+
+    @staticmethod
+    def ferrari_canny_L1(forces, torques, normals, soft_fingers=False, params=None,
+                         wrench_norm_thresh=1e-3,
+                         wrench_regularizer=1e-10):
+        """ Ferrari & Canny's L1 metric. Also known as the epsilon metric.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+
+        Returns
+        -------
+        float : value of metric
+        """
+        if params is not None and 'wrench_norm_thresh' in list(params.keys()):
+            wrench_norm_thresh = params.wrench_norm_thresh
+        if params is not None and 'wrench_regularizer' in list(params.keys()):
+            wrench_regularizer = params.wrench_regularizer
+
+        # create grasp matrix
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals,
+                                             soft_fingers, params=params)
+        s = time.time()
+        # center grasp matrix for better convex hull comp
+        hull = cvh.ConvexHull(G.T)
+        # TODO: suppress ridiculous amount of output for perfectly valid input to qhull
+        e = time.time()
+        logging.debug('CVH took %.3f sec' % (e - s))
+
+        debug = False
+        if debug:
+            fig = plt.figure()
+            torques = G[3:, :].T
+            ax = Axes3D(fig)
+            ax.scatter(torques[:, 0], torques[:, 1], torques[:, 2], c='b', s=50)
+            ax.scatter(0, 0, 0, c='k', s=80)
+            ax.set_xlim3d(-1.5, 1.5)
+            ax.set_ylim3d(-1.5, 1.5)
+            ax.set_zlim3d(-1.5, 1.5)
+            ax.set_xlabel('tx')
+            ax.set_ylabel('ty')
+            ax.set_zlabel('tz')
+            plt.show()
+
+        if len(hull.vertices) == 0:
+            logging.warning('Convex hull could not be computed')
+            return 0.0
+
+        # determine whether or not zero is in the convex hull
+        s = time.time()
+        min_norm_in_hull, v = PointGraspMetrics3D.min_norm_vector_in_facet(G, wrench_regularizer=wrench_regularizer)
+        e = time.time()
+        logging.debug('Min norm took %.3f sec' % (e - s))
+        # print("shunang",min_norm_in_hull)
+
+        # if norm is greater than 0 then forces are outside of hull
+        if min_norm_in_hull > wrench_norm_thresh:
+            logging.debug('Zero not in convex hull')
+            return 0.0
+
+        # if there are fewer nonzeros than D-1 (dim of space minus one)
+        # then zero is on the boundary and therefore we do not have
+        # force closure
+        if np.sum(v > 1e-4) <= G.shape[0] - 1:
+            logging.warning('Zero not in interior of convex hull')
+            return 0.0
+
+        # find minimum norm vector across all facets of convex hull
+        s = time.time()
+        min_dist = sys.float_info.max
+        closest_facet = None
+        # print("shunang",G)
+        for v in hull.vertices:
+            if np.max(np.array(v)) < G.shape[1]:  # because of some occasional odd behavior from pyhull
+                facet = G[:, v]
+                # print("shunang1",facet)
+                dist, _ = PointGraspMetrics3D.min_norm_vector_in_facet(facet, wrench_regularizer=wrench_regularizer)
+                if dist < min_dist:
+                    min_dist = dist
+                    closest_facet = v
+        e = time.time()
+        logging.debug('Min dist took %.3f sec for %d vertices' % (e - s, len(hull.vertices)))
+
+        return min_dist
+
+
+    @staticmethod
+    def ferrari_canny_L1_force_only(forces, torques, normals, soft_fingers=False, params=None,
+                         wrench_norm_thresh=1e-3,
+                         wrench_regularizer=1e-10):
+        """ Ferrari & Canny's L1 metric with force only. Also known as the epsilon metric.
+
+        Parameters
+        ----------
+        forces : 3xN :obj:`numpy.ndarray`
+            set of forces on object in object basis
+        torques : 3xN :obj:`numpy.ndarray`
+            set of torques on object in object basis
+        normals : 3xN :obj:`numpy.ndarray`
+            surface normals at the contact points
+        soft_fingers : bool
+            whether or not to use the soft finger contact model
+        params : :obj:`GraspQualityConfig`
+            set of parameters for grasp matrix and contact model
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+
+        Returns
+        -------
+        float : value of metric
+        """
+        if params is not None and 'wrench_norm_thresh' in list(params.keys()):
+            wrench_norm_thresh = params.wrench_norm_thresh
+        if params is not None and 'wrench_regularizer' in list(params.keys()):
+            wrench_regularizer = params.wrench_regularizer
+
+        # create grasp matrix
+        G = PointGraspMetrics3D.grasp_matrix(forces, torques, normals,
+                                             soft_fingers, params=params)
+        G = G[:3, :]
+        s = time.time()
+        # center grasp matrix for better convex hull comp
+        hull = cvh.ConvexHull(G.T)
+        # TODO: suppress ridiculous amount of output for perfectly valid input to qhull
+        e = time.time()
+        logging.debug('CVH took %.3f sec' % (e - s))
+
+        debug = False
+        if debug:
+            fig = plt.figure()
+            torques = G[3:, :].T
+            ax = Axes3D(fig)
+            ax.scatter(torques[:, 0], torques[:, 1], torques[:, 2], c='b', s=50)
+            ax.scatter(0, 0, 0, c='k', s=80)
+            ax.set_xlim3d(-1.5, 1.5)
+            ax.set_ylim3d(-1.5, 1.5)
+            ax.set_zlim3d(-1.5, 1.5)
+            ax.set_xlabel('tx')
+            ax.set_ylabel('ty')
+            ax.set_zlabel('tz')
+            plt.show()
+
+        if len(hull.vertices) == 0:
+            logging.warning('Convex hull could not be computed')
+            return 0.0
+
+        # determine whether or not zero is in the convex hull
+        s = time.time()
+        min_norm_in_hull, v = PointGraspMetrics3D.min_norm_vector_in_facet(G, wrench_regularizer=wrench_regularizer)
+        e = time.time()
+        logging.debug('Min norm took %.3f sec' % (e - s))
+        # print("shunang",min_norm_in_hull)
+
+        # if norm is greater than 0 then forces are outside of hull
+        if min_norm_in_hull > wrench_norm_thresh:
+            logging.debug('Zero not in convex hull')
+            return 0.0
+
+        # if there are fewer nonzeros than D-1 (dim of space minus one)
+        # then zero is on the boundary and therefore we do not have
+        # force closure
+        if np.sum(v > 1e-4) <= G.shape[0] - 1:
+            logging.warning('Zero not in interior of convex hull')
+            return 0.0
+
+        # find minimum norm vector across all facets of convex hull
+        s = time.time()
+        min_dist = sys.float_info.max
+        closest_facet = None
+        # print("shunang",G)
+        for v in hull.vertices:
+            if np.max(np.array(v)) < G.shape[1]:  # because of some occasional odd behavior from pyhull
+                facet = G[:, v]
+                # print("shunang1",facet)
+                dist, _ = PointGraspMetrics3D.min_norm_vector_in_facet(facet, wrench_regularizer=wrench_regularizer)
+                if dist < min_dist:
+                    min_dist = dist
+                    closest_facet = v
+        e = time.time()
+        logging.debug('Min dist took %.3f sec for %d vertices' % (e - s, len(hull.vertices)))
+
+        return min_dist
+
+    @staticmethod
+    def wrench_in_positive_span(wrench_basis, target_wrench, force_limit, num_fingers=1,
+                                wrench_norm_thresh=1e-4, wrench_regularizer=1e-10):
+        """ Check whether a target can be exerted by positive combinations of wrenches in a given basis with L1 norm fonger force limit limit.
+
+        Parameters
+        ----------
+        wrench_basis : 6xN :obj:`numpy.ndarray`
+            basis for the wrench space
+        target_wrench : 6x1 :obj:`numpy.ndarray`
+            target wrench to resist
+        force_limit : float
+            L1 upper bound on the forces per finger (aka contact point)
+        num_fingers : int
+            number of contacts, used to enforce L1 finger constraint
+        wrench_norm_thresh : float
+            threshold to use to determine equivalence of target wrenches
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+
+        Returns
+        -------
+        int
+            whether or not wrench can be resisted
+        float
+            minimum norm of the finger forces required to resist the wrench
+        """
+        num_wrenches = wrench_basis.shape[1]
+
+        # quadratic and linear costs
+        P = wrench_basis.T.dot(wrench_basis) + wrench_regularizer * np.eye(num_wrenches)
+        q = -wrench_basis.T.dot(target_wrench)
+
+        # inequalities
+        lam_geq_zero = -1 * np.eye(num_wrenches)
+
+        num_wrenches_per_finger = num_wrenches / num_fingers
+        force_constraint = np.zeros([num_fingers, num_wrenches])
+        for i in range(num_fingers):
+            start_i = num_wrenches_per_finger * i
+            end_i = num_wrenches_per_finger * (i + 1)
+            force_constraint[i, start_i:end_i] = np.ones(num_wrenches_per_finger)
+
+        G = np.r_[lam_geq_zero, force_constraint]
+        h = np.zeros(num_wrenches + num_fingers)
+        for i in range(num_fingers):
+            h[num_wrenches + i] = force_limit
+
+        # convert to cvx and solve
+        P = cvx.matrix(P)
+        q = cvx.matrix(q)
+        G = cvx.matrix(G)
+        h = cvx.matrix(h)
+        sol = cvx.solvers.qp(P, q, G, h)
+        v = np.array(sol['x'])
+
+        min_dist = np.linalg.norm(wrench_basis.dot(v).ravel() - target_wrench) ** 2
+
+        # add back in the target wrench
+        return min_dist < wrench_norm_thresh, np.linalg.norm(v)
+
+    @staticmethod
+    def min_norm_vector_in_facet(facet, wrench_regularizer=1e-10):
+        """ Finds the minimum norm point in the convex hull of a given facet (aka simplex) by solving a QP.
+
+        Parameters
+        ----------
+        facet : 6xN :obj:`numpy.ndarray`
+            vectors forming the facet
+        wrench_regularizer : float
+            small float to make quadratic program positive semidefinite
+
+        Returns
+        -------
+        float
+            minimum norm of any point in the convex hull of the facet
+        Nx1 :obj:`numpy.ndarray`
+            vector of coefficients that achieves the minimum
+        """
+        dim = facet.shape[1]  # num vertices in facet
+
+        # create alpha weights for vertices of facet
+        G = facet.T.dot(facet)
+        grasp_matrix = G + wrench_regularizer * np.eye(G.shape[0])
+
+        # Solve QP to minimize .5 x'Px + q'x subject to Gx <= h, Ax = b
+        P = cvx.matrix(2 * grasp_matrix)  # quadratic cost for Euclidean dist
+        q = cvx.matrix(np.zeros((dim, 1)))
+        G = cvx.matrix(-np.eye(dim))  # greater than zero constraint
+        h = cvx.matrix(np.zeros((dim, 1)))
+        A = cvx.matrix(np.ones((1, dim)))  # sum constraint to enforce convex
+        b = cvx.matrix(np.ones(1))  # combinations of vertices
+
+        sol = cvx.solvers.qp(P, q, G, h, A, b)
+        v = np.array(sol['x'])
+        min_norm = np.sqrt(sol['primal objective'])
+
+        return abs(min_norm), v

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/eval_utils.py

@@ -0,0 +1,389 @@
+__author__ = 'cxwang, mhgou'
+__version__ = '1.0'
+
+import os
+import time
+import numpy as np
+import open3d as o3d
+from transforms3d.euler import euler2mat, quat2mat
+
+from .rotation import batch_viewpoint_params_to_matrix, matrix_to_dexnet_params
+
+from .dexnet.grasping.quality import PointGraspMetrics3D
+from .dexnet.grasping.grasp import ParallelJawPtGrasp3D 
+from .dexnet.grasping.graspable_object import GraspableObject3D
+from .dexnet.grasping.grasp_quality_config import GraspQualityConfigFactory
+from .dexnet.grasping.contacts import Contact3D
+from .dexnet.grasping.meshpy.obj_file import ObjFile
+from .dexnet.grasping.meshpy.sdf_file import SdfFile
+
+def get_scene_name(num):
+    '''
+    **Input:**
+    - num: int of the scene number.
+    
+    **Output:**
+    - string of the scene name.
+    '''
+    return ('scene_%04d' % (num,))
+
+def create_table_points(lx, ly, lz, dx=0, dy=0, dz=0, grid_size=0.01):
+    '''
+    **Input:**
+    - lx:
+    - ly:
+    - lz:
+    **Output:**
+    - numpy array of the points with shape (-1, 3).
+    '''
+    xmap = np.linspace(0, lx, int(lx/grid_size))
+    ymap = np.linspace(0, ly, int(ly/grid_size))
+    zmap = np.linspace(0, lz, int(lz/grid_size))
+    xmap, ymap, zmap = np.meshgrid(xmap, ymap, zmap, indexing='xy')
+    xmap += dx
+    ymap += dy
+    zmap += dz
+    points = np.stack([xmap, ymap, zmap], axis=-1)
+    points = points.reshape([-1, 3])
+    return points
+
+def parse_posevector(posevector):
+    '''
+    **Input:**
+    - posevector: list of pose
+    **Output:**
+    - obj_idx: int of the index of object.
+    - mat: numpy array of shape (4, 4) of the 6D pose of object.
+    '''
+    mat = np.zeros([4,4],dtype=np.float32)
+    alpha, beta, gamma = posevector[4:7]
+    alpha = alpha / 180.0 * np.pi
+    beta = beta / 180.0 * np.pi
+    gamma = gamma / 180.0 * np.pi
+    mat[:3,:3] = euler2mat(alpha, beta, gamma)
+    mat[:3,3] = posevector[1:4]
+    mat[3,3] = 1
+    obj_idx = int(posevector[0])
+    return obj_idx, mat
+
+def load_dexnet_model(data_path):
+    '''
+    **Input:**
+        
+    - data_path: path to load .obj & .sdf files
+    
+    **Output:**
+    - obj: dexnet model
+    '''
+    of = ObjFile('{}.obj'.format(data_path))
+    sf = SdfFile('{}.sdf'.format(data_path))
+    mesh = of.read()
+    sdf = sf.read()
+    obj = GraspableObject3D(sdf, mesh)
+    return obj
+
+def transform_points(points, trans):
+    '''
+    **Input:**
+    
+    - points: (N, 3)
+    
+    - trans: (4, 4)
+    
+    **Output:**
+    - points_trans: (N, 3)
+    '''
+    ones = np.ones([points.shape[0],1], dtype=points.dtype)
+    points_ = np.concatenate([points, ones], axis=-1)
+    points_ = np.matmul(trans, points_.T).T
+    points_trans = points_[:,:3]
+    return points_trans
+
+def compute_point_distance(A, B):
+    '''
+    **Input:**
+    - A: (N, 3)
+    
+    - B: (M, 3)
+    
+    **Output:**
+    - dists: (N, M)
+    '''
+    A = A[:, np.newaxis, :]
+    B = B[np.newaxis, :, :]
+    dists = np.linalg.norm(A-B, axis=-1)
+    return dists
+
+def compute_closest_points(A, B):
+    '''
+    **Input:**
+    
+    - A: (N, 3)
+        
+    - B: (M, 3)
+    
+    **Output:**
+    
+    - indices: (N,) closest point index in B for each point in A
+    '''
+    dists = compute_point_distance(A, B)
+    indices = np.argmin(dists, axis=-1)
+    return indices
+
+def voxel_sample_points(points, voxel_size=0.008):
+    '''
+    **Input:**
+    
+    - points: (N, 3)
+    
+    **Output:**
+    
+    - points: (n, 3)
+    '''
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(points)
+    cloud = cloud.voxel_down_sample(voxel_size)
+    points = np.array(cloud.points)
+    return points
+
+def topk_grasps(grasps, k=10):
+    '''
+    **Input:**
+    
+    - grasps: (N, 17)
+    
+    - k: int
+    
+    **Output:**
+    
+    - topk_grasps: (k, 17)
+    '''
+    assert(k > 0)
+    grasp_confidence = grasps[:, 0]
+    indices = np.argsort(-grasp_confidence)
+    topk_indices = indices[:min(k, len(grasps))]
+    topk_grasps = grasps[topk_indices]
+    return topk_grasps
+
+def get_grasp_score(grasp, obj, fc_list, force_closure_quality_config):
+    tmp, is_force_closure = False, False
+    quality = -1
+    for ind_, value_fc in enumerate(fc_list):
+        value_fc = round(value_fc, 2)
+        tmp = is_force_closure
+        is_force_closure = PointGraspMetrics3D.grasp_quality(grasp, obj, force_closure_quality_config[value_fc])
+        if tmp and not is_force_closure:
+            quality = round(fc_list[ind_ - 1], 2)
+            break
+        elif is_force_closure and value_fc == fc_list[-1]:
+            quality = value_fc
+            break
+        elif value_fc == fc_list[0] and not is_force_closure:
+            break
+    return quality
+
+def collision_detection(grasp_list, model_list, dexnet_models, poses, scene_points, outlier=0.05, empty_thresh=10, return_dexgrasps=False):
+    '''
+    **Input:**
+    
+    - grasp_list: [(k1, 17), (k2, 17), ..., (kn, 17)] in camera coordinate
+    
+    - model_list: [(N1, 3), (N2, 3), ..., (Nn, 3)] in camera coordinate
+    
+    - dexnet_models: [GraspableObject3D,] in object coordinate
+    
+    - poses: [(4, 4),] from model coordinate to camera coordinate
+    
+    - scene_points: (Ns, 3) in camera coordinate
+    
+    - outlier: float, used to compute workspace mask
+    
+    - empty_thresh: int, 'num_inner_points < empty_thresh' means empty grasp
+
+    - return_dexgrasps: bool, return grasps in dex-net format while True
+    
+    **Output:**
+    
+    - collsion_mask_list: [(k1,), (k2,), ..., (kn,)]
+
+    - empty_mask_list: [(k1,), (k2,), ..., (kn,)]
+    
+    - dexgrasp_list: [[ParallelJawPtGrasp3D,],] in object coordinate
+    '''
+    height = 0.02
+    depth_base = 0.02
+    finger_width = 0.01
+    collision_mask_list = list()
+    num_models = len(model_list)
+    empty_mask_list = list()
+    dexgrasp_list = list()
+
+    for i in range(num_models):
+        if len(grasp_list[i]) == 0:
+            collision_mask_list.append(list())
+            empty_mask_list.append(list())
+            if return_dexgrasps:
+                dexgrasp_list.append(list())
+            continue
+
+        ## parse grasp parameters
+        model = model_list[i]
+        obj_pose = poses[i]
+        dexnet_model = dexnet_models[i]
+        grasps = grasp_list[i]
+        grasp_points = grasps[:, 13:16]
+        grasp_poses = grasps[:, 4:13].reshape([-1,3,3])
+        grasp_depths = grasps[:, 3]
+        grasp_widths = grasps[:, 1]
+        
+        ## crop scene, remove outlier
+        xmin, xmax = model[:,0].min(), model[:,0].max()
+        ymin, ymax = model[:,1].min(), model[:,1].max()
+        zmin, zmax = model[:,2].min(), model[:,2].max()
+        xlim = ((scene_points[:,0] > xmin-outlier) & (scene_points[:,0] < xmax+outlier))
+        ylim = ((scene_points[:,1] > ymin-outlier) & (scene_points[:,1] < ymax+outlier))
+        zlim = ((scene_points[:,2] > zmin-outlier) & (scene_points[:,2] < zmax+outlier))
+        workspace = scene_points[xlim & ylim & zlim]
+        
+        # transform scene to gripper frame
+        target = (workspace[np.newaxis,:,:] - grasp_points[:,np.newaxis,:])
+        target = np.matmul(target, grasp_poses)
+        
+        # compute collision mask
+        mask1 = ((target[:,:,2]>-height/2) & (target[:,:,2]<height/2))
+        mask2 = ((target[:,:,0]>-depth_base) & (target[:,:,0]<grasp_depths[:,np.newaxis]))
+        mask3 = (target[:,:,1]>-(grasp_widths[:,np.newaxis]/2+finger_width))
+        mask4 = (target[:,:,1]<-grasp_widths[:,np.newaxis]/2)
+        mask5 = (target[:,:,1]<(grasp_widths[:,np.newaxis]/2+finger_width))
+        mask6 = (target[:,:,1]>grasp_widths[:,np.newaxis]/2)
+        mask7 = ((target[:,:,0]>-(depth_base+finger_width)) & (target[:,:,0]<-depth_base))
+        
+        left_mask = (mask1 & mask2 & mask3 & mask4)
+        right_mask = (mask1 & mask2 & mask5 & mask6)
+        bottom_mask = (mask1 & mask3 & mask5 & mask7)
+        inner_mask = (mask1 & mask2 &(~mask4) & (~mask6))
+        collision_mask = np.any((left_mask | right_mask | bottom_mask), axis=-1)
+        empty_mask = (np.sum(inner_mask, axis=-1) < empty_thresh)
+        collision_mask = (collision_mask | empty_mask)
+        collision_mask_list.append(collision_mask)
+        empty_mask_list.append(empty_mask)
+
+        ## generate grasps in dex-net format
+        if return_dexgrasps:
+            dexgrasps = list()
+            for grasp_id,_ in enumerate(grasps):
+                grasp_point = grasp_points[grasp_id]
+                R = grasp_poses[grasp_id]
+                width = grasp_widths[grasp_id]
+                depth = grasp_depths[grasp_id]
+                points_in_gripper = target[grasp_id][inner_mask[grasp_id]]
+                if empty_mask[grasp_id]:
+                    dexgrasps.append(None)
+                    continue
+                center = np.array([depth, 0, 0]).reshape([3, 1]) # gripper coordinate
+                center = np.dot(grasp_poses[grasp_id], center).reshape([3])
+                center = (center + grasp_point).reshape([1,3]) # camera coordinate
+                center = transform_points(center, np.linalg.inv(obj_pose)).reshape([3]) # object coordinate
+                R = np.dot(obj_pose[:3,:3].T, R)
+                binormal, approach_angle = matrix_to_dexnet_params(R)
+                grasp = ParallelJawPtGrasp3D(ParallelJawPtGrasp3D.configuration_from_params(
+                                            center, binormal, width, approach_angle), depth)
+                dexgrasps.append(grasp)
+            dexgrasp_list.append(dexgrasps)
+    
+    if return_dexgrasps:
+        return collision_mask_list, empty_mask_list, dexgrasp_list
+    else:
+        return collision_mask_list, empty_mask_list
+
+def eval_grasp(grasp_group, models, dexnet_models, poses, config, table=None, voxel_size=0.008, TOP_K = 50):
+    '''
+    **Input:**
+    
+    - grasp_group: GraspGroup instance for evaluation.
+
+    - models: in model coordinate
+
+    - dexnet_models: models in dexnet format 
+    
+    - poses: from model to camera coordinate
+
+    - config: dexnet config.
+    
+    - table: in camera coordinate
+
+    - voxel_size: float of the voxel size.
+
+    - TOP_K: int of the number of top grasps to evaluate.
+    '''
+    num_models = len(models)
+    ## grasp nms
+    grasp_group = grasp_group.nms(0.03, 30.0/180*np.pi)
+
+    ## assign grasps to object
+    # merge and sample scene
+    model_trans_list = list()
+    seg_mask = list()
+    for i,model in enumerate(models):
+        model_trans = transform_points(model, poses[i])
+        seg = i * np.ones(model_trans.shape[0], dtype=np.int32)
+        model_trans_list.append(model_trans)
+        seg_mask.append(seg)
+    seg_mask = np.concatenate(seg_mask, axis=0)
+    scene = np.concatenate(model_trans_list, axis=0)
+
+    # assign grasps
+    indices = compute_closest_points(grasp_group.translations, scene)
+    model_to_grasp = seg_mask[indices]
+    pre_grasp_list = list()
+    for i in range(num_models):
+        grasp_i = grasp_group[model_to_grasp==i]
+        grasp_i.sort_by_score()
+        pre_grasp_list.append(grasp_i[:10].grasp_group_array)
+    all_grasp_list = np.vstack(pre_grasp_list)
+    remain_mask = np.argsort(all_grasp_list[:,0])[::-1]
+    min_score = all_grasp_list[remain_mask[min(49,len(remain_mask) - 1)],0]
+
+    grasp_list = []
+    for i in range(num_models):
+        remain_mask_i = pre_grasp_list[i][:,0] >= min_score
+        grasp_list.append(pre_grasp_list[i][remain_mask_i])
+    # grasp_list = pre_grasp_list
+
+    ## collision detection
+    if table is not None:
+        scene = np.concatenate([scene, table])
+
+    collision_mask_list, empty_list, dexgrasp_list = collision_detection(
+        grasp_list, model_trans_list, dexnet_models, poses, scene, outlier=0.05, return_dexgrasps=True)
+    
+    ## evaluate grasps
+    # score configurations
+    force_closure_quality_config = dict()
+    fc_list = np.array([1.2, 1.0, 0.8, 0.6, 0.4, 0.2])
+    for value_fc in fc_list:
+        value_fc = round(value_fc, 2)
+        config['metrics']['force_closure']['friction_coef'] = value_fc
+        force_closure_quality_config[value_fc] = GraspQualityConfigFactory.create_config(config['metrics']['force_closure'])
+    # get grasp scores
+    score_list = list()
+    
+    for i in range(num_models):
+        dexnet_model = dexnet_models[i]
+        collision_mask = collision_mask_list[i]
+        dexgrasps = dexgrasp_list[i]
+        scores = list()
+        num_grasps = len(dexgrasps)
+        for grasp_id in range(num_grasps):
+            if collision_mask[grasp_id]:
+                scores.append(-1.)
+                continue
+            if dexgrasps[grasp_id] is None:
+                scores.append(-1.)
+                continue
+            grasp = dexgrasps[grasp_id]
+            score = get_grasp_score(grasp, dexnet_model, fc_list, force_closure_quality_config)
+            scores.append(score)
+        score_list.append(np.array(scores))
+
+    return grasp_list, score_list, collision_mask_list

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/pose.py

@@ -0,0 +1,94 @@
+__author__ = 'Minghao Gou'
+__version__ = '1.0'
+"""
+define the pose class and functions associated with this class.
+"""
+
+import numpy as np
+from . import trans3d
+from transforms3d.euler import euler2quat
+
+class Pose:
+    def __init__(self,id,x,y,z,alpha,beta,gamma):
+        self.id = id
+        self.x = x
+        self.y = y
+        self.z = z
+        # alpha, bata, gamma is in degree
+        self.alpha = alpha
+        self.beta = beta
+        self.gamma = gamma
+        self.quat = self.get_quat()
+        self.mat_4x4 = self.get_mat_4x4()
+        self.translation = self.get_translation()
+
+    def __repr__(self):
+        return '\nPose id=%d,x=%f,y=%f,z=%f,alpha=%f,beta=%f,gamma=%f' %(self.id,self.x,self.y,self.z,self.alpha,self.beta,self.gamma)+'\n'+'translation:'+self.translation.__repr__() + '\nquat:'+self.quat.__repr__()+'\nmat_4x4:'+self.mat_4x4.__repr__()
+
+    def get_id(self):
+        """
+        **Output:**
+        
+        - return the id of this object
+        """
+        return self.id
+
+    def get_translation(self):
+        """ 
+        **Output:**
+
+        - Convert self.x, self.y, self.z into self.translation
+        """
+        return np.array([self.x,self.y,self.z])
+
+    def get_quat(self):
+        """
+        **Output:**
+        
+        - Convert self.alpha, self.beta, self.gamma into self.quat
+        """
+        euler = np.array([self.alpha, self.beta, self.gamma]) / 180.0 * np.pi
+        quat = euler2quat(euler[0],euler[1],euler[2])
+        return quat
+
+    def get_mat_4x4(self):
+        """
+        **Output:**
+        
+        - Convert self.x, self.y, self.z, self.alpha, self.beta and self.gamma into mat_4x4 pose
+        """
+        mat_4x4 = trans3d.get_mat(self.x,self.y,self.z,self.alpha,self.beta,self.gamma)
+        return mat_4x4
+
+def pose_from_pose_vector(pose_vector):
+    """
+    **Input:**
+    
+    - pose_vector: A list in the format of [id,x,y,z,alpha,beta,gamma]
+    
+    **Output:**
+    
+    - A pose class instance
+    """
+    return Pose(id = pose_vector[0],
+    x = pose_vector[1],
+    y = pose_vector[2],
+    z = pose_vector[3],
+    alpha = pose_vector[4],
+    beta = pose_vector[5],
+    gamma = pose_vector[6])
+
+def pose_list_from_pose_vector_list(pose_vector_list):
+    """
+    **Input:**
+
+    - Pose vector list defined in xmlhandler.py
+
+    **Output:**
+    
+    - list of poses.
+    """
+    pose_list = []
+    for pose_vector in pose_vector_list:
+        pose_list.append(pose_from_pose_vector(pose_vector))
+    return pose_list

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/rotation.py

@@ -0,0 +1,142 @@
+""" Author: chenxi-wang
+    Transformation matrices from/to viewpoints and dexnet gripper params.
+"""
+
+import numpy as np
+from math import pi
+
+def rotation_matrix(alpha, beta, gamma):
+    '''
+    **Input:**
+
+    - alpha: float of alpha angle.
+
+    - beta: float of beta angle.
+
+    - gamma: float of the gamma angle.
+
+    **Output:**
+
+    - numpy array of shape (3, 3) of rotation matrix.
+    '''
+    Rx = np.array([[1, 0, 0],
+                   [0, np.cos(alpha), -np.sin(alpha)],
+                   [0, np.sin(alpha), np.cos(alpha)]])
+    Ry = np.array([[np.cos(beta), 0, np.sin(beta)],
+                   [0, 1, 0],
+                   [-np.sin(beta), 0, np.cos(beta)]])
+    Rz = np.array([[np.cos(gamma), -np.sin(gamma), 0],
+                   [np.sin(gamma), np.cos(gamma), 0],
+                   [0, 0, 1]])
+    R = Rz.dot(Ry).dot(Rx)
+    return R
+
+def matrix_to_dexnet_params(matrix):
+    '''
+    **Input:**
+    
+    - numpy array of shape (3, 3) of the rotation matrix.
+
+    **Output:**
+
+    - binormal: numpy array of shape (3,).
+    
+    - angle: float of the angle.
+    '''
+    approach = matrix[:, 0]
+    binormal = matrix[:, 1]
+    axis_y = binormal
+    axis_x = np.array([axis_y[1], -axis_y[0], 0])
+    if np.linalg.norm(axis_x) == 0:
+        axis_x = np.array([1, 0, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    approach = R.T.dot(approach)
+    cos_t, sin_t = approach[0], -approach[2]
+    angle = np.arccos(max(min(cos_t,1),-1))
+    if sin_t < 0:
+        angle = pi * 2 - angle
+    return binormal, angle
+
+def viewpoint_params_to_matrix(towards, angle):
+    '''
+    **Input:**
+
+    - towards: numpy array towards vector with shape (3,).
+
+    - angle: float of in-plane rotation.
+
+    **Output:**
+
+    - numpy array of the rotation matrix with shape (3, 3).
+    '''
+    axis_x = towards
+    axis_y = np.array([-axis_x[1], axis_x[0], 0])
+    if np.linalg.norm(axis_y) == 0:
+        axis_y = np.array([0, 1, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R1 = np.array([[1, 0, 0],
+                   [0, np.cos(angle), -np.sin(angle)],
+                   [0, np.sin(angle), np.cos(angle)]])
+    R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    matrix = R2.dot(R1)
+    return matrix.astype(np.float32)
+
+def batch_viewpoint_params_to_matrix(batch_towards, batch_angle):
+    '''
+    **Input:**
+
+    - towards: numpy array towards vectors with shape (n, 3).
+
+    - angle: numpy array of in-plane rotations (n, ).
+
+    **Output:**
+
+    - numpy array of the rotation matrix with shape (n, 3, 3).
+    '''
+    axis_x = batch_towards
+    ones = np.ones(axis_x.shape[0], dtype=axis_x.dtype)
+    zeros = np.zeros(axis_x.shape[0], dtype=axis_x.dtype)
+    axis_y = np.stack([-axis_x[:,1], axis_x[:,0], zeros], axis=-1)
+    mask_y = (np.linalg.norm(axis_y, axis=-1) == 0)
+    axis_y[mask_y] = np.array([0, 1, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x, axis=-1, keepdims=True)
+    axis_y = axis_y / np.linalg.norm(axis_y, axis=-1, keepdims=True)
+    axis_z = np.cross(axis_x, axis_y)
+    sin = np.sin(batch_angle)
+    cos = np.cos(batch_angle)
+    R1 = np.stack([ones, zeros, zeros, zeros, cos, -sin, zeros, sin, cos], axis=-1)
+    R1 = R1.reshape([-1,3,3])
+    R2 = np.stack([axis_x, axis_y, axis_z], axis=-1)
+    matrix = np.matmul(R2, R1)
+    return matrix.astype(np.float32)
+
+def dexnet_params_to_matrix(binormal, angle):
+    '''
+    **Input:**
+
+    - binormal: numpy array of shape (3,).
+    
+    - angle: float of the angle.
+
+    **Output:**
+
+    - numpy array of shape (3, 3) of the rotation matrix.
+    '''
+    axis_y = binormal
+    axis_x = np.array([axis_y[1], -axis_y[0], 0])
+    if np.linalg.norm(axis_x) == 0:
+        axis_x = np.array([1, 0, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R1 = np.array([[np.cos(angle), 0, np.sin(angle)],
+                  [0, 1, 0],
+                  [-np.sin(angle), 0, np.cos(angle)]])
+    R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    matrix = R2.dot(R1)
+    return matrix

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/trans3d.py

@@ -0,0 +1,62 @@
+from transforms3d.quaternions import mat2quat, quat2mat
+from transforms3d.euler import quat2euler, euler2quat
+import numpy as np
+
+def get_pose(pose):
+	pos, quat = pose_4x4_to_pos_quat(pose)
+	euler = np.array([quat2euler(quat)[0], quat2euler(quat)[1],quat2euler(quat)[2]])
+	euler = euler * 180.0 / np.pi
+	alpha, beta, gamma = euler[0], euler[1], euler[2]
+	x, y, z = pos[0], pos[1], pos[2]
+	return x,y,z, alpha, beta, gamma
+
+def get_mat(x,y,z, alpha, beta, gamma):
+	"""
+	Calls get_mat() to get the 4x4 matrix
+	"""
+	try:
+		euler = np.array([alpha, beta, gamma]) / 180.0 * np.pi
+		quat = np.array(euler2quat(euler[0],euler[1],euler[2]))
+		pose = pos_quat_to_pose_4x4(np.array([x,y,z]), quat)
+		return pose
+	except Exception as e:
+		print(str(e))
+		pass         
+
+def pos_quat_to_pose_4x4(pos, quat):
+	"""pose = pos_quat_to_pose_4x4(pos, quat)
+	Convert pos and quat into pose, 4x4 format
+
+	Args:
+	    pos: length-3 position
+	    quat: length-4 quaternion
+
+	Returns:
+	    pose: numpy array, 4x4
+	"""
+	pose = np.zeros([4, 4])
+	mat = quat2mat(quat)
+	pose[0:3, 0:3] = mat[:, :]
+	pose[0:3, -1] = pos[:]
+	pose[-1, -1] = 1
+	return pose
+
+
+def pose_4x4_to_pos_quat(pose):
+	"""
+	Convert pose, 4x4 format into pos and quat
+
+	Args:
+	    pose: numpy array, 4x4
+	Returns:
+		pos: length-3 position
+	    quat: length-4 quaternion
+
+	"""
+	mat = pose[:3, :3]
+	quat = mat2quat(mat)
+	pos = np.zeros([3])
+	pos[0] = pose[0, 3]
+	pos[1] = pose[1, 3]
+	pos[2] = pose[2, 3]
+	return pos, quat

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/utils.py

@@ -0,0 +1,807 @@
+import os
+import open3d as o3d
+import numpy as np
+from PIL import Image
+from transforms3d.euler import euler2mat
+
+from .rotation import batch_viewpoint_params_to_matrix
+from .xmlhandler import xmlReader
+
+class CameraInfo():
+    ''' Author: chenxi-wang
+    Camera intrinsics for point cloud generation.
+    '''
+    def __init__(self, width, height, fx, fy, cx, cy, scale):
+        self.width = width
+        self.height = height
+        self.fx = fx
+        self.fy = fy
+        self.cx = cx
+        self.cy = cy
+        self.scale = scale
+
+def get_camera_intrinsic(camera):
+    '''
+    **Input:**
+
+    - camera: string of type of camera, "realsense" or "kinect".
+
+    **Output:**
+
+    - numpy array of shape (3, 3) of the camera intrinsic matrix.
+    '''
+    param = o3d.camera.PinholeCameraParameters()
+    if camera == 'kinect':
+        param.intrinsic.set_intrinsics(1280,720,631.55,631.21,638.43,366.50)
+    elif camera == 'realsense':
+        param.intrinsic.set_intrinsics(1280,720,927.17,927.37,651.32,349.62)
+    intrinsic = param.intrinsic.intrinsic_matrix
+    return intrinsic
+
+def create_point_cloud_from_depth_image(depth, camera, organized=True):
+    assert(depth.shape[0] == camera.height and depth.shape[1] == camera.width)
+    xmap = np.arange(camera.width)
+    ymap = np.arange(camera.height)
+    xmap, ymap = np.meshgrid(xmap, ymap)
+    points_z = depth / camera.scale
+    points_x = (xmap - camera.cx) * points_z / camera.fx
+    points_y = (ymap - camera.cy) * points_z / camera.fy
+    cloud = np.stack([points_x, points_y, points_z], axis=-1)
+    if not organized:
+        cloud = cloud.reshape([-1, 3])
+    return cloud
+
+def generate_views(N, phi=(np.sqrt(5)-1)/2, center=np.zeros(3, dtype=np.float32), R=1):
+    ''' Author: chenxi-wang
+    View sampling on a sphere using Febonacci lattices.
+
+    **Input:**
+
+    - N: int, number of viewpoints.
+
+    - phi: float, constant angle to sample views, usually 0.618.
+
+    - center: numpy array of (3,), sphere center.
+
+    - R: float, sphere radius.
+
+    **Output:**
+
+    - numpy array of (N, 3), coordinates of viewpoints.
+    '''
+    idxs = np.arange(N, dtype=np.float32)
+    Z = (2 * idxs + 1) / N - 1
+    X = np.sqrt(1 - Z**2) * np.cos(2 * idxs * np.pi * phi)
+    Y = np.sqrt(1 - Z**2) * np.sin(2 * idxs * np.pi * phi)
+    views = np.stack([X,Y,Z], axis=1)
+    views = R * np.array(views) + center
+    return views
+
+def generate_scene_model(dataset_root, scene_name, anno_idx, return_poses=False, align=False, camera='realsense'):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - dataset_root: str, graspnet dataset root
+
+    - scene_name: str, name of scene folder, e.g. scene_0000
+
+    - anno_idx: int, frame index from 0-255
+
+    - return_poses: bool, return object ids and 6D poses if set to True
+
+    - align: bool, transform to table coordinates if set to True
+
+    - camera: str, camera name (realsense or kinect)
+
+    **Output:**
+
+    - list of open3d.geometry.PointCloud.
+    '''
+    if align:
+        camera_poses = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'camera_poses.npy'))
+        camera_pose = camera_poses[anno_idx]
+        align_mat = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'cam0_wrt_table.npy'))
+        camera_pose = np.matmul(align_mat,camera_pose)
+    print('Scene {}, {}'.format(scene_name, camera))
+    scene_reader = xmlReader(os.path.join(dataset_root, 'scenes', scene_name, camera, 'annotations', '%04d.xml'%anno_idx))
+    posevectors = scene_reader.getposevectorlist()
+    obj_list = []
+    mat_list = []
+    model_list = []
+    pose_list = []
+    for posevector in posevectors:
+        obj_idx, pose = parse_posevector(posevector)
+        obj_list.append(obj_idx)
+        mat_list.append(pose)
+
+    for obj_idx, pose in zip(obj_list, mat_list):
+        plyfile = os.path.join(dataset_root, 'models', '%03d'%obj_idx, 'nontextured.ply')
+        model = o3d.io.read_point_cloud(plyfile)
+        points = np.array(model.points)
+        if align:
+            pose = np.dot(camera_pose, pose)
+        points = transform_points(points, pose)
+        model.points = o3d.utility.Vector3dVector(points)
+        model_list.append(model)
+        pose_list.append(pose)
+
+    if return_poses:
+        return model_list, obj_list, pose_list
+    else:
+        return model_list
+
+def generate_scene_pointcloud(dataset_root, scene_name, anno_idx, align=False, camera='kinect'):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - dataset_root: str, graspnet dataset root
+
+    - scene_name: str, name of scene folder, e.g. scene_0000
+
+    - anno_idx: int, frame index from 0-255
+
+    - align: bool, transform to table coordinates if set to True
+
+    - camera: str, camera name (realsense or kinect)
+
+    **Output:**
+
+    - open3d.geometry.PointCloud.
+    '''
+    colors = np.array(Image.open(os.path.join(dataset_root, 'scenes', scene_name, camera, 'rgb', '%04d.png'%anno_idx)), dtype=np.float32) / 255.0
+    depths = np.array(Image.open(os.path.join(dataset_root, 'scenes', scene_name, camera, 'depth', '%04d.png'%anno_idx)))
+    intrinsics = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'camK.npy'))
+    fx, fy = intrinsics[0,0], intrinsics[1,1]
+    cx, cy = intrinsics[0,2], intrinsics[1,2]
+    s = 1000.0
+    
+    if align:
+        camera_poses = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'camera_poses.npy'))
+        camera_pose = camera_poses[anno_idx]
+        align_mat = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'cam0_wrt_table.npy'))
+        camera_pose = align_mat.dot(camera_pose)
+
+    xmap, ymap = np.arange(colors.shape[1]), np.arange(colors.shape[0])
+    xmap, ymap = np.meshgrid(xmap, ymap)
+
+    points_z = depths / s
+    points_x = (xmap - cx) / fx * points_z
+    points_y = (ymap - cy) / fy * points_z
+
+    mask = (points_z > 0)
+    points = np.stack([points_x, points_y, points_z], axis=-1)
+    points = points[mask]
+    colors = colors[mask]
+    if align:
+        points = transform_points(points, camera_pose)
+
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(points)
+    cloud.colors = o3d.utility.Vector3dVector(colors)
+
+    return cloud
+
+def rotation_matrix(rx, ry, rz):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - rx/ry/rz: float, rotation angle along x/y/z-axis
+
+    **Output:**
+
+    - numpy array of (3, 3), rotation matrix.
+    '''
+    Rx = np.array([[1,          0,           0],
+                   [0, np.cos(rx), -np.sin(rx)],
+                   [0, np.sin(rx),  np.cos(rx)]])
+    Ry = np.array([[ np.cos(ry), 0, np.sin(ry)],
+                   [          0, 1,          0],
+                   [-np.sin(ry), 0, np.cos(ry)]])
+    Rz = np.array([[np.cos(rz), -np.sin(rz), 0],
+                   [np.sin(rz),  np.cos(rz), 0],
+                   [         0,           0, 1]])
+    R = Rz.dot(Ry).dot(Rx)
+    return R
+
+def transform_matrix(tx, ty, tz, rx, ry, rz):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - tx/ty/tz: float, translation along x/y/z-axis
+
+    - rx/ry/rz: float, rotation angle along x/y/z-axis
+
+    **Output:**
+
+    - numpy array of (4, 4), transformation matrix.
+    '''
+    trans = np.eye(4)
+    trans[:3,3] = np.array([tx, ty, tz])
+    rot_x = np.array([[1,          0,           0],
+                      [0, np.cos(rx), -np.sin(rx)],
+                      [0, np.sin(rx),  np.cos(rx)]])
+    rot_y = np.array([[ np.cos(ry), 0, np.sin(ry)],
+                      [          0, 1,          0],
+                      [-np.sin(ry), 0, np.cos(ry)]])
+    rot_z = np.array([[np.cos(rz), -np.sin(rz), 0],
+                      [np.sin(rz),  np.cos(rz), 0],
+                      [         0,           0, 1]])
+    trans[:3,:3] = rot_x.dot(rot_y).dot(rot_z)
+    return trans
+
+def matrix_to_dexnet_params(matrix):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+    
+    - numpy array of shape (3, 3) of the rotation matrix.
+
+    **Output:**
+
+    - binormal: numpy array of shape (3,).
+    
+    - angle: float of the angle.
+    '''
+    approach = matrix[:, 0]
+    binormal = matrix[:, 1]
+    axis_y = binormal
+    axis_x = np.array([axis_y[1], -axis_y[0], 0])
+    if np.linalg.norm(axis_x) == 0:
+        axis_x = np.array([1, 0, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    approach = R.T.dot(approach)
+    cos_t, sin_t = approach[0], -approach[2]
+    angle = np.arccos(cos_t)
+    if sin_t < 0:
+        angle = np.pi * 2 - angle
+    return binormal, angle
+
+def viewpoint_params_to_matrix(towards, angle):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - towards: numpy array towards vector with shape (3,).
+
+    - angle: float of in-plane rotation.
+
+    **Output:**
+
+    - numpy array of the rotation matrix with shape (3, 3).
+    '''
+    axis_x = towards
+    axis_y = np.array([-axis_x[1], axis_x[0], 0])
+    if np.linalg.norm(axis_y) == 0:
+        axis_y = np.array([0, 1, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R1 = np.array([[1, 0, 0],
+                   [0, np.cos(angle), -np.sin(angle)],
+                   [0, np.sin(angle), np.cos(angle)]])
+    R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    matrix = R2.dot(R1)
+    return matrix
+
+def dexnet_params_to_matrix(binormal, angle):
+    '''
+    Author: chenxi-wang
+
+    **Input:**
+
+    - binormal: numpy array of shape (3,).
+    
+    - angle: float of the angle.
+
+    **Output:**
+
+    - numpy array of shape (3, 3) of the rotation matrix.
+    '''
+    axis_y = binormal
+    axis_x = np.array([axis_y[1], -axis_y[0], 0])
+    if np.linalg.norm(axis_x) == 0:
+        axis_x = np.array([1, 0, 0])
+    axis_x = axis_x / np.linalg.norm(axis_x)
+    axis_y = axis_y / np.linalg.norm(axis_y)
+    axis_z = np.cross(axis_x, axis_y)
+    R1 = np.array([[np.cos(angle), 0, np.sin(angle)],
+                  [0, 1, 0],
+                  [-np.sin(angle), 0, np.cos(angle)]])
+    R2 = np.c_[axis_x, np.c_[axis_y, axis_z]]
+    matrix = R2.dot(R1)
+    return matrix
+
+def transform_points(points, trans):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - points: numpy array of (N,3), point cloud
+    
+    - trans: numpy array of (4,4), transformation matrix
+
+    **Output:**
+
+    - numpy array of (N,3), transformed points.
+    '''
+    ones = np.ones([points.shape[0],1], dtype=points.dtype)
+    points_ = np.concatenate([points, ones], axis=-1)
+    points_ = np.matmul(trans, points_.T).T
+    return points_[:,:3]
+
+def get_model_grasps(datapath):
+    ''' Author: chenxi-wang
+    Load grasp labels from .npz files.
+    '''
+    label = np.load(datapath)
+    points = label['points']
+    offsets = label['offsets']
+    scores = label['scores']
+    collision = label['collision']
+    return points, offsets, scores, collision
+
+def parse_posevector(posevector):
+    ''' Author: chenxi-wang
+    Decode posevector to object id and transformation matrix.
+    '''
+    mat = np.zeros([4,4],dtype=np.float32)
+    alpha, beta, gamma = posevector[4:7]
+    alpha = alpha / 180.0 * np.pi
+    beta = beta / 180.0 * np.pi
+    gamma = gamma / 180.0 * np.pi
+    mat[:3,:3] = euler2mat(alpha, beta, gamma)
+    mat[:3,3] = posevector[1:4]
+    mat[3,3] = 1
+    obj_idx = int(posevector[0])
+    return obj_idx, mat
+
+def create_mesh_box(width, height, depth, dx=0, dy=0, dz=0):
+    ''' Author: chenxi-wang
+    Create box instance with mesh representation.
+    '''
+    box = o3d.geometry.TriangleMesh()
+    vertices = np.array([[0,0,0],
+                         [width,0,0],
+                         [0,0,depth],
+                         [width,0,depth],
+                         [0,height,0],
+                         [width,height,0],
+                         [0,height,depth],
+                         [width,height,depth]])
+    vertices[:,0] += dx
+    vertices[:,1] += dy
+    vertices[:,2] += dz
+    triangles = np.array([[4,7,5],[4,6,7],[0,2,4],[2,6,4],
+                          [0,1,2],[1,3,2],[1,5,7],[1,7,3],
+                          [2,3,7],[2,7,6],[0,4,1],[1,4,5]])
+    box.vertices = o3d.utility.Vector3dVector(vertices)
+    box.triangles = o3d.utility.Vector3iVector(triangles)
+    return box
+
+def create_table_cloud(width, height, depth, dx=0, dy=0, dz=0, grid_size=0.01):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - width/height/depth: float, table width/height/depth along x/z/y-axis in meters
+
+    - dx/dy/dz: float, offset along x/y/z-axis in meters
+
+    - grid_size: float, point distance along x/y/z-axis in meters
+
+    **Output:**
+
+    - open3d.geometry.PointCloud
+    '''
+    xmap = np.linspace(0, width, int(width/grid_size))
+    ymap = np.linspace(0, depth, int(depth/grid_size))
+    zmap = np.linspace(0, height, int(height/grid_size))
+    xmap, ymap, zmap = np.meshgrid(xmap, ymap, zmap, indexing='xy')
+    xmap += dx
+    ymap += dy
+    zmap += dz
+    points = np.stack([xmap, ymap, zmap], axis=-1)
+    points = points.reshape([-1, 3])
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(points)
+    return cloud
+
+def create_axis(length,grid_size = 0.01):
+    num = int(length / grid_size)
+    xmap = np.linspace(0,length,num)
+    ymap = np.linspace(0,2*length,num)
+    zmap = np.linspace(0,3*length,num)
+    x_p = np.vstack([xmap.T,np.zeros((1,num)),np.zeros((1,num))])
+    y_p = np.vstack([np.zeros((1,num)),ymap.T,np.zeros((1,num))])
+    z_p = np.vstack([np.zeros((1,num)),np.zeros((1,num)),zmap.T])
+    p = np.hstack([x_p,y_p,z_p])
+    # print('p',p.shape)
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(p.T)
+    return cloud
+
+def plot_axis(R,center,length,grid_size = 0.01):
+    num = int(length / grid_size)
+    xmap = np.linspace(0,length,num)
+    ymap = np.linspace(0,2*length,num)
+    zmap = np.linspace(0,3*length,num)
+    x_p = np.vstack([xmap.T,np.zeros((1,num)),np.zeros((1,num))])
+    y_p = np.vstack([np.zeros((1,num)),ymap.T,np.zeros((1,num))])
+    z_p = np.vstack([np.zeros((1,num)),np.zeros((1,num)),zmap.T])
+    p = np.hstack([x_p,y_p,z_p])
+    # print('p',p.shape)
+    p = np.dot(R, p).T + center
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(p)
+    return cloud
+
+def plot_gripper_pro_max(center, R, width, depth, score=1, color=None):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - center: numpy array of (3,), target point as gripper center
+
+    - R: numpy array of (3,3), rotation matrix of gripper
+
+    - width: float, gripper width
+
+    - score: float, grasp quality score
+
+    **Output:**
+
+    - open3d.geometry.TriangleMesh
+    '''
+    x, y, z = center
+    height=0.004
+    finger_width = 0.004
+    tail_length = 0.04
+    depth_base = 0.02
+    
+    if color is not None:
+        color_r, color_g, color_b = color
+    else:
+        color_r = score # red for high score
+        color_g = 0
+        color_b = 1 - score # blue for low score
+    
+    left = create_mesh_box(depth+depth_base+finger_width, finger_width, height)
+    right = create_mesh_box(depth+depth_base+finger_width, finger_width, height)
+    bottom = create_mesh_box(finger_width, width, height)
+    tail = create_mesh_box(tail_length, finger_width, height)
+
+    left_points = np.array(left.vertices)
+    left_triangles = np.array(left.triangles)
+    left_points[:,0] -= depth_base + finger_width
+    left_points[:,1] -= width/2 + finger_width
+    left_points[:,2] -= height/2
+
+    right_points = np.array(right.vertices)
+    right_triangles = np.array(right.triangles) + 8
+    right_points[:,0] -= depth_base + finger_width
+    right_points[:,1] += width/2
+    right_points[:,2] -= height/2
+
+    bottom_points = np.array(bottom.vertices)
+    bottom_triangles = np.array(bottom.triangles) + 16
+    bottom_points[:,0] -= finger_width + depth_base
+    bottom_points[:,1] -= width/2
+    bottom_points[:,2] -= height/2
+
+    tail_points = np.array(tail.vertices)
+    tail_triangles = np.array(tail.triangles) + 24
+    tail_points[:,0] -= tail_length + finger_width + depth_base
+    tail_points[:,1] -= finger_width / 2
+    tail_points[:,2] -= height/2
+
+    vertices = np.concatenate([left_points, right_points, bottom_points, tail_points], axis=0)
+    vertices = np.dot(R, vertices.T).T + center
+    triangles = np.concatenate([left_triangles, right_triangles, bottom_triangles, tail_triangles], axis=0)
+    colors = np.array([ [color_r,color_g,color_b] for _ in range(len(vertices))])
+
+    gripper = o3d.geometry.TriangleMesh()
+    gripper.vertices = o3d.utility.Vector3dVector(vertices)
+    gripper.triangles = o3d.utility.Vector3iVector(triangles)
+    gripper.vertex_colors = o3d.utility.Vector3dVector(colors)
+    return gripper
+
+
+def find_scene_by_model_id(dataset_root, model_id_list):
+    picked_scene_names = []
+    scene_names = ['scene_'+str(i).zfill(4) for i in range(190)]
+    for scene_name in scene_names:
+        try:
+            scene_reader = xmlReader(os.path.join(dataset_root, 'scenes', scene_name, 'kinect', 'annotations', '0000.xml'))
+        except:
+            continue
+        posevectors = scene_reader.getposevectorlist()
+        for posevector in posevectors:
+            obj_idx, _ = parse_posevector(posevector)
+            if obj_idx in model_id_list:
+                picked_scene_names.append(scene_name)
+                print(obj_idx, scene_name)
+                break
+    return picked_scene_names
+
+def generate_scene(scene_idx, anno_idx, return_poses=False, align=False, camera='realsense'):
+    camera_poses = np.load(os.path.join('scenes','scene_%04d' %(scene_idx,),camera, 'camera_poses.npy'))
+    camera_pose = camera_poses[anno_idx]
+    if align:
+        align_mat = np.load(os.path.join('camera_poses', '{}_alignment.npy'.format(camera)))
+        camera_pose = align_mat.dot(camera_pose)
+    camera_split = 'data' if camera == 'realsense' else 'data_kinect'
+    # print('Scene {}, {}'.format(scene_idx, camera_split))
+    scene_reader = xmlReader(os.path.join(scenedir % (scene_idx, camera), 'annotations', '%04d.xml'%(anno_idx)))
+    posevectors = scene_reader.getposevectorlist()
+    obj_list = []
+    mat_list = []
+    model_list = []
+    pose_list = []
+    for posevector in posevectors:
+        obj_idx, mat = parse_posevector(posevector)
+        obj_list.append(obj_idx)
+        mat_list.append(mat)
+
+    for obj_idx, mat in zip(obj_list, mat_list):
+        model = o3d.io.read_point_cloud(os.path.join(modeldir, '%03d'%obj_idx, 'nontextured.ply'))
+        points = np.array(model.points)
+        pose = np.dot(camera_pose, mat)
+        points = transform_points(points, pose)
+        model.points = o3d.utility.Vector3dVector(points)
+        model_list.append(model)
+        pose_list.append(pose)
+
+    if return_poses:
+        return model_list, obj_list, pose_list
+    else:
+        return model_list
+
+def get_obj_pose_list(camera_pose, pose_vectors):
+    import numpy as np
+    obj_list = []
+    mat_list = []
+    pose_list = []
+    for posevector in pose_vectors:
+        obj_idx, mat = parse_posevector(posevector)
+        obj_list.append(obj_idx)
+        mat_list.append(mat)
+
+    for obj_idx, mat in zip(obj_list, mat_list):
+        pose = np.dot(camera_pose, mat)
+        pose_list.append(pose)
+
+    return obj_list, pose_list
+
+def batch_rgbdxyz_2_rgbxy_depth(points, camera):
+    '''
+    **Input:**
+
+    - points: np.array(-1,3) of the points in camera frame
+
+    - camera: string of the camera type
+
+    **Output:**
+
+    - coords: float of xy in pixel frame [-1, 2]
+
+    - depths: float of the depths of pixel frame [-1]
+    '''
+    intrinsics = get_camera_intrinsic(camera)
+    fx, fy = intrinsics[0,0], intrinsics[1,1]
+    cx, cy = intrinsics[0,2], intrinsics[1,2]
+    s = 1000.0
+    depths = s * points[:,2] # point_z
+    ###################################
+    # x and y should be inverted here #
+    ###################################
+    # y = point[0] / point[2] * fx + cx 
+    # x = point[1] / point[2] * fy + cy
+    # cx = 640, cy = 360 
+    coords_x = points[:,0] / points[:,2] * fx + cx
+    coords_y = points[:,1] / points[:,2] * fy + cy
+    coords = np.stack([coords_x, coords_y], axis=-1)
+    return coords, depths
+
+def get_batch_key_points(centers, Rs, widths):
+    '''
+    **Input:**
+
+    - centers: np.array(-1,3) of the translation
+
+    - Rs: np.array(-1,3,3) of the rotation matrix
+
+    - widths: np.array(-1) of the grasp width
+
+    **Output:**
+
+    - key_points: np.array(-1,4,3) of the key point of the grasp
+    '''
+    import numpy as np
+    depth_base = 0.02
+    height = 0.02
+    key_points = np.zeros((centers.shape[0],4,3),dtype = np.float32)
+    key_points[:,:,0] -= depth_base
+    key_points[:,1:,1] -= widths[:,np.newaxis] / 2
+    key_points[:,2,2] += height / 2
+    key_points[:,3,2] -= height / 2
+    key_points = np.matmul(Rs, key_points.transpose(0,2,1)).transpose(0,2,1)
+    key_points = key_points + centers[:,np.newaxis,:]
+    return key_points
+
+def batch_key_points_2_tuple(key_points, scores, object_ids, camera):
+    '''
+    **Input:**
+
+    - key_points: np.array(-1,4,3) of grasp key points, definition is shown in key_points.png
+    
+    - scores: numpy array of batch grasp scores.
+
+    - camera: string of 'realsense' or 'kinect'.
+
+    **Output:**
+
+    - np.array([center_x,center_y,open_x,open_y,height])
+    '''
+    import numpy as np
+    centers, _ = batch_rgbdxyz_2_rgbxy_depth(key_points[:,0,:], camera)
+    opens, _ = batch_rgbdxyz_2_rgbxy_depth(key_points[:,1,:], camera)
+    lefts, _ = batch_rgbdxyz_2_rgbxy_depth(key_points[:,2,:], camera)
+    rights, _ = batch_rgbdxyz_2_rgbxy_depth(key_points[:,3,:], camera)
+    heights = np.linalg.norm(lefts - rights, axis=-1, keepdims=True)
+    tuples = np.concatenate([centers, opens, heights, scores[:, np.newaxis], object_ids[:, np.newaxis]], axis=-1).astype(np.float32)
+    return tuples
+
+def framexy_depth_2_xyz(pixel_x, pixel_y, depth, camera):
+    '''
+    **Input:**
+
+    - pixel_x: int of the pixel x coordinate.
+    
+    - pixel_y: int of the pixle y coordicate.
+    
+    - depth: float of depth. The unit is millimeter.
+    
+    - camera: string of type of camera. "realsense" or "kinect".
+    
+    **Output:**
+    
+    - x, y, z: float of x, y and z coordinates in camera frame. The unit is millimeter.
+    '''
+    intrinsics = get_camera_intrinsic(camera)
+    fx, fy = intrinsics[0,0], intrinsics[1,1]
+    cx, cy = intrinsics[0,2], intrinsics[1,2]
+    z = depth # mm
+    x = z / fx * (pixel_x - cx) # mm
+    y = z / fy * (pixel_y - cy) # mm
+    return x, y, z
+
+def batch_framexy_depth_2_xyz(pixel_x, pixel_y, depth, camera):
+    '''
+    **Input:**
+
+    - pixel_x: numpy array of int of the pixel x coordinate. shape: (-1,)
+
+    - pixel_y: numpy array of int of the pixle y coordicate. shape: (-1,)
+
+    - depth: numpy array of float of depth. The unit is millimeter. shape: (-1,)
+
+    - camera: string of type of camera. "realsense" or "kinect".
+
+    **Output:**
+
+    x, y, z: numpy array of float of x, y and z coordinates in camera frame. The unit is millimeter.
+    '''
+    intrinsics = get_camera_intrinsic(camera)
+    fx, fy = intrinsics[0,0], intrinsics[1,1]
+    cx, cy = intrinsics[0,2], intrinsics[1,2]
+    z = depth # mm
+    x = z / fx * (pixel_x - cx) # mm
+    y = z / fy * (pixel_y - cy) # mm
+    return x, y, z
+
+def center_depth(depths, center, open_point, upper_point):
+    '''
+    **Input:**
+
+    - depths: numpy array of the depths.
+
+    - center: numpy array of the center point.
+
+    - open_point: numpy array of the open point.
+
+    - upper_point: numpy array of the upper point.
+
+    **Output:**
+
+    - depth: float of the grasp depth.
+    '''
+    return depths[int(round(center[1])), int(round(center[0]))]
+
+def batch_center_depth(depths, centers, open_points, upper_points):
+    '''
+    **Input:**
+
+    - depths: numpy array of the depths.
+
+    - centers: numpy array of the center points of shape(-1, 2).
+
+    - open_points: numpy array of the open points of shape(-1, 2).
+
+    - upper_points: numpy array of the upper points of shape(-1, 2).
+
+    **Output:**
+
+    - depths: numpy array of the grasp depth of shape (-1).
+    '''
+    x = np.round(centers[:,0]).astype(np.int32)
+    y = np.round(centers[:,1]).astype(np.int32)
+    return depths[y, x]
+
+def key_point_2_rotation(center_xyz, open_point_xyz, upper_point_xyz):
+    '''
+    **Input:**
+
+    - center_xyz: numpy array of the center point.
+
+    - open_point_xyz: numpy array of the open point.
+
+    - upper_point_xyz: numpy array of the upper point.
+
+    **Output:**
+
+    - rotation: numpy array of the rotation matrix.
+    '''
+    open_point_vector = open_point_xyz - center_xyz
+    upper_point_vector = upper_point_xyz - center_xyz
+    unit_open_point_vector = open_point_vector / np.linalg.norm(open_point_vector)
+    unit_upper_point_vector = upper_point_vector / np.linalg.norm(upper_point_vector)
+    rotation = np.hstack((
+        np.array([[0],[0],[1.0]]), 
+        unit_open_point_vector.reshape((-1, 1)), 
+        unit_upper_point_vector.reshape((-1, 1))
+    ))
+    return rotation
+
+def batch_key_point_2_rotation(centers_xyz, open_points_xyz, upper_points_xyz):
+    '''
+    **Input:**
+
+    - centers_xyz: numpy array of the center points of shape (-1, 3).
+
+    - open_points_xyz: numpy array of the open points of shape (-1, 3).
+
+    - upper_points_xyz: numpy array of the upper points of shape (-1, 3).
+
+    **Output:**
+
+    - rotations: numpy array of the rotation matrix of shape (-1, 3, 3).
+    '''
+    # print('open_points_xyz:{}'.format(open_points_xyz))
+    # print('upper_points_xyz:{}'.format(upper_points_xyz))
+    open_points_vector = open_points_xyz - centers_xyz # (-1, 3)
+    upper_points_vector = upper_points_xyz - centers_xyz # (-1, 3)
+    open_point_norm = np.linalg.norm(open_points_vector, axis = 1).reshape(-1, 1)
+    upper_point_norm = np.linalg.norm(upper_points_vector, axis = 1).reshape(-1, 1)
+    # print('open_point_norm:{}, upper_point_norm:{}'.format(open_point_norm, upper_point_norm))
+    unit_open_points_vector = open_points_vector / np.hstack((open_point_norm, open_point_norm, open_point_norm)) # (-1, 3)
+    unit_upper_points_vector = upper_points_vector / np.hstack((upper_point_norm, upper_point_norm, upper_point_norm)) # (-1, 3)
+    num = open_points_vector.shape[0]
+    x_axis = np.hstack((np.zeros((num, 1)), np.zeros((num, 1)), np.ones((num, 1)))).astype(np.float32).reshape(-1, 3, 1)
+    rotations = np.dstack((x_axis, unit_open_points_vector.reshape((-1, 3, 1)), unit_upper_points_vector.reshape((-1, 3, 1))))
+    return rotations

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/vis.py

@@ -0,0 +1,383 @@
+import os
+import time
+import numpy as np
+import open3d as o3d
+from transforms3d.euler import euler2mat, quat2mat
+from .utils import generate_scene_model, generate_scene_pointcloud, generate_views, get_model_grasps, plot_gripper_pro_max, transform_points
+from .rotation import viewpoint_params_to_matrix, batch_viewpoint_params_to_matrix
+
+def create_table_cloud(width, height, depth, dx=0, dy=0, dz=0, grid_size=0.01):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - width/height/depth: float, table width/height/depth along x/z/y-axis in meters
+
+    - dx/dy/dz: float, offset along x/y/z-axis in meters
+
+    - grid_size: float, point distance along x/y/z-axis in meters
+
+    **Output:**
+
+    - open3d.geometry.PointCloud
+    '''
+    xmap = np.linspace(0, width, int(width/grid_size))
+    ymap = np.linspace(0, depth, int(depth/grid_size))
+    zmap = np.linspace(0, height, int(height/grid_size))
+    xmap, ymap, zmap = np.meshgrid(xmap, ymap, zmap, indexing='xy')
+    xmap += dx
+    ymap += dy
+    zmap += dz
+    points = np.stack([xmap, -ymap, -zmap], axis=-1)
+    points = points.reshape([-1, 3])
+    cloud = o3d.geometry.PointCloud()
+    cloud.points = o3d.utility.Vector3dVector(points)
+    return cloud
+
+
+def get_camera_parameters(camera='kinect'):
+    '''
+    author: Minghao Gou
+    
+    **Input:**
+
+    - camera: string of type of camera: 'kinect' or 'realsense'
+
+    **Output:**
+
+    - open3d.camera.PinholeCameraParameters
+    '''
+    import open3d as o3d
+    param = o3d.camera.PinholeCameraParameters()
+    param.extrinsic = np.eye(4,dtype=np.float64)
+    # param.intrinsic = o3d.camera.PinholeCameraIntrinsic()
+    if camera == 'kinect':
+        param.intrinsic.set_intrinsics(1280,720,631.5,631.2,639.5,359.5)
+    elif camera == 'realsense':
+        param.intrinsic.set_intrinsics(1280,720,927.17,927.37,639.5,359.5)
+    return param
+
+def visAnno(dataset_root, scene_name, anno_idx, camera, num_grasp=10, th=0.3, align_to_table=True, max_width=0.08, save_folder='save_fig', show=False, per_obj=False):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - dataset_root: str, graspnet dataset root
+
+    - scene_name: str, name of scene folder, e.g. scene_0000
+
+    - anno_idx: int, frame index from 0-255
+
+    - camera: str, camera name (realsense or kinect)
+
+    - num_grasp: int, number of sampled grasps
+
+    - th: float, threshold of friction coefficient
+
+    - align_to_table: bool, transform to table coordinates if set to True
+
+    - max_width: float, only visualize grasps with width<=max_width
+
+    - save_folder: str, folder to save screen captures
+
+    - show: bool, show visualization in open3d window if set to True
+
+    - per_obj: bool, show grasps on each object
+    '''
+    model_list, obj_list, pose_list = generate_scene_model(dataset_root, scene_name, anno_idx, return_poses=True, align=align_to_table, camera=camera)
+    point_cloud = generate_scene_pointcloud(dataset_root, scene_name, anno_idx, align=align_to_table, camera=camera)
+
+    table = create_table_cloud(1.0, 0.02, 1.0, dx=-0.5, dy=-0.5, dz=0, grid_size=0.01)
+    num_views, num_angles, num_depths = 300, 12, 4
+    views = generate_views(num_views)
+    collision_label = np.load('{}/collision_label/{}/collision_labels.npz'.format(dataset_root,scene_name))
+
+    vis = o3d.visualization.Visualizer()
+    vis.create_window(width = 1280, height = 720)
+    ctr = vis.get_view_control()
+    param = get_camera_parameters(camera=camera)
+
+    if align_to_table:
+        cam_pos = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'cam0_wrt_table.npy'))
+        param.extrinsic = np.linalg.inv(cam_pos).tolist()
+
+    grippers = []
+    vis.add_geometry(point_cloud)
+    for i, (obj_idx, trans) in enumerate(zip(obj_list, pose_list)):
+        sampled_points, offsets, scores, _ = get_model_grasps('%s/grasp_label/%03d_labels.npz'%(dataset_root, obj_idx))
+        collision = collision_label['arr_{}'.format(i)]
+
+        cnt = 0
+        point_inds = np.arange(sampled_points.shape[0])
+        np.random.shuffle(point_inds)
+
+        for point_ind in point_inds:
+            target_point = sampled_points[point_ind]
+            offset = offsets[point_ind]
+            score = scores[point_ind]
+            view_inds = np.arange(300)
+            np.random.shuffle(view_inds)
+            flag = False
+            for v in view_inds:
+                if flag: break
+                view = views[v]
+                angle_inds = np.arange(12)
+                np.random.shuffle(angle_inds)
+                for a in angle_inds:
+                    if flag: break
+                    depth_inds = np.arange(4)
+                    np.random.shuffle(depth_inds)
+                    for d in depth_inds:
+                        if flag: break
+                        angle, depth, width = offset[v, a, d]
+                        if score[v, a, d] > th or score[v, a, d] < 0:
+                            continue
+                        if width > max_width:
+                            continue
+                        if collision[point_ind, v, a, d]:
+                            continue
+                        R = viewpoint_params_to_matrix(-view, angle)
+                        t = transform_points(target_point[np.newaxis,:], trans).squeeze()
+                        R = np.dot(trans[:3,:3], R)
+                        gripper = plot_gripper_pro_max(t, R, width, depth, 1.1-score[v, a, d])
+                        grippers.append(gripper)
+                        flag = True
+            if flag:
+                cnt += 1
+            if cnt == num_grasp:
+                break
+
+        if per_obj:
+            for gripper in grippers:
+                vis.add_geometry(gripper)
+            ctr.convert_from_pinhole_camera_parameters(param)
+            vis.poll_events()
+            filename = os.path.join(save_folder, '{}_{}_pointcloud_{}.png'.format(scene_name, camera, obj_idx))
+            if not os.path.exists(save_folder):
+                os.mkdir(save_folder)
+            vis.capture_screen_image(filename, do_render=True)
+            
+            for gripper in grippers:
+                vis.remove_geometry(gripper)
+            grippers = []
+
+    if not per_obj:
+        for gripper in grippers:
+            vis.add_geometry(gripper)
+        ctr.convert_from_pinhole_camera_parameters(param)
+        vis.poll_events()
+        filename = os.path.join(save_folder, '{}_{}_pointcloud.png'.format(scene_name, camera))
+        if not os.path.exists(save_folder):
+            os.mkdir(save_folder)
+        vis.capture_screen_image(filename, do_render=True)
+        if show:
+            o3d.visualization.draw_geometries([point_cloud, *grippers])
+
+        vis.remove_geometry(point_cloud)
+        vis.add_geometry(table)
+        for model in model_list:
+            vis.add_geometry(model)
+        ctr.convert_from_pinhole_camera_parameters(param)
+        vis.poll_events()
+        filename = os.path.join(save_folder, '{}_{}_model.png'.format(scene_name, camera))
+        vis.capture_screen_image(filename, do_render=True)
+        if show:
+            o3d.visualization.draw_geometries([table, *model_list, *grippers])
+
+
+def vis6D(dataset_root, scene_name, anno_idx, camera, align_to_table=True, save_folder='save_fig', show=False, per_obj=False):
+    '''
+    **Input:**
+
+    - dataset_root: str, graspnet dataset root
+
+    - scene_name: str, name of scene folder, e.g. scene_0000
+
+    - anno_idx: int, frame index from 0-255
+
+    - camera: str, camera name (realsense or kinect)
+
+    - align_to_table: bool, transform to table coordinates if set to True
+
+    - save_folder: str, folder to save screen captures
+
+    - show: bool, show visualization in open3d window if set to True
+
+    - per_obj: bool, show pose of each object
+    '''
+    model_list, obj_list, pose_list = generate_scene_model(dataset_root, scene_name, anno_idx, return_poses=True, align=align_to_table, camera=camera)
+    point_cloud = generate_scene_pointcloud(dataset_root, scene_name, anno_idx, align=align_to_table, camera=camera)
+    point_cloud = point_cloud.voxel_down_sample(voxel_size=0.005)
+
+    vis = o3d.visualization.Visualizer()
+    vis.create_window(width = 1280, height = 720)
+    ctr = vis.get_view_control()
+    param = get_camera_parameters(camera=camera)
+
+    if align_to_table:
+        cam_pos = np.load(os.path.join(dataset_root, 'scenes', scene_name, camera, 'cam0_wrt_table.npy'))
+        param.extrinsic = np.linalg.inv(cam_pos).tolist()
+
+    vis.add_geometry(point_cloud)
+    if per_obj:
+        for i,model in zip(obj_list,model_list):
+            vis.add_geometry(model)
+            ctr.convert_from_pinhole_camera_parameters(param)
+            vis.poll_events()
+            filename = os.path.join(save_folder, '{}_{}_6d_{}.png'.format(scene_name, camera, i))
+            vis.capture_screen_image(filename, do_render=True)
+            vis.remove_geometry(model)
+    else:
+        for model in model_list:
+            vis.add_geometry(model)
+        ctr.convert_from_pinhole_camera_parameters(param)
+        vis.poll_events()
+        filename = os.path.join(save_folder, '{}_{}_6d.png'.format(scene_name, camera))
+        vis.capture_screen_image(filename, do_render=True)
+        if show:
+            o3d.visualization.draw_geometries([point_cloud, *model_list])
+
+
+
+def visObjGrasp(dataset_root, obj_idx, num_grasp=10, th=0.5, max_width=0.08, save_folder='save_fig', show=False):
+    '''
+    Author: chenxi-wang
+    
+    **Input:**
+
+    - dataset_root: str, graspnet dataset root
+
+    - obj_idx: int, index of object model
+
+    - num_grasp: int, number of sampled grasps
+
+    - th: float, threshold of friction coefficient
+
+    - max_width: float, only visualize grasps with width<=max_width
+
+    - save_folder: str, folder to save screen captures
+
+    - show: bool, show visualization in open3d window if set to True
+    '''
+    plyfile = os.path.join(dataset_root, 'models', '%03d'%obj_idx, 'nontextured.ply')
+    model = o3d.io.read_point_cloud(plyfile)
+
+    num_views, num_angles, num_depths = 300, 12, 4
+    views = generate_views(num_views)
+
+    vis = o3d.visualization.Visualizer()
+    vis.create_window(width = 1280, height = 720)
+    ctr = vis.get_view_control()
+    param = get_camera_parameters(camera='kinect')
+
+    cam_pos = np.load(os.path.join(dataset_root, 'scenes', 'scene_0000', 'kinect', 'cam0_wrt_table.npy'))
+    param.extrinsic = np.linalg.inv(cam_pos).tolist()
+
+    sampled_points, offsets, scores, _ = get_model_grasps('%s/grasp_label/%03d_labels.npz'%(dataset_root, obj_idx))
+
+    cnt = 0
+    point_inds = np.arange(sampled_points.shape[0])
+    np.random.shuffle(point_inds)
+    grippers = []
+
+    for point_ind in point_inds:
+        target_point = sampled_points[point_ind]
+        offset = offsets[point_ind]
+        score = scores[point_ind]
+        view_inds = np.arange(300)
+        np.random.shuffle(view_inds)
+        flag = False
+        for v in view_inds:
+            if flag: break
+            view = views[v]
+            angle_inds = np.arange(12)
+            np.random.shuffle(angle_inds)
+            for a in angle_inds:
+                if flag: break
+                depth_inds = np.arange(4)
+                np.random.shuffle(depth_inds)
+                for d in depth_inds:
+                    if flag: break
+                    angle, depth, width = offset[v, a, d]
+                    if score[v, a, d] > th or score[v, a, d] < 0 or width > max_width:
+                        continue
+                    R = viewpoint_params_to_matrix(-view, angle)
+                    t = target_point
+                    gripper = plot_gripper_pro_max(t, R, width, depth, 1.1-score[v, a, d])
+                    grippers.append(gripper)
+                    flag = True
+        if flag:
+            cnt += 1
+        if cnt == num_grasp:
+            break
+
+    vis.add_geometry(model)
+    for gripper in grippers:
+        vis.add_geometry(gripper)
+    ctr.convert_from_pinhole_camera_parameters(param)
+    vis.poll_events()
+    filename = os.path.join(save_folder, 'object_{}_grasp.png'.format(obj_idx))
+    vis.capture_screen_image(filename, do_render=True)
+    if show:
+        o3d.visualization.draw_geometries([model, *grippers])
+
+def vis_rec_grasp(rec_grasp_tuples,numGrasp,image_path,save_path,show=False):
+    '''
+    author: Minghao Gou
+    
+    **Input:**
+
+    - rec_grasp_tuples: np.array of rectangle grasps
+
+    - numGrasp: int of total grasps number to show
+
+    - image_path: string of path of the image
+
+    - image_path: string of the path to save the image
+
+    - show: bool of whether to show the image 
+
+    **Output:**
+
+    - no output but display the rectangle grasps in image
+    '''
+    import cv2
+    import numpy as np
+    import os
+    img = cv2.imread(image_path)
+    if len(rec_grasp_tuples) > numGrasp:
+            np.random.shuffle(rec_grasp_tuples)
+            rec_grasp_tuples = rec_grasp_tuples[0:numGrasp]
+    for rec_grasp_tuple in rec_grasp_tuples:
+        center_x,center_y,open_x,open_y,height,score = rec_grasp_tuple
+        center = np.array([center_x,center_y])
+        left = np.array([open_x,open_y])
+        axis = left - center
+        normal = np.array([-axis[1],axis[0]])
+        normal = normal / np.linalg.norm(normal) * height / 2
+        p1 = center + normal + axis
+        p2 = center + normal - axis
+        p3 = center - normal - axis
+        p4 = center - normal + axis
+        cv2.line(img, (int(p1[0]),int(p1[1])), (int(p2[0]),int(p2[1])), (0,0,255), 1, 8)
+        cv2.line(img, (int(p2[0]),int(p2[1])), (int(p3[0]),int(p3[1])), (255,0,0), 3, 8)
+        cv2.line(img, (int(p3[0]),int(p3[1])), (int(p4[0]),int(p4[1])), (0,0,255), 1, 8)
+        cv2.line(img, (int(p4[0]),int(p4[1])), (int(p1[0]),int(p1[1])), (255,0,0), 3, 8)
+    cv2.imwrite(save_path,img)
+    if show:
+        cv2.imshow('grasp',img)
+        cv2.waitKey(0)
+        cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    camera = 'kinect'
+    dataset_root = '../'
+    scene_name = 'scene_0000'
+    anno_idx = 0
+    obj_idx = 0
+    visAnno(dataset_root, scene_name, anno_idx, camera, num_grasp=1, th=0.5, align_to_table=True, max_width=0.08, save_folder='save_fig', show=False)
+    vis6D(dataset_root, scene_name, anno_idx, camera, align_to_table=True, save_folder='save_fig', show=False)
+    visObjGrasp(dataset_root, obj_idx, num_grasp=10, th=0.5, save_folder='save_fig', show=False)

third_party/tuntunclaw/graspnet-baseline/graspnetAPI/graspnetAPI/utils/xmlhandler.py

@@ -0,0 +1,158 @@
+__author__ = 'Minghao Gou'
+__version__ = '1.0'
+
+from xml.etree.ElementTree import Element, SubElement, tostring
+import xml.etree.ElementTree as ET
+import xml.dom.minidom
+from transforms3d.quaternions import mat2quat, quat2axangle
+from transforms3d.euler import quat2euler
+import numpy as np
+from .trans3d import get_mat, pos_quat_to_pose_4x4
+import os
+from .pose import pose_list_from_pose_vector_list
+
+
+class xmlWriter():
+    def __init__(self, topfromreader=None):
+        self.topfromreader = topfromreader
+        self.poselist = []
+        self.objnamelist = []
+        self.objpathlist = []
+        self.objidlist = []
+    def addobject(self, pose, objname, objpath, objid):
+        # pose is the 4x4 matrix representation of 6d pose
+        self.poselist.append(pose)
+        self.objnamelist.append(objname)
+        self.objpathlist.append(objpath)
+        self.objidlist.append(objid)
+
+    def objectlistfromposevectorlist(self, posevectorlist, objdir, objnamelist, objidlist):
+        self.poselist = []
+        self.objnamelist = []
+        self.objidlist = []
+        self.objpathlist = []
+        for i in range(len(posevectorlist)):
+            id, x, y, z, alpha, beta, gamma = posevectorlist[i]
+            objname = objnamelist[objidlist[i]]
+            self.addobject(get_mat(x, y, z, alpha, beta, gamma),
+                           objname, os.path.join(objdir, objname), id)
+
+    def writexml(self, xmlfilename='scene.xml'):
+        if self.topfromreader is not None:
+            self.top = self.topfromreader
+        else:
+            self.top = Element('scene')
+        for i in range(len(self.poselist)):
+            obj_entry = SubElement(self.top, 'obj')
+
+            obj_name = SubElement(obj_entry, 'obj_id')
+            obj_name.text = str(self.objidlist[i])
+
+            obj_name = SubElement(obj_entry, 'obj_name')
+            obj_name.text = self.objnamelist[i]
+
+            obj_path = SubElement(obj_entry, 'obj_path')
+            obj_path.text = self.objpathlist[i]
+            pose = self.poselist[i]
+            pose_in_world = SubElement(obj_entry, 'pos_in_world')
+            pose_in_world.text = '{:.4f} {:.4f} {:.4f}'.format(
+                pose[0, 3], pose[1, 3], pose[2, 3])
+
+            rotationMatrix = pose[0:3, 0:3]
+            quat = mat2quat(rotationMatrix)
+
+            ori_in_world = SubElement(obj_entry, 'ori_in_world')
+            ori_in_world.text = '{:.4f} {:.4f} {:.4f} {:.4f}'.format(
+                quat[0], quat[1], quat[2], quat[3])
+        xmlstr = xml.dom.minidom.parseString(
+            tostring(self.top)).toprettyxml(indent='    ')
+        # remove blank line
+        xmlstr = "".join([s for s in xmlstr.splitlines(True) if s.strip()])
+        with open(xmlfilename, 'w') as f:
+            f.write(xmlstr)
+            #print('log:write annotation file '+xmlfilename)
+
+
+class xmlReader():
+    def __init__(self, xmlfilename):
+        self.xmlfilename = xmlfilename
+        etree = ET.parse(self.xmlfilename)
+        self.top = etree.getroot()
+
+    def showinfo(self):
+        print('Resumed object(s) already stored in '+self.xmlfilename+':')
+        for i in range(len(self.top)):
+            print(self.top[i][1].text)
+
+    def gettop(self):
+        return self.top
+
+    def getposevectorlist(self):
+        # posevector foramat: [objectid,x,y,z,alpha,beta,gamma]
+        posevectorlist = []
+        for i in range(len(self.top)):
+            objectid = int(self.top[i][0].text)
+            objectname = self.top[i][1].text
+            objectpath = self.top[i][2].text
+            translationtext = self.top[i][3].text.split()
+            translation = []
+            for text in translationtext:
+                translation.append(float(text))
+            quattext = self.top[i][4].text.split()
+            quat = []
+            for text in quattext:
+                quat.append(float(text))
+            alpha, beta, gamma = quat2euler(quat)
+            x, y, z = translation
+            alpha *= (180.0 / np.pi)
+            beta *= (180.0 / np.pi)
+            gamma *= (180.0 / np.pi)
+            posevectorlist.append([objectid, x, y, z, alpha, beta, gamma])
+        return posevectorlist
+
+    def get_pose_list(self):
+        pose_vector_list = self.getposevectorlist()
+        return pose_list_from_pose_vector_list(pose_vector_list)
+
+def empty_pose_vector(objectid):
+    # [object id,x,y,z,alpha,beta,gamma]
+    # alpha, beta and gamma are in degree
+	return [objectid, 0.0, 0.0, 0.4, 0.0, 0.0, 0.0]
+
+
+def empty_pose_vector_list(objectidlist):
+	pose_vector_list = []
+	for id in objectidlist:
+		pose_vector_list.append(empty_pose_vector(id))
+	return pose_vector_list
+
+
+def getposevectorlist(objectidlist, is_resume, num_frame, frame_number, xml_dir):
+    if not is_resume or (not os.path.exists(os.path.join(xml_dir, '%04d.xml' % num_frame))):
+        print('log:create empty pose vector list')
+        return empty_pose_vector_list(objectidlist)
+    else:
+        print('log:resume pose vector from ' +
+              os.path.join(xml_dir, '%04d.xml' % num_frame))
+        xmlfile = os.path.join(xml_dir, '%04d.xml' % num_frame)
+        mainxmlReader = xmlReader(xmlfile)
+        xmlposevectorlist = mainxmlReader.getposevectorlist()
+        posevectorlist = []
+        for objectid in objectidlist:
+            posevector = [objectid, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+            for xmlposevector in xmlposevectorlist:
+                if xmlposevector[0] == objectid:
+                    posevector = xmlposevector
+            posevectorlist.append(posevector)
+        return posevectorlist
+
+
+def getframeposevectorlist(objectidlist, is_resume, frame_number, xml_dir):
+    frameposevectorlist = []
+    for num_frame in range(frame_number):
+        if not is_resume or (not os.path.exists(os.path.join(xml_dir,'%04d.xml' % num_frame))):
+            posevectorlist=getposevectorlist(objectidlist,False,num_frame,frame_number,xml_dir)	
+        else:
+            posevectorlist=getposevectorlist(objectidlist,True,num_frame,frame_number,xml_dir)
+        frameposevectorlist.append(posevectorlist)
+    return frameposevectorlist

third_party/tuntunclaw/manipulator_grasp/utils/mj.py

@@ -0,0 +1,96 @@
+from typing import List, Optional, Tuple, Union
+import numpy as np
+import spatialmath as sm
+import spatialmath.base as smb
+import mujoco as mj
+from .rtb import make_tf
+
+
+def set_body_pose(model: mj.MjModel, data: mj.MjData, body_name: Union[int, str], xpos: np.ndarray) -> None:
+    body_id = (
+        body_name if isinstance(body_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_BODY, body_name)
+    )
+    data.body(body_id).xpos = xpos[:3]
+
+def get_body_pose(model: mj.MjModel, data: mj.MjData, body_name: Union[int, str]) -> sm.SE3:
+    body_id = (
+        body_name if isinstance(body_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_BODY, body_name)
+    )
+    t = data.body(body_id).xpos
+    q = data.body(body_id).xquat
+    return make_tf(pos=t, ori=q)
+
+
+def set_joint_q(model: mj.MjModel, data: mj.MjData, joint_name: Union[int, str], q: Union[np.ndarray, float],
+                unit: str = "rad") -> None:
+    joint_id = (
+        joint_name if isinstance(joint_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_JOINT, joint_name)
+    )
+
+    if unit == 'deg':
+        q = np.deg2rad(q)
+
+    q_inds = get_joint_qpos_inds(model, data, joint_id)
+    data.qpos[q_inds] = q
+
+
+def get_joint_q(model: mj.MjModel, data: mj.MjData, joint_name: Union[int, str]) -> np.ndarray:
+    joint_id = (
+        joint_name if isinstance(joint_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_JOINT, joint_name)
+    )
+    q_inds = get_joint_qpos_inds(model, data, joint_id)
+    return data.qpos[q_inds]
+
+
+def get_joint_qpos_inds(model: mj.MjModel, data: mj.MjData, joint_name: Union[int, str]) -> np.ndarray:
+    joint_id = (
+        joint_name if isinstance(joint_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_JOINT, joint_name)
+    )
+    addr = get_joint_qpos_addr(model, joint_id)
+    joint_dim = get_joint_dim(model, data, joint_id)
+    return np.array(range(addr, addr + joint_dim))
+
+
+def get_joint_qpos_addr(model: mj.MjModel, joint_name: Union[int, str]) -> int:
+    joint_id = (
+        joint_name if isinstance(joint_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_JOINT, joint_name)
+    )
+    return model.jnt_qposadr[joint_id]
+
+
+def get_joint_dim(model: mj.MjModel, data: mj.MjData, joint_name: Union[str, int]) -> int:
+    joint_id = (
+        joint_name if isinstance(joint_name, int) else mj.mj_name2id(model, mj.mjtObj.mjOBJ_JOINT, joint_name)
+    )
+    return len(data.joint(joint_id).qpos)
+
+
+def set_free_joint_pose(model: mj.MjModel, data: mj.MjData, joint_name: Union[int, str], T: sm.SE3) -> None:
+    t = T.t
+    q = sm.base.r2q(T.R).data
+    T_new = np.append(t, q)
+    set_joint_q(model, data, joint_name, T_new)
+
+
+def attach(model: mj.MjModel, data: mj.MjData, equality_name: str, free_joint_name: str, T: sm.SE3,
+           eq_data=np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0]),
+           eq_solimp: np.ndarray = np.array([[0.99, 0.99, 0.001, 0.5, 1]]),
+           eq_solref: np.ndarray = np.array([0.0001, 1])
+           ) -> None:
+    eq_id = mj.mj_name2id(model, mj.mjtObj.mjOBJ_EQUALITY, equality_name)
+
+    if eq_id is None:
+        raise ValueError(
+            f"Equality constraint with name '{equality_name}' not found in the model."
+        )
+
+    data.eq_active[eq_id] = 0
+
+    set_free_joint_pose(model, data, free_joint_name, T)
+
+    model.equality(equality_name).data = eq_data
+
+    model.equality(equality_name).solimp = eq_solimp
+    model.equality(equality_name).solref = eq_solref
+
+    data.eq_active[eq_id] = 1