Post on 14-Mar-2020
VECTOR-BASED LIBRARY FOR DISPLAYING BEZIER CURVES
USING A LASER PROJECTOR
MENENDEZ Francisco J., HALABI Osama, CHIBA Norishige
Department of Computer Science Graduate School of Engineering
Iwate University E-mail: fcomenendez@cg.cis.iwate-u.ac.jp, [ohalabi | nchiba] @cis.iwate-u.ac.jp
ABSTRACT
Although laser projectors are widely used in the practical
field (e.g.: laser shows performed at music concerts and
other various events), it has not yet been studied from the
Computer Graphics research point of view. In this paper,
we propose a small library to project Bezier curves using
double buffering techniques. This is our first try to develop
Computer Graphics technology for making use of laser
projectors in an efficient way.
1. INTRODUCTION
Displaying images using laser projectors is hardly a new
topic. It was first introduced in 1969 by Lowell Cross, in
collaboration with physicist Carson Jeffries [1]. Ever since
then, the use of lasers for displaying images became
widespread inside the music entertainment industry as part
of laser shows, to enhance the visual appearance of live
concert shows or as ambience inside dance clubs. For the
most part, lasers have only move in rhythm to the music
and recently, with the introduction of computers, it has
been also possible to draw simple animations.
Nonetheless, this usage is mainly practical. Laser hobbyists
and entertainment companies develop their own
equipments and software to create their laser shows, but do
not attempt to establish a formal research base for laser
graphics. In consequence, in this work, we will try to set up
the basis for displaying graphics using a computer and a
laser projection system, described, as in the section 1.2.
Since it is our objective to create the basis for a formal
research on laser graphics, we will present a “process
library”. This library is in charge of transforming the user
input so it can be displayed in a given screen, using a laser
projector. It is made from modular nodes, each one with a
different responsibility. These nodes share a common
interface, allowing the library to add new nodes or change
some according to the user’s needs.
These nodes can be used to simplify some tasks for the user,
while others can solve problems inherent to the laser
projector [2][3], such as:
� Continuity and flickering: The first and more
evident problem is to draw one complete drawing using
only one beam of light without flickering. As the beam
moves, it appears to the human eye that a line is being
drawn. After a few moments, the effect starts to disappear,
breaks the feeling of continuity and the flicker effect
appears.
� Speed versus intensity: There is an inherent problem
with laser projectors in general. The faster the beam moves,
the less intense it looks to the eye. Slowing the beam down
would make the beam look brighter, but the effect of
continuity would fade faster.
� Shortest path: The mechanical parts of the projector
require a minimum time to rotate from one position to the
next. Larger rotations would mean longer times, as fast
movements could damage the delicate galvanometers. For
a given drawing, it is necessary to find the way to perform
the least amount of rotations
� Inertia: As the galvanometers try to quickly switch
from one position to the next, an associated problem of
inertia comes into play, which produces a curved effect on
straight corners.
� Communication delay and equipped memory usage:
Most laser projectors include an in-board memory for
pre-loading programs. However, the programming
language of these devices is rather limited. Line-by-line
control of the projector proves very slow because of
communication delays between the projector and the
computer. A hybrid solution where chunks of code are sent
to the controller’s memory when needed should be
implemented.
Our first library can take user input such as control points
for Bezier curves and, using a double-buffer approach,
display them on a screen via a laser projector.
1.1 Previous Work
Research on CG for vector-based devices was active until
the booming of raster graphics, used mainly for X-Y
plotters and Vector based displays [4]. As raster monitors
and inkjet printers became more popular and widespread,
the research on computer graphics for vector-based devices
slowed down. Please note that, as vector-graphics can still
be displayed in a raster screen, eventually, they are
transformed into pixels. Vector-based devices have their
own advantages and shortcomings that deserve their own
research.
It is one of our aims to retake the computer graphics for
vector-based devices research, investigating new ways to
121
implement algorithms (such as non-photorealistic
rendering) for vector-based hardware and, in particular,
laser displays. To achieve this, we need to create a solid
library for handling laser projectors and their related
problems. In this paper we set up the first steps towards
achieving this library.
Formally, there is little or none previous research done on
laser graphics. However, there has been a good amount of
work done for the industry, and music and laser hobbyists.
In the industry, lasers have been used for marking products
in a production line [5]. A printing laser is used to mark
things such as lot and serial numbers, as well as
manufacturing and expire dates. In the music field, lasers
have been used for a while as part of laser shows in dance
clubs [6]. Yet these shows usually employ very simple,
static animations (they do not change once they started and
repeat endlessly) or the lasers simply move to match the
rhythm of the music playing.
There is also an association that gathers various hobbyists,
laser display manufacturers and users called ILDA [7]
(International Laser Display Association), which main goal
is to be a trade group. Though it has shown some efforts
into moving towards a standard file format and hardware
specifications, these standards have a commercial goal only,
as they benefit the exchange of products and services.
2. EXPERIMENTAL LASER PROJECTOR
Most basic laser projectors (figure 1) consist of at least the
following parts: (a) A main controller unit, which
communicates with the PC, holds an amount of RAM for
storing programs and is responsible for processing the PC
commands into signals the servo controllers can execute. (b)
A laser beam of a given color and intensity. (c) Power units
to feed the projector. (d) Two servo controllers that convert
the digital signals from the main controller into analog
currents for the galvanometers. (e) Two galvanometers and
their respective mirrors, one for each axis.
Figure 1: Laser projection system. (a) Main controller. (b)
Laser. (c) Power source (d). Servo controllers. (e)
Galvanometers and mirrors
The operation of the projector is achieved by sending
instructions into the controller. These instructions are sent
to the corresponding servo controllers that rotate the X and
Y mirrors by changing the current on the galvanometers.
The laser beam stays static and it is the reflection on these
two fast moving mirrors that creates the illusion of lines
and shapes on the projection screen.
The projector used in our experiments was built using the
following components [8][9]:
Scan Controller: GSI Lumonics SC2000
Servo Controllers: GSI Lumonics MiniSAX (2 units)
Galvanometers: GSI Lumonics VM-500
Laser: Coherent MVP Control Diode Laser Module.
Wavelength: 670nm±10nm (Red). Power: 0.95mW
3. PROCESS LIBRARY
To create our Laser Graphics library, we split the problem
of displaying primitives into smaller parts. The sum of
these parts is what we call the “process library” and it is
shown in figure 2
3.1 Design Overview The library subdivides the problem into “nodes”, each
having a task to solve. It allows the user or programmer to
directly input polygon coordinates to create the shape they
need or use one of the added features to easily enter text or
draw Bezier curves. Upon finishing its process, each node
passes the result onto the next. This is possible because all
nodes share a minimal common interface, allowing them to
communicate with each other. Moreover, each node also
has a set of special functions to handle the particular
settings of a given node (for example, assigning a font to
the text processing node)
Normally the library only handles coordinates. The extra
features extend the library’s abilities, allowing the user to
enter more complex elements, such as text. These extra
features eventually transform the input data into
coordinates for the rest of the library to process.
The coordinates are then clipped and normalized before
they are sent to the hardware. There are three modes of
operation that will discuss in detail further ahead.
3.2 Adding features
As we previously mentioned, the library works only with
x-y coordinates. The next two features allow the user to
enter both text and Bezier curves, besides polygon
coordinates.
3.2.1 Bezier Curves
Bezier curves are an extremely useful tool to display
graphics [10]. The implemented node allows the
programmer to choose between a quadratic or cubic curve,
as well as the number of segments that will be used to
create the curve. Then it takes three points (or four, in the
case of cubic curves) and by applying the Bezier curve
equations, it obtains a set of segments that are sent as a
group of coordinates onto the next library node.
(c)
(d)
(a) (b)
(e)
122
Hardware Controller
Controller SRAM
Programmer / User Input
Polygoon
CoordinatesText Control Points
Extra Features
Font and Text
ProcessingBezier Curves
Coordinate Processing
Clipping
Normalizing
Hardware Communication
Double Buffer
Mode
Program
ModeDirect
Mode
X-Y Mirror Movement Commands
Figure 2: Process library
3.2.2 Displaying Text
Another vital feature is the ability to display text using
different fonts. For this task, we make use the FreeType
project [11], a freely available library for reading font files,
distributed under the GPL software license. This library
allows us to read any TrueType font, obtain the curve
information for a given glyph and, with help of the Bezier
curves node previously explained, we can transform a
given string into a set of coordinates ready to be processed
by the library
3.3 Clipping
Either as result of the Bezier curve or text processing nodes,
or by direct input of the user, the clipping node takes x-y
coordinates as input and clips them to the given boundary
values. This is especially helpful to ensure that the
coordinates do not exceed the displaying capabilities of the
projector. It also useful to create certain effects, like a
scrolling message, that appears from one border and
disappears on the other end.
The implemented clipping method is roughly based on the
Sutherland-Hodgman's polygon-clipping algorithm [12].
For each side of the clipping rectangle, there are four
possible cases.
a. The beam moves inside the bounding area. No
clipping happens and the coordinates are sent to the
next node
b. The beam moves from inside-out the bounding area.
The beam is clipped to the border and then the laser is
turned off. Clipped coordinates are sent to the next
node.
c. The beam moves outside the bounding area. The
coordinates are clipped completely and not sent to the
next node. The laser remains off.
d. The beam moves from outside-in the bounding area.
The beam is clipped from the border to the intended
coordinate. Laser is turned on at border. Clipped
coordinates are sent to the next node.
3.4 Normalizing
Most controllers for laser projectors have the ability to
control not only the coordinates of the laser beam
movement, but also the time in which this movement
happens. While this might be desirable to create some
effects, for most purposes it becomes a problem. This is
because, if left unchecked, different lines will have
different intensity. For example, given two lines of
different length drawn in the same interval, the shorter line
will look brighter than the longer one. This will happen
because the mirrors will have to speed up to draw the
longer line, resulting in weaker beam intensity.
The normalizing node is in charge of resolving this for the
user, by calculating the correct delay between movements,
according to the length of the lines to be drawn. In this way,
all the lines in the drawing appear to have the same
brightness. This calculation is shown in the following
equation
Segment LengthSegment Delay
Total Frame Length × FPS=
where “Segment Delay” is the delay in time units for a
given segment, and “Segment Length” its length in
distance units. “Total Frame Length” is the sum of the
lengths of all the segments for this frame, and “FPS” is the
desired speed in frames per second.
3.5 Sending to the projector
Once the coordinates have been clipped and normalized,
we need to send them to the projector to be displayed on a
screen. Most projectors can either accept direct commands,
or instead, group a number of commands into its embedded
memory and execute them in sequence as a program. Each
mode has its advantages and limitations, as we will show.
We will also introduce a hybrid method that combines the
strength of both modes. We called this method the
double-buffer mode.
3.5.1 Direct Mode
Direct mode is possibly the simplest way to interact with
the projector. In this mode, each instruction is sent after the
123
other, commanding the controller to move and to turn the
laser on or off as needed. One of the main advantages is
that we do not have to deal with in-board memory space.
Instructions are executed on demand, providing a fast
response and real-time interaction. However, the great flaw
of this method is synchronization. Each ‘move’ instruction
takes a few microseconds to execute. Sending another
instruction while the projector is busy, might result in the
running instruction getting overwritten with the new one,
or the new instruction simply gets ignored, producing
undesirable effects. In figure 3 we can see what happens
when we try to draw five corners of a star using this
method. New coordinates overwrite the ones being
executed, creating jumps to undesired positions.
Figure 3: Instructions overlapping
To avoid this overlapping of instructions, the computer
must wait for the first instruction to end, before sending the
next instruction. There is no way to assert whether the
projector has finished or not, since querying the controller
would require an overwriting instruction. The only
approach is estimating the duration of the command and
hold the next one until that lapse expires.
Since there is no accurate way to synchronize the computer
timer to match the exact period of time required by the
laser controller to execute an instruction, small fluctuations
will appear, creating small yet noticeable delays between
two instructions.
Despite of this setback, direct mode works great for testing
programs or drawings during the developing process. And
it is much easier to debug, since only move and laser on/off
instructions are being sent.
3.5.2 Program Mode
Opposite to the direct mode, the program mode sends a
group of instructions to the controller’s memory to be
executed in sequence, instead of being sent one at the time.
Similarly, the flaws of one mode become the strengths of
the other. In program mode we no longer need to worry
about synchronization, as the controller takes care to finish
one instruction before pulling the next from its memory.
However we lose the interactivity. Once the instructions
are stored in the controller’s RAM, there is no way to
modify the program. It will repeat continuously until
execution is broken with a specific command.
While this is becomes a clear disadvantage for interactive
applications, it still can be used to load text, designs and
animations that don’t require any changes after they have
been loaded.
3.5.3 Double Buffer Mode
Upon noticing the flaws and benefits from the previous
modes, we designed a hybrid approach that we called
‘double-buffer mode’. In this mode we combine the
flexibility of the direct mode and the ability to synchronize
of the memory mode.
In double-buffer mode, we create two empty programs in
memory, and by using a third main program, we tell the
controller to switch execution between these two empty
programs and repeat until told otherwise.
As instructions start to arrive, we send them to the first
program until a ‘swap buffers’ function of our library node
is called. When this happens, we save our changes to the
first program, overwriting the empty one and immediately
start writing the second program and repeat the process.
The laser controller then begins to displays the contents of
this first buffer. When a new call to ‘swap buffers’ happens,
we save the changes to our second program and start
overwriting the first. This repeats itself continuously until
the user commands the library to stop execution.
Figure 4: Correct image drawn using double buffers
As a result of this process, we can achieve real time
interactivity, just as in direct mode. If we need to refresh
the contents of the drawings, a call to ‘swap buffers’ will
place the new buffer on display. And at the same time,
synchronization between instructions is handled
automatically by the laser controller, like in program mode.
Also, as the buffers overwrite themselves as new data input,
there are no memory limitations. This is a very good
feature, since these devices usually count with limited
memory resources (usually between 256 KB and 2 MB).
The buffers that have already been displayed are erased
from memory, permitting more data into the controller and
allowing the user to make drawings and animations as big
as necessary.
Using the implemented double buffer method, we can now
draw the five-corner star without any problems, as shown
124
in figure 4.
4. RESULTS
We were able to display objects of different complexity by
using our proposed library. Simple objects made from a
few dozen coordinates seem to display quite nicely. But, as
the number of coordinates increase, so does the number of
movements the mirrors must do to create one drawing,
increasing the time needed to display it. Eventually the
retention ability of the human retina begins to fade with
time and the images seem to flicker for these highly
complex drawings. For a given projection speed, this can
be easily solved by replacing the laser beam with a brighter
one, extending the time the image stays in the retina.
None-the-less, we can show the effectiveness of our library
approach in the following pictures.
Figure 5 shows four different Bezier curves with using
different sets of control points. Twenty-five segments were
used to display each curve.
Figure 6 is an example of our text and font processing
feature. The text “Laser Graphics” was used as input and
we used three different types of fonts to display it. With the
help of the Bezier curves node, we could even achieve very
round shaped fonts, like the example in the middle of the
figure.
Figure 5: Drawing Bezier curves
In the experiment shown in figure 6, for the three types of
fonts, the number of segments the Bezier curve sections of
the font is always 3. The resulting number of vertices is
shown in table 1 (same order as in figure 6).
The shape of the font is a defining factor in the resulting
number of vertices required to draw the text. Straight-line
based fonts usually require much less vertices, as they do
not have curves that need to be broken down in smaller
parts.
This can be seen with both the ‘Algerian’ and
‘Haettenschweiler’ fonts, which are mostly made up of
straight segments. The final number of vertices is actually
less than the number of control points because of the
number of straight segments. In the case of the ‘Brush
Script’ font, which is mostly a curvy font, the final number
of vertices is higher than the number of control points, due
to the larger amount of curved segments.
Font name
Co
ntro
l
po
ints
Straig
ht
segm
ents
Cu
rve
segm
ents
Fin
al
vertices
Algerian
(alger.ttf) 1260 856 84 1108
Brush Script
(brushsci.ttf) 681 263 219 920
Haettenschweiler
(hatten.ttf) 310 222 12 258
Table 1: Font – vertex comparison
Finally, figure 7 shows a clipping example. Applying a
clipping rectangle to the same text shown in the bottom of
figure 6, we managed to remove the rest of the text. Even
sections of the letters have been clipped when necessary.
By using clipping and scrolling the message from right to
left, we managed to create a small scrolling banner.
5. CONCLUSIONS AND FUTURE WORK
In this work we have managed to give the first steps
towards establishing a new library for displaying computer
graphics using a laser projector. Basic yet fundamental
operations such as clipping, drawing Bezier curves and
displaying text were implemented and successfully
achieved. The modularity of our proposed library allows
the addition of new nodes, extending its functionality. It
also allows easily replacing of communication modules in
the eventual case of using it with new laser projection
hardware.
We also stated the benefits of our double-buffer approach,
as it lets the user obtain real-time interactivity and smooth
animations without delays, making best use of the
projector’s memory.
As for the future work, there is a lot of areas that this
research can be further extended. Things as calculating the
shortest path needed to draw a figure, improving the speed
the mirrors rotate will be taken into account. We also
contemplate the possibility of enhancing raster projection
using lasers (for instance, superposing a message or
enhancing the borders of a figure). Problems such as
auto-calibration will have to be taken into account for this
task.
ACKNOWLEDGEMENTS
We would like to thank Mr. Norihiro Nasukawa for his
valuable technical support by building and maintaining the
laser projection hardware.
REFERENCES
[1] Lowel Cross Homepage: http://www.lowellcross.com/
[2] MENENDEZ Francisco, ABDERYIM Purkhat,
125
NASUKAWA Norihiro, HALABI Osama,
CHIBA Norishige. 2A-16 Research Towards Laser
Graphics and Related Problems. Tohoku-Section Joint
Convention of Institutes of Electrical and Information
Engineers 2006.
[3] NASUKAWA Norihiro, ABDERYIM Purkhat,
MENENDEZ Francisco, HALABI Osama, CHIBA
Norishige, 1E-04, Development of Experimental Laser
Projector, Tohoku-Section Joint Convention of Institutes of
Electrical and Information Engineers 2006, (in Japanese)
[4] FOLEY J.D., VAN DAM A. Fundamentals of
Interactive Computer Graphics. Addison-Wesley (1982).
ISBN: 0201144689
[5] Laser Engraving article on Wikipedia:
http://en.wikipedia.org/wiki/Laser_engraving
[6] Laser Shows article on Wikipedia:
http://en.wikipedia.org/wiki/Laser_show
[7] International Laser Display Association (ILDA):
http://www.ilda.wa.org/
[8] GSI Lumonics. Optical Scanners and Controllers:
http://www.gsig.com/
[9] Coherent Lasers: http://www.coherent.com/
[10] PRAUTZSCH Hartmut, BOEHM Wolfgang,
PALUSZNY Marco. Bezier and B-Spline Techniques
Springer (2002). ISBN: 3540437614
[11] The FreeType Project: http://www.freetype.org/
[12] SUTHERLAND Ivan, HODGMAN Gary. Reentrant
polygon clipping. Communications of the ACM, Volume
17, Issue 1 (1974)
Figure 6: Displaying text
Figure 7: Scrolling text with clipping applied
126