- changed warning when OpenEXR is missing because there's actually no info about it in README file. Another way would be to add it there and leave warning as it is.

- updated notebooks to use Python 3 as default
- fixed TF2 incompatibility in example at tensorflow.org/graphics
- some typos

Author: Molkree

tensorflow_graphics/g3doc/_index.ipynb

@@ -62,7 +62,7 @@
         "id": "q4fzyll4LvQc"
       },
       "source": [
-        "If Tensorflow Graphics and Trimesh are not installed on your system the following cell can install theses package for you."
+        "If Tensorflow Graphics and Trimesh are not installed on your system the following cell can install these packages for you."
       ]
     },
     {
@@ -110,7 +110,7 @@
         "import tensorflow_graphics.geometry.transformation as tfg_transformation\n",
         "from tensorflow_graphics.notebooks import threejs_visualization\n",
         "\n",
-        "tf.enable_eager_execution()"
+        "tf.compat.v1.enable_v2_behavior()"
       ]
     },
     {
@@ -163,8 +163,8 @@
       "version": "0.3.2"
     },
     "kernelspec": {
-      "display_name": "Python 2",
-      "name": "python2"
+      "display_name": "Python 3",
+      "name": "python3"
     }
   },
   "nbformat": 4,

tensorflow_graphics/g3doc/install.md

@@ -3,8 +3,7 @@
 ## Stable builds
 
 TensorFlow Graphics depends on [TensorFlow](https://www.tensorflow.org/install)
-1.13.1 or above. Nightly builds of TensorFlow that tf-nightly and
-tf-nightly-2.0-preview are also supported.
+1.13.1 or above. Nightly builds of TensorFlow (tf-nightly) are also supported.
 
 To install the latest CPU version from
 [PyPI](https://pypi.org/project/tensorflow-graphics/), run the following:

tensorflow_graphics/notebooks/6dof_alignment.ipynb

@@ -681,8 +681,8 @@
       "version": "0.3.2"
     },
     "kernelspec": {
-      "display_name": "Python 2",
-      "name": "python2"
+      "display_name": "Python 3",
+      "name": "python3"
     }
   },
   "nbformat": 4,

tensorflow_graphics/notebooks/interpolation.ipynb

@@ -61,7 +61,7 @@
       "source": [
         "Given a limited number of pre-defined points and associated values, interpolation allows to predict new data points within the range of the pre-defined points.\n",
         "\n",
-        "In the example below, the left plot shows samples represented as blue dots. Assuming that these samples come from a smooth function, one has many options avaiable to find plausible values *between* these dots. A first option is to build a piece-wise linear function which links any pair of neighbouring points with a line, as can be observed in the cental plot. Another widely used option is to fit a polynomial to these samples. The right plot illustrates a cubic polynomial fitted to the samples.\n",
+        "In the example below, the left plot shows samples represented as blue dots. Assuming that these samples come from a smooth function, one has many options available to find plausible values *between* these dots. A first option is to build a piece-wise linear function which links any pair of neighbouring points with a line, as can be observed in the central plot. Another widely used option is to fit a polynomial to these samples. The right plot illustrates a cubic polynomial fitted to the samples.\n",
         "\n",
         "![](https://storage.googleapis.com/tensorflow-graphics/notebooks/interpolation/interpolations.png)\n",
         "\n",
@@ -132,9 +132,9 @@
       },
       "source": [
         "## Slerp interpolation\n",
-        "Lerp is a widely used interpolation technique allowing to linearly interpolate between points. The piece-wise linear interpolation described at the beginning of this Colab effectively consists of pieces of linear interpolants. But what about if our data lives on a circle or at the surface of a sphere? In that case, Lerp would not provide a good way to interpolate, but fortunately, Slerp would! Slerp stands for *spherical* linear interpolation and has been introduced in the context of interplating quaternions, which is a rotation formalism. We refer the interested reader to the [wikipedia page for Slerp](https://en.wikipedia.org/wiki/Slerp) for further details.\n",
+        "Lerp is a widely used interpolation technique allowing to linearly interpolate between points. The piece-wise linear interpolation described at the beginning of this Colab effectively consists of pieces of linear interpolants. But what about if our data lives on a circle or at the surface of a sphere? In that case, Lerp would not provide a good way to interpolate, but fortunately, Slerp would! Slerp stands for *spherical* linear interpolation and has been introduced in the context of interpolating quaternions, which is a rotation formalism. We refer the interested reader to the [wikipedia page for Slerp](https://en.wikipedia.org/wiki/Slerp) for further details.\n",
         "\n",
-        "The following demo allows to define two vectors, each starting from the center of a circle and ending on the circle. These define the vectors we want to interpolate between, and the slider 'percent' controls the extend to which each vector influence the interpolated vector. Note that the resulting vector also ends on the circle.\n"
+        "The following demo allows to define two vectors, each starting from the center of a circle and ending on the circle. These define the vectors we want to interpolate between, and the slider 'percent' controls the extent to which each vector influences the interpolated vector. Note that the resulting vector also ends on the circle.\n"
       ]
     },
     {
@@ -252,8 +252,8 @@
       "version": "0.3.2"
     },
     "kernelspec": {
-      "display_name": "Python 2",
-      "name": "python2"
+      "display_name": "Python 3",
+      "name": "python3"
     }
   },
   "nbformat": 4,

tensorflow_graphics/notebooks/intrinsics_optimization.ipynb

@@ -63,11 +63,11 @@
         "\n",
         "![](https://storage.googleapis.com/tensorflow-graphics/notebooks/intrinsics/camera_model.jpg)\n",
         "\n",
-        " This model is composed of two parameters that are often refered to as intrinsic parameters:\n",
+        " This model is composed of two parameters that are often referred to as intrinsic parameters:\n",
         "- the principal point, which is the projection of the optical center on the image. Ideally, the principal point is close to the center of the image.\n",
         "- the focal length, which is the distance between the optical center and the image plane. This parameters allows to control the level of zoom.\n",
         "\n",
-        "This notebook illustrates how to use [Tensorflow Graphics](https://github.com/tensorflow/graphics) to estimate the intrinsic parameters of a projective camera. Recovering these parameters is particularly imporant to perform several tasks, including 3D reconstruction.\n",
+        "This notebook illustrates how to use [Tensorflow Graphics](https://github.com/tensorflow/graphics) to estimate the intrinsic parameters of a projective camera. Recovering these parameters is particularly important to perform several tasks, including 3D reconstruction.\n",
         "\n",
         "In this Colab, the goal is to recover the intrinsic parameters of a camera given an observation and correspondences between the observation and the render of the current solution.  Things are kept simple by only inserting a rectangle in the 3D scene, and using it as the source of correspondences during the optimization. The minimization is performed using the Levenberg-Marquardt algorithm."
       ]
@@ -222,7 +222,7 @@
         "ideal_principal_point = np.array(\n",
         "    (image_width, image_height), dtype=np.float64) / 2.0\n",
         "\n",
-        "# Let's see what our scene looks like using the intrinsic paramters defined above.\n",
+        "# Let's see what our scene looks like using the intrinsic parameters defined above.\n",
         "render = render_rectangle(rectangle_vertices, focal_lengths, ideal_principal_point,\n",
         "                          image_dimensions)\n",
         "_ = plt.imshow(render)"
@@ -355,7 +355,7 @@
         "id": "QTdXuY6BapnT"
       },
       "source": [
-        "As described earlier, one can compare how the 3D object would look using the current estimate of the intrinsic parameters, can compare that to the actual observation. The following function captures a distance beween these two images which we will seek to minimize."
+        "As described earlier, one can compare how the 3D object would look using the current estimate of the intrinsic parameters, can compare that to the actual observation. The following function captures a distance between these two images which we will seek to minimize."
       ]
     },
     {
@@ -403,7 +403,7 @@
         "real_focal_lengths, real_principal_point, estimate_focal_lengths, estimate_principal_point = build_parameters(\n",
         ")\n",
         "\n",
-        "# Contructs the observed image.\n",
+        "# Constructs the observed image.\n",
         "observation = render_rectangle(rectangle_vertices, real_focal_lengths,\n",
         "                               real_principal_point, image_dimensions)\n",
         "\n",
@@ -444,8 +444,8 @@
       "version": "0.3.2"
     },
     "kernelspec": {
-      "display_name": "Python 2",
-      "name": "python2"
+      "display_name": "Python 3",
+      "name": "python3"
     }
   },
   "nbformat": 4,