Week 05 - 3D Scanning and printing

Weekly goals

• design and 3D print an object (small, few cm3, limited by printer time) that could not be made subtractively
• 3D scan an object (and optionally print it)
• group assignment: test the design rules for your 3D printer(s)

Week's explorations and achievements

• I had prior experience with Fused Deposit Material additive manufacturing process, on various brands (Ultimaker, Raise 3D, Zortrax, Dagoma), using the slicers Cura, Z-Suite and Ideamaker.
• I discovered a new 3D modelling software, OpenSCAD and tested the Closepoints library.
• I learned more about a topology shape called knot.
• I used OpenSCAD to create 3D models of knots, using parametric equations and the hull() operation.
• I rendered and exported these models in stl format.
• I sliced them with Ideamaker and printed them in ABS and PLA on Raise 3D Pro2 machines.
• I discovered 3D scanning, and more precisely how to use the structured light 3D scanner David Scanner 4 along with the software David 4.
• I scanned a pointy shell and printed the scanned model to compare it to the original object.
• We printed torture tests in ABS and PLA (group assignment).

Group assignment

We printed two torture tests, one in PLA and the other in ABS.

See the group assignment page

Left: ABS print. Right: PLA print

Individual reflects: I thought I would observe an even bigger difference in the dimensions accuracy between the PLA and ABS print. The results are hard to extrapolate because other factors than the filament composition can influence the results - for example for bridging. Indeed, these results are made to characterize the printer's calibration, so a lot of these variations depend on the machine itself. So I think it's an intersting torture test if I need to make a diagnosis on our printers!

3D design

Visualizing Mathematics with 3D Printing

The possibilities given by 3D design, 3D visualizing tools and 3D printing to better grasp topology are some real excitements. When I imagine topologists from the past centuries trying to manipulate such concepts only with a paper and a pen I can easily imagine their high frustration and all the knots in their head they had in their sleep.

Topology bio break, a donut with a coffee. Do you know which surfaces are topologically equivalent? -- Picture taken by myself at the office (the foldable cup comes from Artipelag's museum shop near Stockholm, the donut comes from the university's canteen, the shell from the geoscience department)

So I was delighted when a friend offered me a few months ago a fascinating book by Henry Segerman called Visualizing Mathematics with 3D Printing. I first discovered this work online thanks to the rich website accompying the book's work, 3dprintmath.com. Some models are even available for printing! The book gives more explanation about the figures and the theory, in a very beginner friendly way. This week was thus an opportunity to really start practicing some notions explained in the book and create my CAD files for some figures.

Knots

A knot is an easy concept to understand from the first glance, but that doesn't mean topologists are done with them yet! Indeed, there is still much to prove and to explore in the knot field.

Basically, to make a topological knot you would make a knot in an ideal piece of string (perfectly flexible with no thickness and no friction) and tie the two ends together. That's more or less a knot! You can imagine a wide variety of knots, and all the savour of knot-studying is understanding which knot you have in front of you. Because knots can be simplified! I'll let Carlo H. Séquin explains this to you in this youtube video:

In topology you really shouldn't break your shapes apart, but there are some knots you can break apart in your imagination in two simpler knots. The simpler knots that you cannot break in even simpler knots are called primary knots. This concept gave birth to the table of primary knots:

I decided to focus on torus knots.

Torus knots

Put in simple words, you could say that Torus knots are knots you can make by drawing on a torus without intersecting itself. Here's the definition given by Wikipedia :

In knot theory, a torus knot is a special kind of knot that lies on the surface of an unknotted torus in R3. [...] Each torus knot is specified by a pair of coprime integers p and q. [...] A torus knot is trivial (equivalent to the unknot) if and only if either p or q is equal to 1 or −1. The simplest nontrivial example is the (2,3)-torus knot, also known as the trefoil knot.

Here is an example of the process to make a trefoil knot which is the simplest torus knot. As says Henry Segerman in *Visualizing Mathematics with 3D printing, the trefoil is the (2,3) torus knot, because it goes three times through the hole and two times around. In the unrolled version in the figure bellow (fig 5.6), the knot (the red line) goes three times around horizonthally and twice vertically.

Here is a 3D visualization that might help (source):

Trefoil Torus Knot by Henry Segerman on Sketchfab

Torus knots are thus some specific type of knots, and some happens to also be primary knots, such as the trefoil knot, which is named 3_1 knot in the Alexander-Briggs notation (that we encounter in the primary knot table). But not all torus knots are primary knots! That's the case for example for the (3,4) torus knot but we'll come back to it later.

Important remark about conventions!

The (p,q)-torus notation is a convention, but it exists one where you'll find the inverse definition of p and q!! Some places the same knot could be call T(3,2) and some places (2,3). Very confusing. I'll carry on with the convention used above and in Seager's book.

Anyway, the torus knots have kind of their own table. Here is an extract of a 36 torus knots I found on The knot atlas. It uses the other conventions, don't get all mix up as I did!

3D design in Openscad: looking for the correct method

OpenSCAD was the more obvious CAD software too chose since you really want to use some parametric equations to describe your volumes. Also it's a good exercise for me since I barely ever used it (only to follow through a basic tutorial). This exercise definitely helped me getting more familiar with Openscad, though I admit I didn't have the time to dig in all functions and particularities of the software. I am using OpenSCAD 2021.01 version.

Sweeper library

I first looked online for some knots modelled in Openscad. I found some interesting articles on the blog Hackstatic, A blog about design, math, and failure I should defintiely browse one of these days!

The first article I found was about using a library called Sweeper to calculate the volumes: see Knots in Openscad with Sweeper. I'll cite them to explain the benefit of the Sweeper library:

Knots are basically just closed curves in space, and the easiest way to create a closed curve in OpenSCAD is to “connect the dots” — that is, to create a list of points in space, place a small sphere at each of those points, and then connect each sphere to the next. If you only have a few datapoints then this method is perfectly acceptable. This “connect-the-dots” method is simple, but with more points, as you would have if you were sampling close-together points to connect and make a curvy path in space, this way of generating a curve in space is really, really, really slow. Each pair of connected spheres costs a convex hull calculation, which is a very computationally expensive operation.

Luckily, there is a smarter way. The “sweeper” code library in OpenSCAD takes a sequence of datapoints on a curve and constructs one huge polyhedron from that data. At each point the sweeper code places a cross-sectional shape like a polygonal circle or a square, oriented in the direction of the curve. Then it connects successive cross-sections with faces, and puts the whole thing together with OpenSCAD’s polyhedron command. The code is a lot harder to follow than the method above, but for the most part you can ignore it and just put in your datapoints.

I let you read the rest on their blog!

So that indeed seemed interesting, but unfortunately I couldn't find that sweeper library. As the article was dated from 2018 I started having doubts about wheter it still exists. I then abandoned searching in that direction and looked for another library.

Closepoints library

Well, maybe I could start with the list of libraries mentioned on Openscad's official website. I indeed found something interesting similar to what I understood Sweeper did: the closepoints library that you can find here on github.

Installing libraries in OpenSCAD

To install a library, first make sure you download the .scad file. If it's a zip unzip it, if it's inside a folder you'll have to get it outside of the folder. Then open OpenSCAD and go in the top menu in File > Show libraries directory. In my case I had to create beforehand a folder named 'Librairies' in this directory, but that may not be your case. That's where you want to place your .scadlibraries. That's it!

I started by testing a demo file, the demo_wavy_donut file.

Here's the code:

// Created in 2021 by Ryan A. Colyer.
// This work is released with CC0 into the public domain.
// https://creativecommons.org/publicdomain/zero/1.0/

use <closepoints.scad>


// [Scale X]            [Shear X along Y]   [Shear X along Z]   [Translate X]
// [Shear Y along X]    [Scale Y]           [Shear Y along Z]   [Translate Y]
// [Shear Z along X]    [Shear Z along Y]   [Scale Z]           [Translate Z]
// or rotation matrix [[cos,-sin],[sin,cos]] in the 2 axes for a plane.
function PathMatrix(t) =
  [[cos(t*360), -sin(t*360), 0, 50*cos(t*360)],
   [sin(t*360),  cos(t*360), 0, 40*sin(t*360)],
   [         0,           0, 1,             0]];

function ThePolygon(t) =
  [for (a=[0:2:359.99])
    (5+5*(1+cos(8*t*360))/2)*[cos(a), 0, -sin(a)]
  ];


pointarrays =
  [for (t=[0:0.002:0.99999])
    [for (p=ThePolygon(t))
      Affine(PathMatrix(t), p)
    ]
  ];

CloseLoop(pointarrays);

I could compile it correctly!

I played around with what looked to me as parameters in the function `ThePolygon(t), and some indeed modified the donut's shape. Here is the initial function:

function ThePolygon(t) =
  [for (a=[0:2:359.99])
    (5+5*(1+cos(8*t*360))/2)*[cos(a), 0, -sin(a)]
  ];

Here are some modifications I tried.

function ThePolygon(t) =
  [for (a=[0:28:359.99])
    (5+5*(1+cos(8*t*360))/2)*[cos(a), 0, -sin(a)]
  ];

function ThePolygon(t) =
  [for (a=[0:2:359.99])
    (5+10*(1+cos(8*t*360))/2)*[cos(a), 0, -sin(a)]
  ];

function ThePolygon(t) =
  [for (a=[0:2:359.99])
    (0+10*(1+cos(8*t*360))/2)*[cos(a), 0, -sin(a)]
  ];

function ThePolygon(t) =
  [for (a=[0:2:359.99])
    (5+10*(1+cos(1*t*360))/2)*[cos(a), 0, -sin(a)]
  ];

Ok maybe it's time to understand what's going here. So, here's how the library works:

// This generates a closed polyhedron from an array of arrays of points,
// with each inner array tracing out one loop outlining the polyhedron.
// pointarrays should contain an array of N arrays each of size P outlining
// a closed manifold.  The points must obey the right-hand rule.  Point your
// right-hand thumb in the direction the N point arrays travel, and then the
// P points in the inner arrays must loop in the direction the fingers curl.
// For example, looking down, the P points in the inner arrays are
// counter-clockwise in a loop, while the N point arrays increase in height.
// Points in each inner array do not need to be equal height, but they
// usually should not meet or cross the line segments from the adjacent
// points in the other arrays.
// (N>=2, P>=3)
// Core triangles:
//   [j][i], [j+1][i], [j+1][(i+1)%P]
//   [j][i], [j+1][(i+1)%P], [j][(i+1)%P]
//   Then triangles are formed in a loop with the middle point of the first
//   and last array.  To override this middle closure point, specify a
//   coordinate position for close_top_pt and/or close_bot_pt.
module ClosePoints(pointarrays, close_top_pt=undef, close_bot_pt=undef)

// This generates a looped polyhedron from an array of arrays of points, with
// each inner array tracing out one layer loop outlining the polyhedron.
// pointarrays should contain an array of N arrays each of size P outlining a
// closed manifold.  The points must obey the right-hand rule.  For example,
// looking down, the P points in the inner arrays are counter-clockwise in a
// loop, while the N point arrays increase in height.  Points in each inner
// array do not need to be equal height, but they usually should not meet or
// cross the line segments from the adjacent points in the other arrays.  The
// last layer loop should geometrically lead into the first when it is closed.
// (N>=2, P>=3)
// Core triangles:
//   [j][i], [j+1][i], [j+1][(i+1)%P]
//   [j][i], [j+1][(i+1)%P], [j][(i+1)%P]
module CloseLoop(pointarrays)

// Perform an affine transformation of matrix M on coordinate v.
//
// [Scale X]          [Shear X along Y] [Shear X along Z] [Translate X]
// [Shear Y along X]  [Scale Y]         [Shear Y along Z] [Translate Y]
// [Shear Z along X]  [Shear Z along Y] [Scale Z]         [Translate Z]
// or rotation matrix [[cos,-sin],[sin,cos]] in the 2 axes for a plane.
function Affine(M, v)

// Combine a list of affine transformation matrices into one.
function AffMerge(Mlist)

// Prepare a matrix to rotate around the x-axis.
function RotX(a)

// Prepare a matrix to rotate around the y-axis.
function RotY(a)

// Prepare a matrix to rotate around the z-axis.
function RotZ(a)

// Prepare a matrix to rotate around x, then y, then z.
function Rotate(rotvec)

// Prepare a matrix to translate by vector v.
function Translate(v)

// Prepare a matrix to scale by vector v.
function Scale(v)

// Find the bounding box of pointarrays.
// Returns [[min_x, min_y, min_z], [max_x, max_y, max_z]]
function BBox(pointarrays)

Unfortunately I couldn't understand how the PathMatrix should be used, and how to transpose a parametric equation in such a description.

I didn't go any further with this library finally.

Let's get back to simple hulling

I was wandering in my many navigation tabs, and came back at some points to hackstatic's blog, more precisily to the following article about some fourier and tritangentless knots.

In their source code they didn't use any libraries but defined a module based on the hull()function. Also, they gave another source which finally got me out of the darkness: Kit wallace's rolling knot Thingiverse file. Kit wallace explains how they improved the original OpenSCAD calculation of hackstatic / mathgrrl in the Thingiverse project:

I came across mathgrrl and was intrigued by the rolling knot http://makerhome.blogspot.co.uk/2013/12/day-110-rocking-knot.html. I wondered if I could define it with Openscad.

The challenge is to create a tube which is smooth enough and will fully render in an acceptable time. I tried a tube of simple cylinders oriented along the path but this proved desparately slow and rough. At nophead's suggestion I then moved to segments made from hull() ing successive pairs of disks or spheres. The script for spheres turned out to be not only simpler but also faster. However nophead suggested a cone instead of a disk, and with the addition of explicit render()s this provide the best performance so far.

The best script is rolling-knot-hull-cone which renders the 2 degree version (180 segments) in 12 minutes on my Acer Aspire.

Many thanks to mathgrrl and the helpful OpenScad community especially nop head.

In this way, without using any additional libraries, Kit Wallace took advantage of the hull() function to create the knot volume. If I understand correctly, here is the magic recipe: to generate segments made from hull() ing successive pairs of cones

Well maybe you're asking yourself what's hulling? Let's ask the OpenSCAD User Manual

Or as all3dp puts it, the hull() operator takes all of the objects inside of it and wraps them up in a “hull”, like taking a piece of cloth and tightly wrapping it around all of your objects. This makes it great for covering up gaps and making complex shapes!

Apparently the difficulty with the hull() is that it has an important computational costs, thus affecting the rendering time. So thinking about what you hull and how is important.

I tried Kit wallace's technique and it worked finefor the rolling knot example provided. By the way, a rolling knot is called that way because no plane is tangent to three places on the curve at the same time. So it cannot help rolling when you put it on a very lightly tilted surface. Seems fun to print someday!

Here's Kit Wallace's code, that you can also find on KitWallace's github page

// rolling knot code with thanks to mathgrrl and nop head

module disc_p2p(p1, p2, r) {
      assign(p = p2 - p1)
      translate(p1 + p/2)
      rotate([0, 0, atan2(p[1], p[0])])
      rotate([0, atan2(sqrt(pow(p[0], 2)+pow(p[1], 2)),p[2]), 0])
      render() cylinder(h = 0.1, r1 = r, r2 = 0);
};

function f(t) =   // rolling knot
   [ a * cos (3 * t) / (1 - b* sin (2 *t)),
     a * sin( 3 * t) / (1 - b* sin (2 *t)),
     1.8 * b * cos (2 * t) /(1 - b* sin (2 *t))
   ];

module tube(r, step) {
   for (t=[0: step: 359])
       assign (p0 = f(t), 
               p1 = f(t + step ),
               p2 = f(t + 2 * step))
       render() hull() {
          disc_p2p (p0,p1,r);
          disc_p2p (p1,p2,r);   
       }
};

$fn=20;
a = 0.8;
b = sqrt (1 - a * a);
r = 0.3;
step = 2;

scale(15) tube (r, step);

Of course I started playing around with the parameters. I started by modifying a and r. Then I changed the rolling knot function. That was fun, but it was time to get back to my torus knot.

Torus knots parametric descriptions

I started looking for the simplest torus knot I'll do, which is also the simplest non trivial knot. Do you remember which one is it? Yes, it's the trefoil knot also known as the (2,3) torus knot. I first found these equations on Wikipedia's trefoil knot page:

First I only focused on the first parametric equations given, and replace the f(t) function in my OpenSCAD rolling knot example with these. Fingers crossed... It worked! Here it is, my first trefoil in OpenSCAD.

Now we want to generalize what we just experimented with a trefoil knot to all torus knots.

Let's remember the definition of torus knots given in Wikipedia:

In knot theory, a torus knot is a special kind of knot that lies on the surface of an unknotted torus in R3. [...] Each torus knot is specified by a pair of coprime integers p and q. [...]

Remember the notation's convention issue!

The (p,q)-torus notation is a convention, but it exists one where you'll find the inverse definition of p and q!! Some places the same knot could be call T(3,2) and some places (2,3). Very confusing. I carry on with the convention used above and in Seager's book.

Here's what Wikipedia tells us about their geometric representations:

The (p,q)-torus knot winds q times around a circle in the interior of the torus, and p times around its axis of rotational symmetry. If p and q are not relatively prime, then we have a torus link with more than one component. The direction in which the strands of the knot wrap around the torus is also subject to differing conventions. The most common is to have the strands form a right-handed screw for p q > 0.

That looks like a really good start. We can extend these equations to other tori with parametric dimensions, by considering the following tori:

• the torus is azimuthally symmetric about the z-axis
• c is the radius from the center of the hole to the center of the torus tube
• a is the radius of the tube
• we considered only ring tori (c>a)

By writing the cartesian equations of such a torus, we can then obtain the equations as stated in the blog Wolfram Mathworld:

Equation of the torus with cartesian coordinates: (c-sqrt(x^2+y^2))^2+z^2=a^2   

The parametric equations are thus: 

x   =   (c+acosv)cosu   
y   =   (c+acosv)sinu   
z   =   asinv   
for u,v in [0,2pi]. 

To go back to our torus knot, we can then finally get a parametric description of the (p,q) torus knot in the form of a function f(t), by setting u = q*t and v=p*t, for t in [0,2pi]. That gives us:

c=10;// radius from the center of the hole to the center of the tube
a=6; // radius of the tube (c>a for a ring torus)
p=2; // (p,q) torus in the (p<q) notation
q=3; // (p,q) torus in the (p<q) notation

function f(t) =   
[ (c+(a*cos(q*t)))*cos(p*t),
(c+ (a*cos(q*t)))*sin(p*t),
(a*(sin(q*t)))
];

We're ready to use this parametric description with the hulling solutions of KitWallace. Note that as OpenSCAD seems not to take in account radiants but only degrees, you need to iterate with t from 0 to 359, and not from 0 to 2*pi.

And here is the whole OpenSCAD code for a (p,q) torus knot

// Clara Devanz - Fabacademy 2023
// Closely adapted code from the rolling knot code written by KitWallace (who also credits mathgrrl and nop head), but with knot torus parametric equations : https://mathworld.wolfram.com/Torus.html
// Here the notation where q > p is used. Thus q is the number of times the knot cross the center of the torus and p is the number ot times it turns around the z-axis.
//  The torus is azimuthally symmetric about the z-axis; c is the radius from the center of the hole to the center of the torus tube, and a is the radius of the tube. We considered only ring tori (c>a).

// Here are the parameters you're invited to modify!

p=2; // (p,q) torus
q=3; // (p,q) torus
c=10; // radius from the center of the hole to the center of the tube
a=6; // radius of the tube
r = 2; // radius of the knot
step = 1; // steps of the 'for' loop calculating the knot's sections for t=[0: step: 359])
$fn=50; // number of fragments. Will change the 

function f(t) =   
[ (c+(a*cos(q*t)))*cos(p*t),
(c+ (a*cos(q*t)))*sin(p*t),
(a*(sin(q*t)))
];

module disc_p2p(p1, p2, r) {
      assign(p = p2 - p1)
      translate(p1 + p/2)
      rotate([0, 0, atan2(p[1], p[0])])
      rotate([0, atan2(sqrt(pow(p[0], 2)+pow(p[1], 2)),p[2]), 0])
      render() cylinder(h = 0.1, r1 = r, r2 = 0);
};

module tube(r, step) {
   for (t=[0: step: 359])
       assign (p0 = f(t), 
               p1 = f(t + step ),
              p2 = f(t + 2 * step))
       render() hull() {
          disc_p2p (p0,p1,r);
          disc_p2p (p1,p2,r);   
       }
};

scale(2) color([0.968,0.788,0.961]) tube (r, step);

Which gives the following result:

I really like this parametric description, the shape is way nicer than the first try!

You can see in the code that in addition to the parametric function parameters, we can also modify some simulation parameters. Finally, here is the list of all parameters you're invited to play with:

• p and q characterize the (p,q) torus you're tracing your knot on, in the convention where p < q.
• c is the radius from the center of the hole to the center of the torus 'tube'
• a is the radius of the torus 'tube' (c>a for a ring torus)
• r is the radius of your knot tube's section
• step is the value of the steps the 'for' loop iterates on to calculate the knot's sections for t=[0: step: 359])
• $fn is the number of fragments used for the surface calculation accross the section of the knot

I didn't take the time to analyze all parts of the code about the hulling but at least I can really play with parameters now!

Some torus knots examples

Here are some torus knots I rendered with the following parameters:

Torus knot	p	q	c	a	r	step	$fn	scale
(2,3)	2	3	8	4	3	1	50	2
(2,5)	2	5	10	4	2.5	1	50	2
(2,7)	2	7	12	4	2.5	1	50	2
(3,4)	3	4	12	8	2.5	1	50	2
(2,9)	2	9	12	3	2	1	50	2
(3,5)	3	5	12	4	2	1	50	2

Below you can find the corresponding Openscad screenshots (in the same order as listed in the table):

---

Here you can visualize them in 3D after the .stl export (see below the section about exporting stl).

(2,3) torus knot

(2,5) torus knot

(2,7) torus knot

(2,9) torus knot

(3,4) torus knot

(3,5) torus knot

3D printing

There are many different technologies to 3D print an object. The most used by makers and hobbyists are probably Fused Deposit Modeling (FDM) technologies. Then in FDM you also have lots of variations from a printer to another.

Here is some documentation I wrote for my lab in French:

• about various types of FDM machines

• about the important parameters in FDM printing

• about how to use our FDM 3D Printers, which are the Raise 3D Pro2

STL export

In order to 3D print our designs, we have to export our designs as .stl files. In OpenSCAD, you first need to render your model. That's when it does all the calculation.

Open the OpenSCAD console to check when it's done, because it might take some long minutes! My models took between 10 and 20 minutes to generate (I didn't measure time precisely).

When it's all good, you should have a similar message in your console:

Our printers

We mostly have Raise 3D Pro 2 printers and also two Pro 2 plus (which works exactly the same). Here are som key characteristics:

• Maximum printing dimensions: 305 x 305 x 300 mm
• Maximum precision: 10 microns
• Speed: 30 - 150 mm/s
• Compatible materials: PLA / ABS / HIPS / PC / TPU / TPE / NYLON / PETG / ASA / PP / Glass fiber / Carbon fiber / Bronze / Wood
• Filament diameter: 1.75mm
• Extrusion: Double extrusion, direct extrusion system

Also we generally use 0.4mm nozzles, mostly in brass.

Slicer

Once you have your .stl file, your printer and your filament, you need to prepare your file for printing thanks to a software called a slicer. In our lab we use the slicer IdeaMaker which is created by the same company than the one who fabricates our FDM printers, Raise 3D.

I used PLA filament (baby pink, ivory and blue filament from Machines-3D) and ABS filament (white).

Here are the parameters I used to slice the models, both for ABS and PLA

• Layer heigth: 0.15mm
• Shells: 2
• Infill pattern: grid
• Infill density: 15%
• Supports: automatic, all below 45°

I used the predefined High Quality profile for the corresponding materials (RAISE 3D PLA 1.75 and RAISE 3D ABS 1.75) without trying to adjust finely the other settings. I would have to do it and to start with printing tests if I were to use more exotic filaments, or if these filaments brands hadn't print correctly.

I used a raft for ABS prints and not PLA (except once by mistake).

Prints

I didn't encounter any major difficulty... except I had a KNOT in the filament!!! While printing a knot, can you imagine??

A knot stopped by another knot

Printing in progress

Print supports

With and without supports

PLA prints

ABS prints

Knots labelled

add images of beautiful knots family <3 <3

3D scanning

Material

We use a DAVID 3D Scanner 4 with the corresponding DAVID 4. It is a structured light 3D scanner. Unfortunately this brand and device has been baught by hp, then abandonned. But thanks to my colleague Pierre we can still make it work!

It consists of:

• a videoprojector
• a small camera
• a tripod equiped with a metal horizonal arm
• the arm itself, where the camera and the projector are mounted. It allows to set the distance between them and the angle of the camera.
• a turning circular base
• a calibration screen

You have to use it with a computer and the dedicated software, DAVID 4.

Official documentation in French

Workflow and software presentation

Basically there are 4 tabs you'll mainly navigate in one after another.

The Setup window

Here you mostly change the brightness of the camera and the exposure of the camera. The documentation advise some settings but other user feedbacks say the contrary. We just tried to have a nice contrast.

At this step you also want to manually adjust the exposure and the focus of the camera.

The Calibration window

Every new scan project requires a proper calibration that you do with the calibration screen and without the object you want to scan. The square in the middle must be visible along with the 6 circles. You have to choose the appropriate calibration panel depending on the object's dimensions, then set it (here it's 120mm).

You might get a warning message if the angle of the camera is no appropriate (we first encountered the situation where the angle was too small). Once your calibration is correct you can go on to the next step.

The Scanning in progress window

Push the screen a bit further and place the turning base approximatively where the screen was during the calibration.

Next scan the background without any object on it, by clicking on Scanner l'arrière plan. Once it's done check Retirer l'arrière-plan(remove the background).

Then, put the object you want to scan in the center of the base. Check on the screen that it fits nicely (also, it should also fit during all the scans once rotated).

Set the number of scans you want to capture, and on which rotational amplitude (for example 360° if you want your object to do a full turn). I did 12 frame captures.

Click on start and watch your object turning. The progress bar is the red bar at the bottom of the screen.

We didn't use the Texture window for the scans so I'll carry on with the next one.

The Reconstitution and fusion window

Here you'll see all your scans appearing one after another, trying to align correctly together in real-time. Well sometimes it does work great, but not all times. All your scans are listed in the right panel. You can hide them one after another to check which one has a problem, and if it's just a matter of 1 or 2 scans, delete them.

If your scans don't seem to align at all, maybe it's better to delete everything and start again from the calibration step.

If they do seem to align properly, you can first clean the result from any unexpected parasite. Click on the selection rectangle in the left then select the rendering defaults in the main workspace and delete them.

You can finally group your scans (right click on the scans) and relaunch a new sery of scans with another position for your object (if you want a 360° scan in all directions).

Let's suppose that everything went fine with that second sery of scan too. Now you want your two groups of scans to be aligned correctly together. You can either choose the automatic alignment thanks to the texture analysis (doesn't work that often) or align the contact points. For this you need to select the same points (in the physical world) on the two different surfaces, and click on Aligner les scans (Align the scans).

Once it's done, you check that you have savec your file and you can fuse your scans by clicking on the Fusionner button. It takes some time and calculous, don't touch anything. You can then export your model in .obj, .stl and even in a .png file containing all the scans.

My results

I used successively three different objects before getting a satisfying result.

The wooden elephant

The first item I thought of scanning was a baby elephant sculpture (10,5 x 5 x 11 cm (4,3 x 2 x 5") made out of dark wood, designed by Gunnar Flørning & Harry Vedøe in 1961, and reedited by the danish manufacturer Lucie Kaas.

Don't trust this cute non-being, it was terrible to scan! Maybe because of the dark wood texture, we couldn't get the scans to align nicely.

I gave up because my time is precious unfortunately, but my colleague told me he managed to scan it when I was gone. What a stubborn animal it is!

My colleague's results, not mine

The white coral

Desperate by my elephant, I asked my colleague if he had anything to scan in his geoscience department. One of his colleague allowed me to take with me some items they used for practice classes with students. One of them was a pretty white coral.

Things went oh so smoothly for the scans real-time alignment. We could launch a new sery of scan of the under part, and they also aligned easily. BUT when we wanted to align both groups of scans together with the Sélectionnez les points de contact (Select contact points), we couldn't manage to find appropriate points in the surfaces that would align everything nicely. We tried a bunch of them but didn't get any result. I gave up again. Of cours, my colleague manage to do it on his own when I was gone è__é

My colleague's results, not mine

The pointy shell

Among the borrowed objects from the geoscience department, there was also a nice pointy shell. He was a bit shiny so we were afraid it couldn't be scanned correctly, but had a lot of hope for the contact points selection since they are much easier to identify.

All steps went good!

Finally some results!

I printed it in ABS afterwards. It seems there is a small problem with the model, as I had the exact same horizontal crack during two consecutive prints (I stopped the second one when I realized it).

The details are pretty nicely reproduced!

Files

• (p,q) torus knot OpenSCAD file, to generate your own (p,q) torus knots.

• (2,3) torus knot, (2,5) torus knot and (2,7) torus knot files. You can also download them (and the 3 others) through Sketchfab, and of course generate your own knots!

• Scans: Unfortunately both the coral and the shell scans are way too big (300-500Mo) to be either pushed in the repo or uploaded for free in sketchfab. I may try some mesh simplifier software.