Skip to content

Google Summer of Code 2022 (GSOC2022)

Jump to bottom
Serge Koudoro edited this page Feb 12, 2022 · 14 revisions

Introduction to FURY

FURY is a free and open source software library for scientific visualization and 3D animations. FURY contains many tools for visualizing a series of scientific data including graph and imaging data. FURY is participating in GSoC this year for the first time under the umbrella of the Python Software Foundation (PSF).

How to become a part of FURY's Google Summer of Code 2022

GSoC is a program that allows everyone (students, professional, academic, etc...) to learn contributing to an open-source project while receiving a fellowship from Google, and mentorship from open-source software developers. For details about this year's GSoC, please refer to this page.

Before considering becoming part of the FURY GSoC, please read about our expectations.

All participants should have basic knowledge of computer graphics, scientific computing, and development in Python. For a comprehensive introduction to these topics, please refer to these 2 books:

However, you should be already familiar with data analysis using Python and Numpy before applying.

Be happy to ask questions directly by choosing one of the following options:

Getting Started

Potential candidates should follow all these steps before applying for the GSoC:

  1. Take a look at the guidelines on how to contribute to FURY.
  2. Go through the tutorials and examples on the website, make sure you're familiar with the library.
  3. Run the tests. FURY has unit tests that are at about 90% coverage (amount of lines of code tested). Make sure you know how to run them, and if you've never done Python unit tests before you might want to read up on Pytest library.
  4. Figure out how to run a single test! Running one test instead of all of them will speed up your workflow when you are writing your tests! (hint, it's in the contributing docs!)
  5. Make your first contribution to FURY !!! Making a small enhancement/bugfix/documentation fix/etc to FURY is really important! It shows your understanding of the library and your Github knowledge. The fix does not need to be related to your proposal. We have and will continue adding some beginner-friendly issues in Github. You can see some of them here

This is a requirement from the PSF; it can help you get some idea of how things would work during the GSoC.

Project Ideas (5)

Notice: We want to provide the best mentoring to our students, only 2 or 3 of these projects will be selected. Not more!

If you have any questions or if you want to contact a mentor:

Project 1. GTLF Integration

Description:

glTF (GL Transmission Format) is a 3D file format that stores 3D model information in JSON format. The use of JSON minimizes both the size of 3D assets and the runtime processing needed to unpack and use those assets. It was adopted for the efficient transmission and loading of 3D scenes and models by applications. The file format specifications for glTF 2.0 are available online for reference. The candidate will be able to implement a smooth integration of this file format in FURY. The candidate will provide to the user an easy interaction with this file format to load/save/animate/replace effects and textures of the scene / 3D object. This is a great opportunity for candidates who are interested in the 3D models to become members and contributors to the FURY community.

Here are the different steps to achieve:

  • Step 1: Compare existing tools and understand the different GLTF standard
  • Step 2: Complete the full integration of GLTF
  • Step 3: add animated GLTF
  • Step 4: add tutorials and examples

Difficulty: Intermediate

Skills Required: Python, blender, 3D model

Time: Full Time

Potential Mentors: (Serge Koudoro, TBD)

Project 2. Keyframe animations in FURY

Description

Keyframe animation is a way to produce smooth animations by interpolating a scene based on a few key still states of objects. Such a technique have been used to quickly produce 2D and 3D animations of objects and to control the movement of the camera. It has also become popular in scripted game cutscenes and to produce simple animations for the web.

In this project, the student will develop a keyframe animation system for FURY. Such a system should have a public API with functionality to:

  • play, pause and rewind a timeline;
  • add and remove keyframes at a specific time for transformations of objects (or the camera) such as translation, scale, rotation, color, opacity, and other properties;
  • linear and non-linear (eg. spline-based) interpolation;
  • rotation interpolation based on quarternions and SLERP

The proposed system must get its inspirations from the web-animations API.

Expected steps for the project:

  • Step 1: Understand how FURY works
  • Step 2: Implement a basic timeline of events and keyframes, initially with linear interpolation
  • Step 3: Implement the capabilities to play, pause and rewind the timeline
  • Step 4: Allow the creation and removal of actors from the scene according to the keyframes
  • Step 5: Implement non-linear interpolations, such as splines, bezier curves and/or ease-in/ease-out time transforms
  • Step 6: Implement quaternion-based interpolation (SLERP)
  • Step 7: Allow camera to be interpolated by the keyframe system
  • Step 8: Tune the implementation for speed, preferentially using GLSL languate.
  • Step 9 (Optional): Allow the definition (and visualization) of motion paths, such as those available in 3D editing tools (e.g., After Effects and Cinema4D)

Along the development process, the student will produce tests and documentation for the resulting code and API.

Difficulty: Medium-Advanced

Time: fulltime project

Skills Required: Python, FURY, Shader Language (preferentially: GLSL)

Potential Mentors: Filipi N. Silva, TBD

Related references and links:

Web-animation:

After-effects interpolations:

Implementing keyframe animations partially in shaders:

Example keyframe animation:

SLERP:

Clone this wiki locally