This section details my education to give the reader a better knowledge about the courses I followed and particularities of my academic background.

The reader can find here my master thesis in computer science.

I am graduate from a Master's degree in computer science with major in imagery, Summa cum laude (17.289 / 20) at the University Paris-Est Marne-La-Vallée in 2019.

We have to choose a major in second year, first year is common with the different possible majors.

In first year, I studied:

- advanced software development (java 9, python 3, C++ 14), including concurrent multi-thread programming, design patterns, real time programming.
- imagery (computer graphics and image processing).
- databases and networks (network architecture and programming).
- theory (problems' complexity, linear optimization, cryptography, data compression and combinatorics).

Then in the second year specialized in imagery I followed :

- computer graphics and virtual reality (OpenGL 3, GLSL).
- discrete geometry manipulation (curvature flow on curves and meshes, discrete topology, animation and simulation).
- computer vision and machine learning (statistical learning, neural networks, gradient descent).
- signal processing and image restoration.

I completed a "Licence" program in computer science at the University Paris-Est Marne-La-Vallée in 2017, Summa cum laude (17.714/20).

In this program, I studied :

- system programming (C language), object-oriented programming (java 8), functional programming (Caml).
- data structures (tree algorithmic, graph theory, hash tables).
- language theory (automaton, syntax analysis, compiling).
- mathematics for computer science (arithmetic, combinatorics, logic).

I completed a "Licence" degree in mathematics from the University Paris-Est Marne-La-Vallée in 2018, Magna cum laude (14.85/20).

In France, courses are often mandatory and follow a given program (sometimes with few options). Here, there were 3 semesters common with mathematics and with computer science and then the 3 last semesters gives a student a full "Licence" degree (undergraduate - bachelor's degree equivalent in 3 years at university). In this case I had the special opportunity to be allowed to follow courses from the mathematical program for the 3 last semester, being present as much as possible on my free time according to the compute science schedule and passed the exams like every student in the math program.

The courses given by this degree completed my skills in:

- numerical solving methods (zero solving, integration numerical approximation, pseudo-random generators) and matrix computation (matrix decomposition).
- geometry (euclidean, affine, projective) and algebra (groups, arithmetic, number theory).
- topology and analysis (differentiation, complex analysis, hilbertian analysis).
- integration, probabilities and statistics.

The first 3 common semesters (passed with 17.09 / 20) of my program were common to both mathematics and computer science program and then split. In January 2016, I initially choose the computer science program. Then in January 2017, I started the mathematics program on my free time while keeping computer science as my main program.

In this common part, I learned the basics in:

- computer science : algorithmic, recursions, complexity, database with python 3, C, PHP and SQL programming languages.
- mathematics : calculus, linear algebra, analysis, logic, probabilities.

Febuary 14, 2020 - Febuary 21, 2020

Keywords:

- 3D
- animation
- C++
- implicit surfaces
- Qt
- Radium Engine
- research

Paul G. Kry invited me to participate to the Bellairs research institute animation workshop in Barbados. The workshop this year was a hackathon like where we had to determine if projects were feasible.

I worked on the "Time-based anisotropic blending" as the developer of the prototype in C++ under Radium Engine using private plugins provided by the STORM team (IRIT).

One limitation of implicit surfaces' work is than it does not offer a lot of control to compose two surfaces. Particularly, previous work does not allow to transform a sphere into a droplet while composed with a plane (we miss a direction information and a way to tell the operator to compose as an union for one side and as a blending for an other).

During this week, we :

- arrived at a proof of concept.
- illustrate the validity of our method on examples (droplet, wave, ferromagnetism, spiral composition).
- proposed automatic and user-based methods.

Keywords:

- 3D
- animation
- C++
- cages
- contacts
- deformation
- implicit skinning
- implicit surfaces
- inverse position
- meshes
- Qt
- Radium Engine
- research

(November 2019 - December 2019 : 3 weeks full-time on site and working remotely since October 2019)

Waiting for a visa to start a Ph.D, Brian Wyvill offers me the possibility to come to the University of Victoria (BC, Canada) and continue the development of the work started with Loïc Barthe and Paul G. Kry.

To extend the previous work, I :

- showed that the method can be generalized to more deformation types : skeletal-based, point-based.
- optimized the update time when deforming (assertion on the structure of the space cover) and improvement of results' quality (optimization of time allow a significant increase of the sampling grid and makes spline approximation relevant where spline interpolation keeps being a limitation).
- set the main limitation about the method which is due to the local overlaps of the space and its discontinuities.
- started to study the method on concrete models (elephant's trump, arm of an octopus).
- proposed a space covering with adaptive refinement with respect to a target iso-surface in a scalar field.

During my experience and my supervised academic projects, I was appreciate for my autonomy but also for the relevancy and the originality of my results.

I give keywords to help the reader having a better idea about the technologies and concepts I worked on during my work experience.

Keywords:

- 3D
- animation
- automation of computations
- C++
- CADO-NFS
- cages
- contacts
- cryptanalysis
- deformation
- discrete logarithm
- finite fields
- implicit skinning
- implicit surfaces
- inverse position
- mathematics
- meshes
- number field sieve
- parameter setting
- Python 3
- Qt
- Radium Engine
- research
- teaching

Keywords:

- 3D
- animation
- C++
- cages
- contacts
- deformation
- implicit skinning
- implicit surfaces
- inverse position
- meshes
- Python 3
- Qt
- Radium Engine
- research

(April 2019 - September 2019 : 6 months full-time as my graduation internship)

Implicit skinning propose the automatic correction of folds and preserve volume at joint while deforming a 3D character with an animation skeleton. However, a limitation of this method is that it keeps being rigid transforms of primitives (implicit surfaces) and does not allow free deformation of the mesh (shapekey like, sculpting muscle bulge).

Under the initial supervision of Loïc Barthe and Pascal Romon, my job was to find a method allowing the animation of an implicit primitive using a cage-based deformation.

To solve this problem, I :

- studied state of the art on free form deformations using a 2D prototype in Java implemented under Processing IDE.
- prototyped the 3D methods in C++ under Radium-Engine with an UI with Qt.
- followed the track of the inverse position solving and proposed a software architecture to answer this problem.
- proposed methods and analyzed their relevancy.

I first investigate methods based on direct solving of the inverse position problem with a weakness due to the computation time for the first one and lack of consistency of the field for the other. Then, I explored methods based on the approximation of the given space deformation using a regular grid. My work focused on improving the robustness of the scalar field deformation (spline reconstruction for better continuity, space region detection using tetrahedral cut). With this methods, I started looking at solving self-intersection of the field with itself. This allow then to correct simple self-contacts of a mesh with itself using a desired effect by the chosen composition operator.

Here is an arm like example with muscle grow where we can add an automatic bulging effect at the contact:

For this work, we gave me the mark of 20 / 20.

For more details and explanations, I invite the reader to study my master thesis (in French, but feel free to contact me if interested and motivate me to write an english version) :

Also slides for my master thesis defense (animations are working under Okular and are fluent are a first reading of all the slides) :

Slides of the scientific presentation :

- en Juin 2019 : TRANCHO_presentation_june_21_2019.pdf
- updated in July 2019 : TRANCHO_presentation_july_08_2019.pdf

Keywords:

- automation of computations
- CADO-NFS
- cryptanalysis
- discrete logarithm
- finite fields
- number field sieve
- parameter setting
- Python 3
- research

(May 2018 - August 2018 : 4 months full-time as a master research internship)

CADO-NFS allow to check the robustness of public key cryptographic systems against mathematical-based attacks when this is based on factoring or discrete logarithm solving in finite fields.

At first CADO-NFS was designed to achieve record on the size of the finite fields to break. Pierrick Gaudry gave me the task to find a method to get a relevant parameter set for CADO-NFS on little size prime finite fields (attacks from an individual's workstation) and reduce as much as possible the range where CADO-NFS is better than concurrent softwares.

During this experience, I:

- understood the general functionalities of CADO-NFS for discrete logarithm solving, its parameters and their task in the pipeline.
- developed scripts (Python 3) for the parsing of results and automation of sub-processes of CADO-NFS to try hypothesis on parameters' configuration on remote machines.
- by a huge number of trials and examples, I reported relevant bugs in CADO-NFS.
- showed that CADO-NFS beats concurrent softwares for Sophie-Germain prime finite fields (worst case) starting from size with 40 digits.

My contribution, parameters sets for prime finite field of size between 30 and 100 digits had been added to CADO-NFS (commits c77fe4b3b5f2 and 1cd07513de565).

For this work, I was given the mark of 19 / 20.

Fun fact related to this subject : Pierrick Gaudry illustrated type of concrete application of CADO-NFS on small size prime finite field : he showed how to break Moscow internet voting system for elections while using prime finite fields of size 256 bits (77 digits), he details to break the encryption scheme here.

I invite the reader to study my work in the following document :

Defense slides :

Slides of scientific presentation given to CARAMBA team :

Keywords:

- teaching
- mathematics

(September 2017 : 18 hours of training)

As soon as students come at the University Paris-Est Marne-La-Vallée, they have to participate to two weeks of preparation in mathematics. Objective is to make the bridge between topics studied at high school and push these to be ready for courses given at the university.

I handled two groups of 13 students each and trained them on the following topics:

- complex numbers.
- algebraic real and complex calculus (polynomials, inequalities).
- study of functions (limits, function's graph).
- study of sequences (recursive sequences).
- integration (Riemann integration, initiation to integration by parts).
- geometry (complex plane, line equation in plane and space).

These projects were developed for an academic purpose to run over Linux.
(To try them, the read would have to install SDL 1.2, MLV, OpenGL, libg3x : given, Processing IDE).

Keywords:

- 2D
- 3D
- animation
- animation skeleton
- automatic hitbox generation
- C
- C++
- character creation
- collisions detection
- computer controlled opponents
- correcting codes
- deformation
- discrete differential geometry
- factoring of polynomials
- finite fields
- GLSL
- image synthesis
- Java 8
- meshes
- morphing
- OpenGL 2
- OpenGL 3
- procedural generation by scripts
- processing IDE
- Python 3
- QR codes
- scene graph
- SDL

Keywords:

- 3D
- deformation
- discrete differential geometry
- Java 8
- meshes
- processing IDE

2019 : Master degree's second year

Here is a project made for the discrete differential geometry course, is implemented the mesh deformation using discrete curvature flows. The idea is to deform a mesh based on a characteristic like the curvature, the maximization of the volume or something else.

On application is noise / sharp features reduction in a mesh.

The project was made in Java 8 under Processing IDE (OpenGL's overlay). We propose the following :

- a software architecture to handle discrete curvature flows on surfaces (here a mesh).
- various flows, examples, parameters and data about the surface.

For more details, the reader is free to run projet.pde under Processing IDE and read the manual in this same file :

Some scientific documents related to the project :

- Mean curvature flow by the faces : 2019_TRANCHO_VEILLERETTE_document_geometrie_differentielle.pdf
- Face-driven flow experience : 2019_TRANCHO_VEILLERETTE_flots_par_faces.pdf

Keywords:

- 3D
- animation
- C++
- GLSL
- image synthesis
- OpenGL 3
- procedural generation by scripts
- scene graph

2019 : Master degree's second year

The objective of this project was to visualize a solar system. It is possible to define properties, add planets and generate an asteroid ring from a script system.

In C++, from a OpenGL 3 overlay, we propose :

- software architecture to split tasks related to rendering and the ones related to scene graph and geometry.
- solar system rendering using shaders (GLSL).
- procedural generation and to parameterize asteroids and planets.

My job in this project was the software architecture and the processing of geometry.

- Sources of the project : 2019_TRANCHO_VEILLERETTE_systeme_solaire.zip

Keywords:

- 2D
- deformation
- morphing
- Python 3

2019 : Master degree's second year

The purpose of this Python 3 project was to make the morphing of an image to an other using :

- covering two images using Delaunay triangulation to establish correspondence.
- linear interpolation of the colors using the triangles in both configurations.

- Sources of the project : 2019_TRANCHO_image_morphing.zip

Keywords:

- 3D
- animation
- C
- OpenGL 2
- procedural generation by scripts
- scene graph

2018 : Master degree's first year

In C language, we propose the visualization of a scene graph using combination of simple primitives (spheres, cylinders, torus and others).

A proposed script language is proposed to the user to build the scene, it means defining primitives, transforms, colors, animations, components schemes.

I was responsible of the scene graph and of setting up the script language for procedural generation of the scene.

To run the project, please install libg3x : given overlay of OpenGL.

- Sources of the project : 2018_TRANCHO_VEILLERETTE_graphe_scene.zip

Keywords:

- C
- correcting codes
- factoring of polynomials
- finite fields
- QR codes

2017 : Undergraduate's third year supervised project

With a personal interest for cryptography and stimulating lectures given in mathematics applied to computer science (arithmetic and combinatorics) given by Jean-Yves Thibon, I came to Marc Zipstein asking to work in crypto, Marc Zipstein and Jean-Yves Thibon then offered me the opportunity to work on correcting codes and to familiarize myself with finite field concept.

Implemented in C, I propose :

- to research irreducible polynomials in Z/
_{2Z}[X] (all the small ones using an Eratosthene sieve and larger ones using recursive factoring with the Berlekamp algorithm). - a calculator to handle computations in a finite field F
_{2q}isomorphic to F_{2}[X]/_{(P(X))}such as P is irreducible in F_{2}[X] and q is P's degree. - to code, decode and correct errors for BCH and Reed-Solomon codes.
- from the correction codes I have, it was possible to handle QR codes (can be checked with a standard software) for coding, decoding and correcting errors.

- Sources of the project : 2017_TRANCHO_codes_correcteurs.zip
- Document about project : TRANCHO_rapport_codes_correcteurs.pdf
- Defense slides : TRANCHO_presentation_code_correcteurs.pdf

Fun fact : Nintendo propose a challenge asking to factorize a polynomial in F

Keywords:

- 2D
- animation
- animation skeleton
- automatic hitbox generation
- C
- character creation
- collisions detection
- SDL

2017 : Undergraduate's third year supervised project

I came to Cyril Nicaud with my idea to create a mini-Blender in 2D and I thank him warmly for trusting me and for supporting me in this ambitious project.

The purpose was to create characters from nothing and being able to make them fight (we drew at the defense).

The project followed the given steps :

- a skeletal editor (hierarchic model of joints with rotation limit).
- a shape editor (modeling visible part by association of a tree of circles to each bone of the character).
- an animation editor (defining the rotation of the articulations and the global character's moving).
- automatic hitbox generation (model's refinement : circles and rectangles).
- automatic impact hit detection and interactive handling of character into a fighting game.

- Sources of the project : 2017_TRANCHO_personnages_articules.zip
- Document about the project : TRANCHO_personnages_articules.pdf
- Hitbox related complement : TRANCHO_hitbox.pdf

You can make your characters fight against each other !

You can edit your own characters for a better fight.

But you can also create your character from scratch.

Keywords:

- 2D
- animation
- C
- character creation
- SDL

2016 : Undergraduate's second year project

The purpose of the project was to make a combination game. However, I found fun to add a character and to propose the user to edit it (shape of the face, hairs, morphology, colors).

Note that this game run without image files (only procedural).

Fun fact : this project was honored by a Borie award, a cool distinction for a student project !

- Sources of the project : 2016_TRANCHO_VEILLERETTE_avatars.zip

Keywords:

- 2D
- C
- computer controlled opponents
- SDL

2016 : Undergraduate's second year

In C language, this classic snake have something more : you can play against other players and even against computers. The computer can have various given gameplays : one will collect the apples in the map, one will try to survive and an other will attack the other players to lock them somewhere !

A fun game has at least one AI with attack job !

- Sources of the project : 2016_TRANCHO_VEILLERETTE_snake.zip

Before having a real education in computer science, I was still able to create some cool games. Here are some which are interesting to share.

2015 October

What is best that create a pokemon like game to use my skills in both 2D art and programming ?
At this time, I didn't yet studied C and C++ at university, but creation does not wait.

As a player of Pokemaths is offered to :

- move on the map to interact with other characters and meet random opponents.
- create you own map to handle your characters.
- fight against character to improve yours, acquire skills and evolve.
- try an adventure, fight the masters and finally arrive to the final boss !
- there is also a chat, field management and other trials to simulate multiplayer at the university (but this is more related to hacking than anything else).

From the creator side, I have :

- a map editor (background, entities an others).
- scripts for the AI of the masters, entities handling : all the content can be edited using files.

Made to run with Linux using SDL 1.2.

Commands :

- Directional arrows -- move the current character.
- Right shift -- menu.
- Enter -- for interactions.
- Space -- to place a block.

Map editor : accessible using "edit" option

- Directional arrows -- move the cursor.
- Clic -- select the element to set (surroundings, background, interaction).
- Keypad 0, 2, 4, 5, 6, 8 -- to set the adjacency of the current tile.
- Keypad 0 -- to set the data related to current entity bloc.
- Keypad +/- -- alternatives for the tile.
- Space -- to place the tile.
- A -- to automatically solve adjacency of the tile in the map.
- F -- filling a region.
- Z -- automatic adjacency correction for tile and its neighborhood.
- Enter -- automatic tile placing on / off.
- Backspace -- get the tile under the cursor.
- Suppr -- hide surroundings.
- G -- go to coordindates you write in terminal.
- S -- save cursor position as your future position as a player.
- M -- goto an other map (input the number in the terminal).
- E -- set entity value for you as a player, in the terminal : [ID] [VALEUR] .

Entities are in the directory "ent" and have to be scripted (it can be interesting to contact me if you want to mod the game, I would be happy to help you).

Hacks:

- Roll the mouse wheel or spam a mouse button to automatically send an attack.
- Run several windows in the same time to train different characters and do massive recruitement.
- Close the window to ingore fights.
- Being happy anti-cheat is not in this version (Well, it would probably have banned you since you're reading this section) !
- Mod the game
- The most powerful hack : play to the game !

Known bugs:

- If you control a character, it exists in your map, try to avoid placing a block on its virtual position (to define this position, press Enter to free the character and then embody it).
- Compress the project using .zip : some of the files won't survive to extracting.

The project is not the original version (you don't have to be kevin to access everything and anti-cheat is removed) but it should work under your Linux with SDL:

- Sources of the project : 2015_TRANCHO_pokemaths.tar.gz

2012 April

Probably my first real game in C/C++ developed at the beginning of high school.
It is a puzzle game where first levels are here to warm you up and then the real game
starts !

The objective is to get the diamond without being captured by blue bears and if you can
collect a maximum amount of money in your path, this is very much to your credit !

Blue bears only see 2 blocks ahead in all directions by not diagonals, easy puzzle.
You also have all the time you need to move.

With the game, you have my identity generator (unless your name is "kevin") and my map
editor (if you want to create your own puzzles).

Commands :

- Directional arrows -- to move your character.
- S -- save your game.
- L -- load last save.

Note : please preserve your ears, reduce music volume.

Well yes, I know, this one runs under Windows but run with Wine ;)

- Project (windows application, sources, editors) : 2012_TRANCHO_fricours.zip
- A video of the 50 first levels, but you would have to play to discover next opponents ;) : Fricours.wmv

P.S.: there are also secret levels ! (have a nice solving)

Before discovering programming, I need a way to create games, here are some of the huge
number of games I created with GameMaker as a child. A child game !

Note : you should probably really reduce the volume of the techno musics to avoid jumping
from your seat, not being to sensitive to bright colors and you should have robust mouse
and keyboard to play !

2012 June

Street fighter like fighting game.

For this game, I need all a team of artists to do all the art for the characters.
But you can still play to the prototype and embody a character to fight an other
controlled by computer in this fighting game.

Commands :

- Directional arrows -- moving.
- Space -- kick.
- Keypad 0 -- punch.
- Keypad 1 -- special attack (loaded bar).

- Application (windows) : KFB_demo.exe
- Sources and assets : KFB_sources.zip

2012 October

Arcade game.

A particular PacMan like with my assets. Here, the opponents are not defined during the
game, but by a path where I tried to predict you moves, be fast, good luck.

- Directional arrows -- moving.

- Application (windows) : TBR.exe
- Sources and assets : TBR_sources.zip

Few examples of tools and cool codes done during my free time that I find interesting to share.

2018 December

The Fibonacci sequence is well-known for its interest in particular for complexity courses !

Fun fact : it can be computed in logarithmic time complexity !
It is the same as considering it as two recurrent sequences and can be reduced to matrix exponnentiation.

If intersted, I propose the following document to detail a bit the theory and some generalization of the topic.

I would be happy to discuss a better and more efficient solution
(I can compute the billionth element of the Fibonacci's sequence in 46.834 seconds using my C implementation and my laptop).

You can also do benchmarks by your own using obscurantist following code :

- in C : 2018_TRANCHO_fibo_log_C.zip
- in python 3 : 2018_TRANCHO_fibo.py
- in mathematics : Mathemagie.pdf

2018 January

Well, if you want to keep a simple and cool factorial definition in mind, keep its natural definition.
Otherwise if you like combinatorics, I propose an other definition :

I save time compared to natural definition due to the idea we can optimize the computation
of sets of factor elements using fast exponent method.

However sympy use a better method to compute factorial.

I let you a python 3 code to test yourself this definition :

- in python 3 : 2018_TRANCHO_powerfact.py

2018 January

Inspired by our python 3 exam, with a friend, we created both our own one.

You can pass mine : 2 points by good answer and 2 bonus points if you play on paper
(Well if you get 26 / 20, you probably start doing python at breakfast).

You have 1 hour :

- python exam 2018 : 2018_TRANCHO_python_empty.py
- fast correction proposal (please check yourself first) : 2018_TRANCHO_python.py
- simplified and explained correction proposal (please check yourself first) : 2018_TRANCHO_python_explications.py

2016 June

To work my skills on automata, I played the game to code the concepts and algorithms from
my theoretical course in C to manipulate glossaries.

One will find here :

- glossaries handling (adding, delete and other).
- properties checking (deterministic, standard, complete and also local properties).
- automata handling (complete, determine, standardize, concat, join, minimize and more).

- Sources in C : 2016_TRANCHO_automates.zip

2015 December

To propose to other students to work their programming skills in C and linked lists, I
proposed two autocorrected exercises using unitary testing.

Antoine Meyer and Marc Zipstein liked the idea and proposed it online to other students.

First exercise is a simple exercise to review linked lists concepts and the second one is
more a challenge (in fact I didn't know yet that I proposed an exercise about graphs).

The player has just to code functions in .c in the directory "exercices" and compile to see the given score.

- completing the code is left to the reader as an exercise : 2015_TRANCHO_exercices_autocorriges.zip
- correction proposal (please try it yourself first) : 2015_TRANCHO_exercices_correction.zip

2015 November

Tools for image manipulation in 2D using SDL with a application :
build of a character using different parts and color edition.

KI_Images allow operations such as transforms, combination, edition of pictures with SDL.

In the demo, the user can change the colors of the character and rotate articulations
using directionnal arrows.

- Sources in C : 2015_TRANCHO_KI_Images.zip

Here are some of my 3D models. I don't have any real training in Blender, these models
are just creations of a passionate amateur.

Models starting from 2020 run with Blender 2.83 and the older ones works with Blender 2.79.

2020

A robot-creature's modeling.

- Modeling by mesh edition and material work.
- Grappling feature for arms, legs and tail.
- Compensation rig (controled stretch and volume variation of the arms).
- Rigid body deformation work : armor and pistons.

- The blender project (2.83) : 2020_TK_bot.blend

2020

A bit like a checking, I tried to exert myself like a real 3D artist would do. On this model, I worked my skills about:

- Character sculpting.
- Retopology of the mesh.
- Rigging : painting weights, adding bones for automatic muscle deformations, shapekeys for joint deformation correction (knee folds and chest grow).
- Animation controls : skeletal handling constraints.
- UV-cut and texture.

- The blender project (2.82) : 2020_human_dragon.blend

2020

Ready to fight my character ?

- Fight (rendering) : 2020_dragon_fight.mp4
- Fight (blender project) : 2020_HD_fight.blend

2016

The short film had to be produced in 3 weeks from nothing (personal challenge).

But, you can't read this without seeing at least this sequence.

At least for light work.

- Iron is coming (rendering) : 2016_iron_arrive.mp4
- Iron is coming (blender project) : 2016_iron_final_sortie.blend

2014

In university's first year, we had to create a website, I choose to do it on weight lifting.
So I did animations for the exercises (Well, not every movement is clean, hopefully knowledge
increase with time : for your own security, don't perform all the exercises like on the gifs !).

- Archive of the blender projects : 2014_gif.zip

2014

Here, I illustrate a demo of little fight, this example is actor-based.

Here, I have a sequence for the kick and then a one for the punch.

But the animation of the poor armor who receive the hit was done by hand.

There is also the sequence of the unfold armor, but by lack of time and resources (end of high school),
project has not been finished.

- Fight demo (rendering) : 2014_armor_fight_demo.mp4
- Fight demo (blender project) : 2014_fight_demo.blend
- Apparition (rendering) : 2014_iron_salue.mp4
- Apparition (blender project) : 2014_iron_salue.blend

Well, I was a young magician but only in videos.

2013

Here, I played to reconstruct my forearm in video. Seems really easy while done numerically.

- The video : 2013_arm_reconstruction.wmv

Hello and welcome to my doodles exhibition !

Here, I propose to follow the steps of construction of a cool drawing made in 2020.

I challenge the reader to detemine the creation dates for the following drawings (few have
10 years or more).