A key problem for all 3D printers is to convert a defined solid into a set
of horizontal slices (planes) through the solid. Each slice will represent
one scan-pass of the printer head for the 3D printer as it builds up the
solid, one layer at a time.


Each slice through the solid should be defined as a binary 2D surface
array, with a binary one in the array indicating that specific point on the
plane is inside the solid, and a binary zero in the array indicating that
the point in the plane is outside the solid. A one in the scan plane array
indicates that the printer should deposit some material at this point in
the plane, and a zero indicates that the printer should not deposit any
material at this point in the plane.


For this problem, we will define a solid using a set of points in 3D space.
The points define the vertices on the surface of the solid. The edges of
the solid are defined as the lines between the points. The faces of the
solid are defined by the set of points which are in the same plane. In the
general case, the faces of the solid's surface can be made as numerous and
as small as required, to form the required shape.


Our solids will be defined in a 3 dimensional space, with points in the
space represented by an x,y,z triple. Thus a solid tetrahedron can be
represented by four points in the space.


The four points 0,0,0 100,0,0 0,100,0 and 0,0,100 define a simple right
tetrahedron. This will be the first solid that we want to print with our 3D
printer.


We define a horizontal scan surface for our printer as the plane defined by
the three points 0,0,0 100,0,0 0,100,0.  There is no reason to define the
scan surface array any larger than the solid itself, so the scan surface
array can be a 100 x 100-point binary array.


Each point in a scan-surface array must indicate whether it is inside or
outside the solid shape. If the point is inside the solid, a binary one
will tell the printer to deposit material at this point. If the point is
outside the solid, a binary zero will tell the printer to not deposit any
material there.


For our 3D printer, we need to generate 100 of these binary scan surface
arrays, one for each resolution step as the printer moves up through the
solid space. These 100 scan surface arrays define where the 3D printer will
deposit material on each layer, to form our tetrahedron. The 3D printer
will start with the lowest layer of the scan arrays, and build the material
up from there.


The problem is to define a J verb that will generate the one hundred
100x100 2D binary arrays (essentially building a 100x100x100 3D binary
matrix), which represents the 100 horizontal slices through the solid. That
binary matrix will indicate to the 3D printer where to place the material
to create the solid.


Once you have generated the 100x100x100 binary array for the tetrahedron,
test your function out by generating a similar scan surface array for the
solid created by the intersection of two tetrahedrons:


Tetrahedron 1:  50,0,0 0,50,0 50,50,0 25,25,100

Tetrahedron2:  0,50,0 0,0,50 0,50,50 100,25,25


For further challenges, see if your J function can generate the set of 3D
printer scan surface arrays for the four other Platonic solids besides the
tetrahedron. Here are the J definitions for all the Platonic solids:
http://tinyurl.com/bry2yxc  You probably will want to scale these solids up
by a factor of 10 or so.


In general, your J function should be able to generate binary scan surface
arrays for a 3D printer given any arbitrary solid, defined by a set of
points in 3-space. Actually, besides the points, for complex solids you may
need a vector indicating which side of each surface or face is the inside
of the solid.


Skip
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to