eos-py - v1.5.0

This release contains only a few very minor convenience code updates, and the CI move to GitHub Actions.

This will be the last release to support C++14. The next release will require a C++17 compiler.

Summarised changes: - Added vcpkg.json to use dependencies from vcpkg for local development - Updated CI: switched from Appveyor & Travis to GitHub Actions. Using vcpkg caching on CI. - Added a .yml that builds the Python bindings using cibuildwheel (https://github.com/patrikhuber/eos/pull/361, thank you @omar-h-omar!) - Adding more fitting python bindings (#354) fbb07631934585005c9fd092e254cae6278a9973 (by @omar-h-omar) - Updated pybind11 to 2.13.6 (support for Python 3.12), toml11 to 3.8.1, and Cereal (latest master) - Improved LandmarkMapper support for hybrid mappings: There is now a get_vertex_index() function in LandmarkMapper.hpp that should be used for both use cases and works with both direct (landmark-id to vertex-index in the mappings .txt file) and indirect (landmark-id to generic-landmark-name in the mappings .txt file, generic-landmark-name to vertex-index as landmark_definitions inside a MorphableModel (e.g. the 4DFM uses this)). (61ccbcb88a527b21f14f9303a84ed686b3830e0f, 165d17c00215113e8ea15c6210701d3692a5b950) - Added get_shape_at_point() for neutral shape only models and for PCA expression models (3445b1ccd2b8fc48b132c90c3fe8b8987d2a334a, 32760194ddc21d5012a3488f5100a2cb6be87fa0) - Minor #include & build fixes/updates

Thanks to the new cibuildwheel CI, there are now Python wheels for Windows, Linux and macOS, and for various Python versions, on PyPI: https://pypi.org/project/eos-py/1.5.0/#files

- C++
Published by patrikhuber over 1 year ago

eos-py - v1.4.0

This release contains quite a few major updates, alongside some smaller "maintenance" updates.

• Removed the use of the GLM library completely, and now using Eigen types throughout. (E.g. 413c9f96302286db346384e8be4a371557003a18, 7e99ab18cd538e8d8ddd4b78affa56a8f00dcfe2, a23ee0bacbd32f2649211a88817c23f3d246c7fc, 096b68e3fb560787871bf7be91b2fd914a353be6, and other commits). This simplified a lot of code. Rewrote glm::project(), perspective() and ortho() using Eigen (see eos/render/matrix_projection.hpp).
• Rewrote the nonlinear Ceres fitting using Eigen. This means no more messing around with GLM_FORCE_UNRESTRICTED_GENTYPE. Eigen and Ceres work much nicer together. Many improvements, and most cost functions were renamed - check the commit message in d101ca546118ae8736920915c6ac0dead448161f for more details. Also reworked PriorCost and renamed it to NormCost (e79da919a14b2449acbf8eff57572238e205ed95), and updated fit-model-ceres.
• Now doing a proper conversion between quaternions (or rotation matrices) and Euler angles that makes sense (1023e4b09a8c88f0f7dae25b7f83785f2d997a15, a23ee0bacbd32f2649211a88817c23f3d246c7fc)
• Added the necessary Python bindings so that the fitting loop can now be written and customised in Python (#347) (Thank you @omar-h-omar)
• Updated eigen3-nnls, nanoflann, toml11 and pybind11 submodules to their latest version. Especially toml11 had a big update, and the updated pybind11 supports Python 3.11.
• Minor change, but may break downstream code: Moved fitting::concat to contour_correspondence.hpp (1029f96f8bd8fa66b55ad1f73962b14aa3fc0f85)
• Modernised CMake scripts a bit. Removed add_definitions() for Boost (1de80682ad38f0e5784302e3089b52b6aca5ff39), and used CMake targets whenever available (e.g. Ceres::ceres).

The documentation website is updated to v1.4.0.

The updated release is available on PyPI, with wheels for Python 3.9, 3.10 and 3.11 on Windows (x64), and source installation for other platforms.

Note: It is very likely that the next release will require the C++17 standard, and will no longer compile in C++14 mode.

- C++
Published by patrikhuber about 3 years ago

eos-py - v1.3.0

This is a minor maintenance release, but with one important change, warranting the version push to 1.3.0 to not catch anyone off guard: The Eigen version in 3rdparty/ is updated from 3.3.4 to the latest 3.4.0.

Full release notes: * Eigen version in 3rdparty/ is updated from 3.3.4 to 3.4.0. The submodule now also uses the official Eigen gitlab.com URL. * Added a script to load the Liverpool-York Head Model (LYHM) (1153e77dab41161f91c1bdeece72650b0956317a) * Added a CITATION.cff file to make it easier to correctly cite eos * Updated the __repr__ methods of some Python bindings a bit (9b8b3509e609be026f56d98073c2cb6699c55978) * Replaced ExpressionModelType None with none in Python to avoid clashing with Python's keyword None (85d09d255da4d57817e0263a06aec0626ed38fed) * Added a constructor to eos::core::Mesh's Python bindings to make it more convenient to create a Mesh object (b2f24a12123b0e2409c139cc5d991e3b2a326454) * Updated pybind11 to 2.9.1

Note: It is quite likely that support for C++14 will be dropped in one of the future releases, and a C++17 compliant compiler will become the minimum requirement to use eos.

- C++
Published by patrikhuber about 4 years ago

eos-py - v1.2.1

This is a follow-up update pushing the python bindings to PyPI:

Updated pybind11 to their latest master commit, and changed the Visual Studio CMake generator for the Python bindings from VS 2017 to VS 2019 (75ecca4ac84dce5a1a5113704f7f8714060663da).

eos/@patrikhuber is now part of GitHub Sponsors. If you are finding eos valuable, there is now the possibility of becoming a sponsor.

See the v1.2.0 release notes for all the changes and improvements in this release!

The updated release is available on PyPI.

- C++
Published by patrikhuber almost 6 years ago

eos-py - v1.2.0

This release updates the renderer and texture extraction, with full support for perspective projection (along with orthographic projection), and contains various other smaller improvements and fixes.

New / major improvements: * Improved v2::extract_texture(...) to support texture coordinates with seams (63243b2) * Moved v2::extract_texture(...) to the eos::render namespace and made it the new default (08cba28). Calling code needs to be adjusted slightly, but the function's parameters are very similar. This new texture extraction uses the Rasterizer of the new renderer, and supports both orthographic and perspective projection. * Removed the old extract_texture(...) function, which only supported affine cameras (8fd1735) * Improved SoftwareRenderer::render(...) to correctly deal with texture maps with seams (c1defba) * Removed the old render(...) function, moved v2::SoftwareRenderer to the render namespace, and added a convenience function for the new renderer that can be called (almost) like the old renderer (12a4120) - calling code needs slight adjustments. The core of the new renderer is the same, but the architecture has been changed to mirror more closely the hardware (or OpenGL) pipeline, with vertex- and fragment shaders. Results should be exactly the same, and they have the same parameters. - Note: Whereas previously, meshes without vertex colour would be rendered with the colour (0.5, 0.5, 0.5), in the new renderer, they will have default colour black (bd01644). In any case, it does not make sense to try and render a mesh without vertex colours or texture. * Added vertex visibility check function that supports both orthographic and perspective projection (0db88d3). Introduced an enum class ProjectionType, which specifies whether orthographic or perspective projection should be used.

Fixes: * Changed strides in Image python bindings to account for row-major Image class (dc0fce8). (The Image class was changed to row-major in a commit a while ago, but the python bindings were never updated to accommodate this.) * Updated mpark::variant to their latest master (bd590bf). This should fix a few compile errors with certain compilers when compiling eos in C++14 mode.

Minor improvements/changes: * Improved v2::extract_texture(...) to not crash when the projected model is partially outside the image (442497e) * Added clear_buffers() function to SoftwareRenderer and Rasterizer to clear the colour- and depth buffers (1e8a875) * Set the colourbuffer's clear color to fully transparent (fc1465e) * Added project(...) function to PcaModel (4694d6f) (see #295 for a potential issue) * Moved render/draw_utils.hpp to render/opencv/ (914fdd5) * Added new draw_wireframe(...) function that doesn't need OpenCV (7303b39) and added python binding for it (f1f83d0) * Renamed "isomap" to "texturemap" throughout, and the <filename>.isomap.png output of the example apps to <filename>.texture.png (174a2c2) * Various other minor improvements.

Removed: * Removed render::detail::interpolate_black_line(...) (it was only needed for #4, which was fixed, and also it was for the old texture extraction) (35abed8) * Removed estimate_affine_camera(...). See the commit message, for people that were still using this. (507eb77) * Removed render_affine(...), this was used in the old texture extraction and is no longer needed (aee7984).

- C++
Published by patrikhuber almost 6 years ago

eos-py - v1.1.2

This is a minor update that slightly improves the internals of loading .scm models from CVSSP from the University of Surrey, and also adds load_scm_model(...) to the Python bindings, so these models can be loaded directly in Python.

Changes/improvements:

• Removed the OpenCV dependency of eos/morphablemodel/io/cvssp.hpp, and clarified the documentation slightly [dd4cd62d4724f4368916875d1303f03e98f2f0fb and following]
• Subsequently, the utils (with utils/scm-to-cereal being the only one) can now be built without OpenCV [d465a042a860283ba3f11ce15683bf186a607273]
• Added load_scm_model(...) to the Python bindings (in the namespace eos.morphablemodel.load_scm_model(...)) [b82b85244d5e5ed55a257d0483d21bcfcef4c9c6]

The updated release is also available on PyPI.

- C++
Published by patrikhuber almost 7 years ago

eos-py - v1.1.1

This release mainly fixes the write_obj(...) and write_textured_obj(...) functions to now also write out the texture triangle indices (tti), when they're present in a mesh. Previously for meshes who used a different set of texture triangle indices, this could cause weird artefacts on the top of the head because the tti were not written to the obj. [c25319769f3d103293d62c857a1b330631c90e5f]

Other small changes/improvements: * Moved write_obj(...) and write_textured_obj(...) into a separate header, eos/core/write_obj.hpp, so that including Mesh.hpp doesn't result in transitively including <fstream> and <string> [a040c0ed73b6df426fdfedb7fa7804e28514a879] * Prefixed all header guards with EOS_ in the eos::core namespace to reduce possible name collisions [4381fd16b994c4533e9af2fe6cc1f63b5adea48a] * write_obj(...) now also inverts the y axis of the uv coords, to be consistent with write_textured_obj(...) [7ce291825a916190aedf790b465ec68dcf49373f] * setup.py now checks for CMake 3.10.0 on Windows [3dd69f7727167345f135421a918f2e1ec7c6b5b7]

- C++
Published by patrikhuber about 7 years ago

eos-py - v1.1.0

This release contains an important fix for models that have separate texture_triangle_indices, like e.g. the 4DFM. It also contains a number of other minor improvements and an updated documentation.

Fixes: * texture_triangle_indices is now correctly passed along to sample_to_mesh(...) in all MorphableModel member functions (e598203ddf8ec370cc86b6ab3e1ea8045f6fb705). Previously, get_mean and the draw_sample functions (except for the one that takes shape, colour and expression coefficients) would have returned a mesh without the texture triangle indices (if the MorphableModel contained them). This might actually have been causing wrong code to be run or some bad memory access to - the assert that checks for that in sample_to_mesh(...) is not triggered in Release and RelWithDebInfo builds, therefore we haven't caught this for a while. Now we always handle models correctly that contain texture triangle indices, like the 4DFM.

Minor improvements & changes: * The documentation at http://patrikhuber.github.io/eos/doc/ is now updated to eos v1.1.0 * Added Mesh::tti to the Python bindings (afc80dfb4bdd3160c867e6327be0ec3818da1fb0) * Moved mesh normal computation functions to eos/render/normals.hpp header (5b6cd230ffac75c8139bb1e74be8d888eb830004) * Added functions to compute face and vertex normals of a mesh (7af6131a334666778e96250bfbbaab784186f7ff) * Renamed include/eos/render/utils.hpp to transforms.hpp * Improve error messaging when loading MorphableModels with odd versions (41fddf6d732df07c5077139b74235b995f7edf4f) * Moved ray_triangle_intersect(...) to its own header (5b574092d562e8628b95edbf4af83a2f8049b5e9) * Added simple image resize function (ae533982269246fbb56cf2f2260c9e09a59d49ee) * Improved the natvis Image visualiser for Image Watch: Set channel type to RGB(A) for 3 and 4 channel images (622fc35a0e6fd22938237e834c1511c7a749bbf4)

In-progress changes:

These are in-progress changes on new rendering/texture extraction stuff in the render::v2 namespace - these work in principle but are not too thoroughly tested or used in eos yet. * Uncommented v2::extract_texture(...) and updated all affected code (23d07554a014d7ce1a1fcafe13e4173074175512) * Updated v2::SoftwareRenderer and related code to compile with the latest eos changes and without OpenCV

- C++
Published by patrikhuber over 7 years ago

eos-py - v1.0.1

Small maintenance release with updated Python bindings, fixed demo.py script (updated to work with the latest eos changes), and fixed BFM2009/2017 converter scripts.

See the release notes from v1.0.0 for the latest changes!

- C++
Published by patrikhuber over 7 years ago

eos-py - v1.0.0

The API and functionality of eos have been quite stable for a while now and proven themselves robust and useful. This release mainly constitutes the exciting bump to v1.0!

One major recent addition is support for the 4D Face Model, 4DFM, a full-head 3D morphable face model with 36 expressions/action units, from 4dface.io.

     

The update also includes the most recent version of pybind11, and addition of sample_to_mesh() to the Python bindings.

Other recent changes & improvements include supporting uv coordinates with seams, support for landmark/vertex definitions in the MorphableModel class to give certain vertices a fixed semantic meaning, and lots of other things. See the release notes from v0.17.0 and v0.18.0 for more details.

- C++
Published by patrikhuber over 7 years ago

eos-py - v0.18.0

This release adds support for texture maps with seams. When a texture map contains seams, the vertices at the seams are usually duplicated, and then some of the triangle indices are different in uv space from the triangulation of the 3D vertices. This change allows to support the texture coordinates of the full-head 4D Face Model (4DFM).

• The MorphableModel file format version was increased to 4 to store an additional member containing the uv triangulation (85cc563afe7e1916fa98d577c5b036cb622c8806)
• Updated extract_texture to support uv coordinates with seams (a70ded3d3c7644b54fd97878183d7b5c46323624)

Other minor changes: * Made the return type of gettexturecoordinates const ref (3a25d5278f131b72fc1f91c5009f4684a2dcf97f)

Please also have a look at the changes in v0.17.0.

- C++
Published by patrikhuber over 7 years ago

eos-py - v0.17.0

This is a release with quite a few nice changes and improvements. Please read through the release notes carefully. This release was in the devel branch for a few months, and never actually left the devel branch. The MorphableModel format version was increased to 3, from adding landmark_definitions. Since there are quite a few model files with this version in circulation, it was deemed best to make it an "official" model version and release it as v0.17.0.

Major changes & improvements: * Added (optional) landmark definitions to the MorphableModel class (8fcc2bfa4f73d1d49388e2b72f99fc2e8c57d2a4) Models can now optionally store landmark/vertex definitions, for example mappings like "eye.right.outer_corner" <=> 177 from a generic name to vertex ids - and then a second mappings file can be used, that maps from 2D landmark identifiers (like the number 37 from ibug) to these generic names ("eye.right.outer_corner"). This separates the vertex definition from a particular set of 2D landmarks. Alternatively, users can still use direct mappings, like in the file ibug_to_sfm.txt, which map directly from 2D landmark identifiers to 3D vertex indices. * Added a getter to MorphableModel for landmark_definitions (e995b07821038567284bf02202feb6021289d1e0) * Set the vertex_idx in the fitting depending on whether the model contains landmark definitions (f123e518c3a85bb5deaf9d17e7c11931ede9225a) * Revamped the Image class to a better and more future-proof design (14b7f6f6d998bb30de3f2047fa7f6af374786f3c) Note: The storage order is now row-major, as opposed to col-major before. In the future, we may add means to choose the storage order. * Added natvis file for Image Watch for eos::core::Image (be436f4d99406cfb62addabcc45303a7aa780a66)

Fixes: * Fix mpark::variant compilation error on VS >=15.8; Updated pybind11 submodule to fix errors on VS 15.8 (a45a888bbf29b251f2bd472d13a06208387e6a8b, ecc626946da2cbea42623759ff09dec6ef9eba34)

Minor improvements, potentially breaking changes: * Renamed get_all_mappings() to get_mappings() (9e0f539652e28a8b461bde9a53a202c471b04677) * Created new directory eos/core/image/ and moved Image_opencv_interop.hpp there (ad06db1b9e85319e8bddbca67b52f248b4dda331) * Return triangle_list by const reference (a7ede7bfca5cc1929b43d629dc90db7c5c3ae14d) * Exposed a few more things to the Python bindings, particularly landmark-mappings related, and added some __repr__ methods. * Removed the unused initial_rendering_params parameter from fitshapeand_pose (ba46285497485c1ab8f0f80722e8c09eb8b26e43)

Other minor changes/improvements: * Exposed some parameters of the contour fitting to callers (54ade09b95c2680d2393d4020604c569189b8a1e, abb2dd7b29944490cbffe92f77b3a5843c8bd990, 3929d0cffd004d1bfae29cde43b9f48e2f35067f) * Improved read_obj a bit to handle a few more cases. Still, don't rely on it to parse every .obj file, it's not meant to do that. Use your own or assimp or something like that.

And as always, various small improvements to the code style and to the documentation.

- C++
Published by patrikhuber over 7 years ago

eos-py - v0.16.1

A few minor updates and fixes:

Fixes: * Added missing inline to draw_sample (a6900a2) * Fixed constructing a 4x4 rotation matrix R instead of 3x3 in the Python bindings of ScaledOrthoProjectionParameters (5863f3b)

Updates: * Moved render::Rect to core namespace * Added Python bindings for eos::core::Rect and eos::core::Landmark<Eigen::Vector2f>. The Python bindings are now using Landmark and LandmarkCollection natively, without having to keep a separate list of landmark identifiers. * Added README.md as long_description for PyPI (link) * Minor README.me/initial_cache.cmake.template updates

- C++
Published by patrikhuber about 8 years ago

eos-py - v0.16.0

This is a major release, bringing full support for expression PCA models. MorphableModels can now either contain no expression model, a set of blendshapes, or a PCA expression model. The fit_shape_and_pose supports both as well, and calls either the _linear or _nnls solver, depending on whether a model contains blendshapes or an expression PCA model.

The main changes that go along with that: * Updated the MorphableModel file format to version to 2 to include an optional expression model. Version 1 models can still be read. * Added a flag ExpressionModelType to MorphableModel to easily query the type of the expression model.

Note: The behaviour of MorphableModel::get_mean() has been changed: It now returns the overall shape and expression mean. (see #188)

Other small additions: * Updated the BFM2017 converter script to convert and save the expression PCA model too. * Added a fitting function for fixed, given correspondences, that runs the fitting loop without contour fitting. (see here) * The online doxygen documentation has been updated to v0.16.0.

As always, when updating from the GitHub repository, make sure to run git submodule update --init --recursive.

The binary files are provided for convenience only - it is recommended to build the examples from source, and use the library by cloning the GitHub repository.

Windows binaries are compiled with Windows 10 64bit, Visual Studio 2017. A .whl with python bindings for python 3.6 is available on PyPI. Linux binaries are compiled with Linux Mint 18.3, based on Ubuntu 16.04, gcc-7. Make sure to follow the instructions for how to use gcc-7 with pip if using the Python bindings on Linux.

- C++
Published by patrikhuber about 8 years ago

eos-py - v0.15.1

This release improves a few crucial things over the last release.

Support for pre-C++17 compilers should be a lot better again - eos compiles again in C++14 mode on VS 2017, and, although not officially tested in CI, likely also compiles again with the likes of g++-5: * eos now seemlessly uses akrzemi1::optional on all pre-C++17 compilers, not only on Apple platforms. * Serialisation for optional also works correctly on all platforms (pre-C++17 and C++17 compilers); and updated cereal to the latest develop branch commit. * optional now also works within the python bindings for pre-C++17 and C++17 compilers. * Added eos::cpp17::clamp, which uses std::clamp on C++17 compilers, or a fallback otherwise.

Matlab bindings: * Updated the eos-matlab-fitting bindings! They now work again in the latest version to use the fitting from Matlab. * Disabled the eos-matlab-render bindings for now, as they would be more work to update. Having the fitting bindings back should suffice for most use cases.

Other small things: * A few small improvements to the main CMakeLists.txt (86fbfa17cf73892196ac6f95b48ba2b67b8f66a6). * Fixed a missing inline, missing include, added a few consts, a couple documentation updates.

- C++
Published by patrikhuber about 8 years ago

eos-py - v0.15.0

eos is now fully working on Apple Xcode again and CI-tested with Xcode 9.2.

Main changes:

• Use of eos::cpp17::optional throughout the code base, to support platforms that do not have <optional> yet (currently only macOS - #ifdef __APPLE__). It is a namespace alias, and will be resolved to std::optional on compilers that have <optional>.
• akrzemi1/Optional is directly integrated into eos and used on macOS
• Added official eigen-git-mirror as submodule at tag 3.3.4, instead of the patrikhuber/eigen fork
• Updated Keyframe-related code to work again with the latest eos version
• Minor other improvements and updates (see https://github.com/patrikhuber/eos/compare/v0.14.0...v0.15.0 for all the details)

- C++
Published by patrikhuber about 8 years ago

eos-py - v0.14.0

This is an update release with various small improvements throughout and two highlights: One major highlight is proper (and tested) support for the BFM2009 (and partially the BFM2017). Another highlight is that the multi_image_fit_devel branch is finally merged into master, and multi-frame fitting is thus now available in the main version.

The changes include, alongside other minor changes:

• Merged multi-frame fitting from multi_image_fit_devel branch. Thank you very much @PhilippKopp for the contribution!
• Added new (and correct) script to convert the BFM2009
• Added script to convert the BFM2017
• Updated syntax of the ibugtobfm*.txt files to TOML
• Add Python and Matlab scripts to generate edge-topology files
• Updated wiki with all BFM info & files (link)
• Clamping the colours to [0, 1] in sample_to_mesh
• Check find_if result for std::end in get_nearest_contour_correspondences to avoid continuing in Release builds without any error message
• Added lots of const qualifiers where possible
• Ran clang-format on the whole codebase
• Added some minor useful things to the Python bindings (e.g. default c'tors for Mesh and Blendshape)
• Updated Ceres code and example to work with the recent eos changes

- C++
Published by patrikhuber over 8 years ago

eos-py - v0.13.0

This release contains some major changes, mainly to the software-side of the library, and not to the algorithms.

• The library is now completely free of external dependencies, it does not depend on Boost and OpenCV anymore. All dependencies are header-only and included as submodules.
• The minimum required compilers are gcc-7, clang-5 and VS2017 Update 3.
• Changed the configuration file format from the custom boost::property_tree format to TOML. This mainly affects share/ibugtosfm.txt.

All in all, these changes make using the library much easier, and they should especially enable installation of the python bindings via pip install eos-py on any system, given >=cmake-3.8.2 and a recent compiler.

The changes, alongside other minor changes, include:

• Replacing all OpenCV vector types with Eigen::Vector
• Replacing glm types in the Python bindings with Eigen types
• Changed the pose fitting from OpenCV to Eigen - this could potentially be a bit of a speed-up
• Added own Image class (very basic, just covering the barebones needed to replace cv::Mat and to represent images). There is a converter function to and from cv::Mat (eos/core/Imageopencvinterop.hpp))
• Added functions to load and save PCA models (6c31092)
• Added ibug to BFM landmark mappings (5dbff1e)
• Updated all submodules to their newest versions
• Many more small fixes and improvements (documentation fixes, added 'const' in many places, etc.)

- C++
Published by patrikhuber over 8 years ago

eos-py - v0.12.2

This is a minor release, mainly adding functionality to build PCA models (include/eos/pca/pca.hpp).

This will be the last version that supports gcc-5, clang-3.x, and VS2015. The next release will require >=gcc-7, >=clang-5 and >=VS2017U3.

Other minor changes:

• Fix for texture mapping into destination image https://github.com/patrikhuber/eos/commit/6875e08b6678046e9c04fc5860383f39d22edd4f
• Fixed some missing inlines, added lots of const, improved documentation, updates of submodules
• gcc-4.9 support removed

- C++
Published by patrikhuber over 8 years ago

eos-py - v0.12.1

This update brings a major speed-up of the shape and blendshape fitting. Depending on the setup (model resolution used, number of coefficients fitted), the speed-up is around 3x to 50x - typically around 10x. The shape and blendshape fitting now take only around or below 1ms per iteration (previously ~10ms). This was achieved by changing all linear algebra operations from OpenCV to Eigen.

Please see also the release notes of v0.12.0 below for the latest changes and updates, some of them breaking changes. See also the release notes of v0.12.0 for information on the PyPi package (eos-py) and the provided binaries.

- C++
Published by patrikhuber about 9 years ago

eos-py - v0.12.0

This is mainly a maintenance release but contains quite a number of improvements. There are some breaking changes in this release and models have to be re-downloaded in the new format.

Major changes:

• Changed PcaModel, MorphableModel and blendshapes to use Eigen for matrices and vectors instead of OpenCV's cv::Mat. This change was motivated by the fact that we need Eigen already anyway for solving linear systems. And since Eigen is a header-only library, the core of eos becomes more independent of OpenCV and easier to compile in the near future. This change means that the model format has changed as well, so users will have to re-download the models and blendshapes in the new model format.
• Changed PcaModel constructor to take an orthonormal basis (4662c59c4d9ae233047d1b5130470db1ed6bf894) This introduces a breaking change: If you're currently using the PcaModel constructor and are passing it a PCA basis matrix, your code will (probably silently) break: The function now expects an orthonormal basis matrix, whereas before, it expected a rescaled basis matrix. However it makes more sense for the function to take an orthonormal basis matrix, as this is usually the result after computing a PCA on data.
• Furthermore, "unnormalised" basis has been renamed to "orthonormal", and "normalised" basis to "rescaled", and the getters have been modified accordingly. This should clear up confusion and make the descriptions good and unambiguous ("normalised" and "unnormalised" was really not a good choice!). (0fdd8a126e82f653001452e88bf1d34210a9ba36)

Minor changes:

• Updated all apps and utilities to reflect all the changes in this release
• We now only store the orthonormal basis in the model files - the rescaled basis is computed when models are loaded. This halves the file size of all models. (50c059c3ff8ced6057e3a7aa15fc5943467c19df)
• Renamed get_*_pca_basis(int) to get_*_pca_basis_at_point(int) (354deb3e962dce0e7dab7b20f1d4c5886a06e103)
• The mean, basis and eigenvalues of PcaModel are now returned by const reference (8901c1141af0217f64b509378f9effc9e8febc23)
• Added a setup.py file for python's pip: This means eos's python bindings can now be built and installed with pip install ./eos, and packages can be created with python setup.py sdist and python setup.py bdist_wheel. A setup.cfg.template exists to set library paths to OpenCV and Boost.
• Added various python bindings: writeobj, savemodel, functionality to construct new models, draw_sample, and more
• Added Eigen as git submodule. This was required because Ubuntu 14.04 only ships with Eigen 3.2.2, while pybind11's new Eigen bindings requires at least 3.2.7. This way, we're also more independent with regards to Python's sdist package. An external Eigen can still be used by setting EIGEN3_INCLUDE_DIR.
• Added cereal as submodule, removed local copy (f38ac6237e9dc372aea69d6aa43baf8f10507600)
• Added better warnings and errors as to the use of fit-model-ceres
• Minor documentation fixes and improvements.

eos python bindings are now available on PyPI! There's a wheel for python 3.5 on Windows, and a source dist. The source dist needs CMake's find_package to be able to find OpenCV and Boost automatically for it to work (so install it beforehand from a package manager). If there are issues, you can always clone the repo and do pip install ./eos locally, after adjusting the paths in setup.cfg.

As always, make sure to clone the repository with git clone --recursive, or, if you're updating, run git submodule update --init --recursive.

Windows binaries are compiled with Windows 8.1 64bit, Visual Studio 2015. A .whl with python bindings for python 3.5 is available on PyPI. The Matlab bindings are created for Matlab R2016b. Linux binaries are compiled with Linux Mint 18, based on Ubuntu 16.04, gcc-5.4.

- C++
Published by patrikhuber about 9 years ago

eos-py - v0.11.1

A very small release with very minor updates.

• The BFM Matlab to binary conversion script is now much faster, thanks to @NextDesign1
• A fix that makes eos compile on clang 3.9.1 on OS X from macports, thanks @NextDesign1!
• Minor updates and clarifications in readme's

This is the last release to support the current model format. eos is switching to Eigen for the PcaModel and MorphableModel classes, which will require users to re-download the models in the new format. The changes are already done in the devel branch and will be included in the next official release.

- C++
Published by patrikhuber about 9 years ago

eos-py - v0.11.0

This release contains a major modernisation of the CMake scripts. Most of it now follows a target-based approach. The release also contains improvements to the Python and Matlab bindings. No changes to the fitting algorithm(s) in this release.

Noteworthy changes: - Major CMake modernisation (and thank you to @ruslo for the PRs!) - gcc-4.9 and CMake 3.1.3 are the new minimum required versions - More Python and Matlab bindings, improvements of the bindings and the documentation - Added a .clang-format file - please more or less stick to the style in there for new contributions. Most notably, we switched from tabs to 4 spaces, as it improves readability on GitHub - Moved Mesh to core namespace (this may break current code, but is easily fixed) - All CMake options are now prefixed with EOS_, you may need to update your configuration (e.g. BUILD_EXAMPLES => EOS_BUILD_EXAMPLES).

The software renderer also got refactored into classes, with a more dynamic approach for vertex and pixel shaders, and rasterising, following the OpenGL paradigm. The code of the core renderer is exactly the same. The new code is very much experimental, I suggest sticking to the existing rendering functions, which are still there and work as before.

As before, make sure to clone the repository with git clone --recursive, or, if you're updating, run git submodule update --init --recursive.

Windows binaries are compiled with Windows 8.1 64bit, Visual Studio 2015. The bindings are created for Python 3.5 and Matlab R2016b. Linux binaries are compiled with Linux Mint 18, based on Ubuntu 16.04, gcc-5.4.

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.10.1

Minor improvements of the project infrastructure: The INSTALL target copies less 3rd-party files (only the headers now), python bindings are now in a separate directory, and the python bindings are being built on travis and AppVeyor.

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.10.0

Added Matlab bindings for the fitting function fit_shape_and_pose(...), which means the fitting can be run from Matlab. It returns a mesh and rendering_parameters (pose). A demo script (demo.m) is included - see the Matlab bindings section of the README.md for more details.

Set GENERATE_MATLAB_BINDINGS in CMake to build the mex file and run the INSTALL target to install everything. CMake-3.7 is required to build the bindings.

So far, only bindings for this one fitting function exists, but it's one of the key functionalities of eos. The model and needed files have to be given as filenames, which means they have to be loaded each time you call the fit_shape_and_pose(...) function. It works quite fast but is therefore not fast enough for real-time scenarios.

Another small limitation is that it currently only works with ibug landmarks, and only if all 68 of them are present. This limitation might be lifted in the future.

More bindings (e.g. for the MorphableModel itself) might be added in the future.

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.9.1

This minor release brings a large speed-up of the shape-fitting, along with a couple other small improvements. - Speed up computation of Omega in shape fitting (e2809f13d163c3fd4b4e325a09cfd96a3a9d1153) - Moved sampletomesh out of the ::detail namespace (da0a240804ef779985155f70a2bdd9592b5b5036) - Fixed bug that the given numshapecoefficientstofit was not forwarded to the shape-fitting function (42d1f43c17de4c79859b2f5291d45b80289df042)

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.9.0

This release contains edge fitting as the main addition - this is a major improvement in the fitting quality. - Added edge fitting from [1] - Using the edge fitting to fit the contour landmarks in the fit-model app - Major rework of the fit-model example app: It now uses blendshapes, the new contour fitting, and iterates the different fitting stages, resulting in a major improvement in fitting quality - Added a single function to the library that iteratively fits pose, shape and blendshapes

[1]: A. Bas, W.A.P. Smith, T. Bolkart and S. Wuhrer, "Fitting a 3D Morphable Model to Edges: A Comparison Between Hard and Soft Correspondences", In Proc. ACCV 2016 Workshops, 2016.

Minor improvements/fixes: - Started a wiki and put some example fitting results: https://github.com/patrikhuber/eos/wiki - Added non-negative least squares blendshape fitting function - Renamed the old fit-model app to fit-model-simple: it shows simple pose and shape fitting, without blendshapes or contour-fitting - Fix: Added inline to all functions. No ODR violations anymore if the library is used from multiple translation units - Added travis and AppVeyor CI

As before, make sure to clone the repository with git clone --recursive, or, if you're updating, run git submodule update --init --recursive.

Again there's some precompiled binaries and python bindings available. No guarantees that they'll work on many other systems though. The Python bindings are the same as in eos v0.8.0, no new additions yet.

Windows binaries are compiled for Windows 8.1 64bit, Visual Studio 2015. Linux binaries are compiled for Linux Mint 18, based on Ubuntu 16.04, gcc-5.4.

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.8.0

A major release with many new features and some minor fixes and improvements! - Linear scaled orthographic projection camera estimate. Faster and more stable than the nonlinear and affine algorithms. fit-model uses this as new default. - Python bindings for parts of the library! - Experimental: Ceres cost functions. A landmark-fitting cost function (fitting shape, expressions and pose) and an image error cost function (the latter one requires acquiring the albedo model from CVSSP). Set -DBUILD_CERES_EXAMPLE to build an example app.

Minor improvements/fixes: - Faster converter script and app for the BFM (now using binary files) - The Mesh type and most of the rendering now uses glm types instead of cv::Vec's - Cleaned up RenderingParameters, it now stores the rotation as a quaternion. Its documentation needs to be improved. - Changed PcaModel getters to return references - Lots of other small improvements and fixes!

Make sure to clone the repository with git clone --recursive, or, if you're updating, run git submodule update --init!

Also there's some precompiled binaries and python bindings available. No guarantees that they'll work on many other systems though. Python bindings are for python-3.5. If you want python-2.7, you need to compile them by yourself.

Windows binaries are compiled for Windows 8.1 64bit, Visual Studio 2015. Linux binaries are compiled for Linux Mint 18, based on Ubuntu 16.04, gcc-5.4.

- C++
Published by patrikhuber over 9 years ago

eos-py - v0.7.1

A few minor updates: - Changed the expression blendshape names slightly to match to Ekman's terminology: anger, disgust, fear, happiness, sadness and surprise - Added a Matlab script to convert the Basel Face Model (BFM) to json (experimental! very slow (takes >1 hour) and results in a >1 GB file) - Added an app to convert a json model to a cereal binary model - Added numcoefficientstofit parameter to fitshape functions - Added an app to generate random samples from the model

- C++
Published by patrikhuber almost 10 years ago

eos-py - v0.7.0

A major release with many new features and some minor fixes and improvements: - Added expression blendshapes for the shape model, containing the 6 expressions angry, disgust, fear, happy, sad and surprised (77f6b8dcc71d2bf1d07dafa384bf36c6cb6a0d54) - Implemented a linear blendshape fitting to fit these blendshapes to landmarks. One very notable improvement is that it allows the model to open the mouth. - Added a function that alternates between PCA shape coefficient fitting and blendshape fitting until convergence (245d8e8785ba722b71514a472b1c39a802cc4a8c) - Added a simple contour fitting that fits the front-facing contour landmarks to the model. This results in much better correspondence.

Minor improvements/fixes: - Added 2D-3D mappings for all 68 ibug landmarks (597aa2967f0cf6051b5d4ec3dfe32d484554639d) - Replaced inv() with solve() in the linear shape and blendshape fitting (b8c5f99a158ed3e7f18b680439155ee935d43b80) - Implemented a workaround to make the small black line in the isomap disappear (see #4)

Note 1: The contour-landmarks fitting in contourcorrespondence.hpp is a bit beta-quality and doesn't contain all necessary safety checks; for example, if given wrong correspondences, it may crash._

Note 2: I initially wanted to tidy up a few more things before officially tagging this, but it has been on GitHub for so long now and people are using it, so that we'll just make this v0.7.0.

- C++
Published by patrikhuber about 10 years ago

eos-py - v0.6.1

Minor fixes, code improvements and a lot of documentation updates.

Noteworthy changes: - Added vertex symmetry list of the reference model (c3cb3c7) - Fixed wrong filename when storing a textured obj with a relative path (4bc9917)

- C++
Published by patrikhuber over 10 years ago

eos-py - v0.6.0

A major release, containing a new pose estimation algorithm, view-dependent texture extraction and a lot more minor improvements.

Highlights: - Added a nonlinear camera estimation algorithm that directly estimates OpenGL-like rendering parameters (pose rotation, translation, camera frustum) - A small OpenGL-like software-rendering function to render the model and textures - Added the glm library headers for all OpenGL operations - Parallelised the texture extraction using std::async - The texture extraction computes and outputs the view-angle for each triangle - The MorphableModel .bin files are now versionised (current version: 0) - Minor fixes, added assert()'s, documentation improvements

Contributors: - @patrikhuber - @MichaelGrupp (OpenCV 3.0 compatibility)

- C++
Published by patrikhuber almost 11 years ago

eos-py - v0.5.0

This is a milestone release and the first version that's ready to be released to the public.

Highlights: - fully header-only, neat, simple & modern C++ code & doxygen documentation - affine camera pose fitting - shape-to-landmarks fitting - isomap extraction - includes our public shape-only 3D Morphable Face model - example application (fit-model.cpp)

Contributors: - @patrikhuber - @PhilippKopp - A handful of people from the Centre for Vision, Speech & Signal Processing that created and previously worked on the 3D face model

- C++
Published by patrikhuber almost 11 years ago