IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS, VOL. 14, NO.

10, OCTOBER 2003 973

An Oð1Þ Time Algorithm for the 3D Euclidean

Distance Transform on the CRCW PRAM Model
Yuh-Rau Wang and Shi-Jinn Horng

Abstract—In this paper, we develop a parallel algorithm for the 2D Euclidean distance transform (2D_EDT, for short) of a binary image
of size N
N in Oð1Þ time using N 2þ
þ CRCW processors and a parallel algorithm for the 3D Euclidean distance transform (3D_EDT,
for short) of a binary image of size N
N
N in Oð1Þ time using N 3þ
þ CRCW processors, where
¼ 1k ,  ¼ 2cþ111 , k, and c are
constants and positive integers. Our 2D_EDT (3D_EDT) parallel algorithm can be used to build up Voronoi diagram and Voronoi
polygons (polyhedra) in a 2D (3D) binary image also. All of these parallel algorithms can be performed in Oð1Þ time using N 2þ
þ
(N 3þ
þ ) CRCW processors. To the best of our knowledge, all results derived above are the best Oð1Þ time algorithms known.

Index Terms—Computer vision, Euclidean distance transform, image processing, parallel algorithm, Voronoi diagram, CRCW PRAM
model.

1 INTRODUCTION

P ROCESSING digital image data from three-dimensional

(3D, for short) objects is an important task in the image
processing and the computer vision fields. The distance
processors. Fujiwara et al. [15] presented an algorithm
2
running in OðlogloglogNN Þ time using N log
log log N
N CRCW processors
N2
and an algorithm running in Oðlog NÞ time using log N EREW
transform (DT, for short) first introduced by Rosenfeld and processors, respectively. Hayashi et al. [16] further pre-
Pfaltz [27], [28] is one of the most important elementary sented an algorithm running in Oðlog log NÞ time using
operations and is extensively applied in the image proces- N2
sing area for extracting useful information from the log log N CRCW processors. Pan et al. [24] presented algo-

received digital image. A number of different DTs have
been developed. The Euclidean distance transform (EDT,
for short) is based on the Euclidean metrics, whose
application is better than those of DTs based on other
metrics. The Euclidean distance transform is an operation
that converts an image consisting of black and white pixels
(voxels) to an image where each pixel (voxel) has a value
that represents the Euclidean distance to its nearest 1-pixel
(1-voxel). Because the EDT is a global operation, it is
prohibitively time consuming when this operation on a
binary image is performed, especially on a 3D binary image.
In order to provide the efficient transform computations,
parallelism should be employed.
Recently, many papers were introduced for constructing
the Euclidean distance transform of a 2D binary image of
size N
N. Hirata [17], and Breu et al. [8] presented OðN 2 Þ
time sequential algorithms for computing the Euclidean
distance transform. On the EREW PRAM model, Lee et al.
[22] presented an Oðlog2 NÞ time algorithm using N 2
processors; Pavel and Akl [26] presented an algorithm
running in Oðlog NÞ time using N 2 processors. Chen [9]
presented an OðN log NÞ time algorithm using logNN EREW
. Y.-R. Wang is with the Department of Computer Science and Information
Engineering, St John’s & St. Mary’s Institute of Technology, Taipei,
Taiwan. E-mail: yrwang@mail.sjsmit.edu.tw.
. S.-J. Horng is with the Department of Electrical Engineering, National
Taiwan University of Science and Technology, Taipei, Taiwan.
E-mail: horng@mouse.ee.ntust.edu.tw.
Manuscript received 24 June 2002; revised 14 Feb. 2003; accepted 6 May
2003.
For information on obtaining reprints of this article, please send e-mail to:
tpds@computer.org, and reference IEEECS Log Number 116840.
1045-9219/03/$17.00 ß 2003 IEEE
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
rithms running in Oðlog log NÞ time on an N 3 LARPBS or in
Oðlog N log log NÞ time on an N 2 LARPBS. Datta et al. [13]
presented an algorithm running in Oðlog log NÞ time using
N 2þ processors on the LARPBS, where 0 <  < 1. As for
Oð1Þ time algorithms for the 2D_EDT computation, Pan et al.
[23] presented an algorithm running in Oð1Þ time on an
N 2
N 2 reconfigurable mesh. Datta et al. [12] presented an
algorithm running in Oð1Þ time on an N
N 2 reconfigur-
able mesh. Wang and Horng [32] presented an Oð1Þ time
algorithm using N 2:25 processors on the AROB model for the
2D_EDT computation but it is incorrect. Several sequential
3D distance transform algorithms were introduced by [4],
[6]. Up to now, some parallel algorithms were introduced
for constructing the Euclidean distance transform of a
3D binary image of size N
N
N. Lee et al. [21] presented
an Oðlog2 NÞ time algorithm using N 3 processors on the
EREW PRAM model. Wang and Horng [32] presented an
Oð1Þ time algorithm using N 3:25 processors on the AROB
model for the 3D_EDT computation but it is incorrect.
In this paper, we present the first Oð1Þ time parallel
algorithms for computing both the exact 2D_EDT and the
exact 3D_EDT on the CRCW PRAM computation model.
We first develop an Oð1Þ time parallel algorithm termed as
ALGORITHM General_Dimension_Expander using N 1þ
þ
CRCW processors, where
¼ 1k ,  ¼ 2cþ111 , k, and c are
constants and positive integers. It supports a route to cross
from a lower dimension to a higher dimension. Then, based
on the dimensionality reduction technique, for an N
N
binary image, our parallel algorithm for the 2D_EDT
computation can be run in Oð1Þ time using N 2þ
þ CRCW
processors. For an N
N
N binary image, our parallel
Published by the IEEE Computer Society
974 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS,
Fig. 1. (a) An illustration of 2D axes X and Y . (b) An illustration of
3D axes X, Y , and Z.
algorithm for the 3D_EDT computation can be run in
Oð1Þ time using N 3þ
þ CRCW processors. Our parallel
2D_EDT algorithm can be used to build up Voronoi
diagram and Voronoi polygons in Oð1Þ time using N 2þ
þ
CRCW processors; meanwhile, the 3D_EDT algorithm can
be used to solve the same problems in Oð1Þ time using
N 3þ
þ CRCW processors.
The remainder of this paper is organized as follows: In
Section 2, we introduce the PRAM model and some
properties of EDTs upon which our algorithms are based.
In Section 3, we develop a lemma for the general maximum
(minimum) finding. In Section 4, we describe our algo-
rithms named ALGORITHM General_Dimension_Expander,
ALGORITHM 2D_EDT_CRCW and ALGORITHM
3D_EDT_CRCW in details. Finally, some concluding re-
marks are included in the last section.
2 PRELIMINARIES
2.1 The PRAM Model
The parallel random access machine (PRAM, for short)
consists of a number of identical processors, memory access
unit, and a shared-memory. The shared-memory stores data
and serves as the communication medium for the proces-
sors. At each step, every processor performs the same
instruction, with a number of processors marked out. The
concurrent read concurrent write PRAM (CRCW, for short)
model will be used in this paper for parallel computation.
The CRCW PRAM can be further divided into a number of
submodels, according to the rule used to resolve memory
write conflicts, which occur when more than one processor
attempt to write into the same memory location simulta-
neously. This gives rise to submodels such as the Common
CRCW PRAM, the Priority CRCW PRAM, and so on. The
Common CRCW PRAM processors are allowed to write in a
memory location if they are attempting to write the same
value. Throughout this paper, the Common CRCW PRAM
submodel is used as our CRCW PRAM computation model.
2.2 Definitions
Fig. 1a illustrates the directions of axes in two dimensions X
and Y , and Fig. 1b depicts the directions of axes in three
dimensions X, Y , and Z. A pixel is used to represent an
image point in a 2D plane and a voxel is used to represent
an image point in a 3D space. A black/white voxel of a
binary image is usually denoted as a 1-voxel/0-voxel. A
voxel can be represented by its Cartesian coordinates. A
voxel p with coordinates ði; j; kÞ is usually represented by
p ¼ ði; j; kÞ, where Xp ¼ i, Yp ¼ j, and Zp ¼ k are the
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
VOL. 14, NO. 10, OCTOBER 2003
X-coordinate, Y -coordinate, and Z-coordinate of p along
the X-axis, Y -axis, Z-axis, respectively. A pixel can be
described similarly. The Euclidean distance transforms in
arbitrary dimensions are formally defined as follows:
Definition 1. Let bi denote a point of a line with coordinate ðiÞ.
Given a sequence b0 ; b1 ; . . . ; bi ; . . . ; bN1 of zeros and ones, to
determine the closest 1-point to every point in this sequence is
defined as the 1D nearest-one problem which actually is the
same as the 1D Euclidean distance transform (1D EDT ).
Definition 2. Let p ¼ ði; jÞ denote a pixel of a 2D binary image.
Let P ¼ fp j p ¼ ði; jÞ, p is either a 0-pixel or a 1-pixel, 0 
i; j  N  1g denote a 2D binary image of size N
N. Let
B2D ¼ fq j q ¼ ðx; yÞ, q is a 1-pixel, 0  x; y  N  1g
represent the set of the 1-pixels of the 2D binary image. Then,
the 2D Euclidean distance transform (2D_EDT) of pixel p
with respect to its nearest 1-pixel N p is denoted by
qffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi
2d edtp ¼ min ði  xÞ2 þ ðj  yÞ2
q2B2D
and the 2D_EDT of P is to compute f2d edtp j for all p 2 Pg.
Definition 3. Let p ¼ ði; jÞ be a pixel p of P. Let N p denote the
nearest 1-pixel of the pixel p with respect to all 1-pixels in P.
Let N p ðCk Þ, 0  k  N  1, denote the nearest 1-pixel of the
pixel
 p with respect  to all 1-pixels in column Ck . Let
XN p ðCk Þ ; YN p ðCk Þ denote the coordinates of N p ðCk Þ. Clearly,
YN p ðCk Þ ¼ k.
Definition 4. Let p ¼ ði; j; kÞ denote a voxel p of a 3D binary
image. Let V ¼ fp j p ¼ ði; j; kÞ, p is either a 0-voxel or a
1-voxel, 0  i; j; k  N  1g denote a 3D binary image of size
N
N
N. Let B3D ¼ fq j q ¼ ðx; y; zÞ, q is a 1-voxel, 0 
x; y; z  N  1g represent the set of the 1-voxels of the
3D binary image. Then, the 3D Euclidean distance transform
(3D_EDT) of voxel p with respect to its nearest 1-voxel N p is
denoted by
qffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffiffi
3d edtp ¼ min ði  xÞ2 þ ðj  yÞ2 þ ðk  zÞ2
q2B3D
and the 3D_EDT of V is to compute f3d edtp j for all p 2 Vg.
Definition 5. Let V ¼ fðx; y; zÞ j 0  x; y; z  N  1g be a
3D binary image of size N
N
N voxels. A
k plane as
shown in Fig. 4 can be represented as fðx; y; kÞ j 0  x; y 
N  1; k is a fixed integerg in a 3D coordinate system. For
convenience, we denote each of these
k plane as Z-plane or
ð; ; kÞ. Then, V can be represented by f
k j 0  k  N  1g
also. We can generate a vertical column parallel to Z-axis by
picking up a pixel with fixed X- and Y -coordinates ðx; yÞ
from every
k plane, 0  k  N  1. Because there are N
N
pixels on each
k plane, so, there exists total N
N vertical
columns, each of them with different combination of x and
y values. For convenience, we denote each of these vertical
columns as Zx;y -column, Z-column, or ðx; y; Þ.
Definition 6. Let R ¼ ði; j; kÞ be a voxel R of V. Let N R denote
the nearest 1-voxel of the voxel R with respect to all 1-voxels in
V. Let N R ð
k Þ, where 0  k  N  1, denote the nearest
1-voxel
 of the voxel R with respect  to all 1-voxels in plane
k .
Let XN R ð
k Þ ; YN R ð
k Þ ; ZN R ð
k Þ denote the coordinates of
N R ð
k Þ. Clearly, ZN R ð
k Þ ¼ k.
WANG AND HORNG: AN Oð1Þ TIME ALGORITHM FOR THE 3D EUCLIDEAN DISTANCE TRANSFORM ON THE CRCW PRAM MODEL
Fig. 2. (a) An illustration of Lemma 1. (b). An illustration of Lemma 2.
Definition 7. For every 1-pixel q of a 2D binary image P, the
union of all the pixels in the plane that are closer to 1-pixel q
than to any other 1-pixels in P is defined to be the Voronoi
polygon of q and is denoted by VorðqÞ. For every 1-voxel q of
a 3D binary image V, the union of all the voxels in the 3D space
that are closer to 1-voxel q than to any other 1-voxels in V is
defined to be the Voronoi polyhedron of q and is denoted by
VorðqÞ. The union of all the Voronoi polygons in a 2D plane or
all the Voronoi polyhedra in a 3D space is defined to be the
Voronoi diagram.
2.3 Properties of EDTs
Lemma 1 introduces a property of 1D_EDT.
Lemma 1. Let Pi ¼ ði; rÞ; Pk ¼ ðk; rÞ; Pj ¼ ðj; rÞ; i < k < j, be
three 0-pixels located in column r which is parallel to X-axis.
Let N Pi ðCr Þ ¼ ðm; rÞ and N Pj ðCr Þ ¼ ðn; rÞ be the nearest
1-pixels of Pi and Pj in column r, respectively. Let N Pk ðCr Þ
¼ ðq; rÞ, then m  q  n. In other words, XN Pi ðCr Þ 
XN Pk ðCr Þ  XN Pj ðCr Þ . See Fig. 2a for the illustration of this
lemma.
The following lemmas introduce some properties of
2D_EDT.
Lemma 2. Let Pk ¼ ði; kÞ, 0  k  N  1, be a sequence of
pixels located in row i which is parallel to Y -axis. Let N Pk be
the nearest 1-pixel of pixel Pk in the 2D space. Then,
N Pk 2 fN Pr ðCr Þ j 0  r  N  1g, 0  k  N  1. It means
that the nearest 1-pixel of Pk in the 2D space must be one of
N P0 ðC0 Þ; N P1 ðC1 Þ; . . . ; N PN1 ðCN1 Þ.
Proof. See Fig. 2b for the illustration of Lemma 2. Suppose
there is a pixel Pk ¼ ði; kÞ, 0  k  N  1, such that
N Pk ¼ ðs; rÞ is not included in fN Pr ðCr Þ j 0  r  N  1g.
Assume Pr ¼ ði; rÞ and N Pr ðCr Þ ¼ ðt; rÞ, then jPr N Pr ðCr Þj
¼ ji  tj < ji  sj ¼ jPr N Pk j. Therefore,
jPk N Pr ðCr Þj ¼ ðði  tÞ2 þ ðk  rÞ2 Þ1=2
< ðði  sÞ2 þ ðk  rÞ2 Þ1=2 ¼ jPk N Pk j:
It means that pixel Pk is closer to pixel N Pr ðCr Þ than to
the pixel N Pk with coordinates ðs; rÞ. A contradiction. t u
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
975
Lemma 3. Let Pi ¼ ðx; iÞ, Pk ¼ ðx; kÞ, and Pj ¼ ðx; jÞ;
i < k < j, be three 0-pixels located in row x which is parallel
to Y -axis. Let N Pi ¼ ðm; rÞ and N Pj ¼ ðn; sÞ be the nearest
1-pixels of Pi and Pj , respectively. Then, N Pk ¼ ðp; qÞ locates
between columns r and s. That is, r  q  s. In other words,
YN Pi  YN Pk  YN Pj .
Proof. See Fig. 3 for the illustration of Lemma 3. The
statement of the lemma means that ðm  xÞ2 þ ðr  iÞ2 
ðpxÞ2 þðq  iÞ2 and ðpxÞ2 þðqkÞ2  ðmxÞ2 þðr kÞ2 .
Adding this two inequalities, we get rðk  iÞ  qðk  iÞ.
Since i < k, so r  q. Similarly, ðp  xÞ2 þ ðq  kÞ2 
ðnxÞ2 þðskÞ2 and ðnxÞ2 þðsjÞ2  ðpxÞ2 þðq  jÞ2 .
Adding this two inequalities, we get kðj  kÞ  sðj  kÞ.
Since k < j, so q  s. Therefore, r  q  s. u
t
The following lemmas introduce some properties of
3D_EDT.
Lemma 4 [20], [31]. Let Qk ¼ ðXQk ; YQk ; kÞ be a sequence of
voxels located at plane
k , 0  k  N  1, with each of them
in the same Z-column. Let N Qk be the nearest 1-voxel of voxel
Qk in the 3D space. Then, N Qk 2 fN Qr ð
r Þ j 0  k;
r  N  1g. It means that the nearest 1-voxel of Qk in
the 3D space must be one of N Q0 ð
0 Þ; N Q1 ð
1 Þ; . . . ;
N QN1 ð
N1 Þ. This lemma can be proven in the same way
as shown in Lemma 2. See Fig. 4 for the illustration of this
lemma.
Lemma 5. Let Qi ¼ ðx; y; iÞ, Qk ¼ ðx; y; kÞ, and Qj ¼ ðx; y; jÞ,
where i < k < j, be three 0-voxels located in the same
Zx;y -column. Let N Qi ¼ ðm; n; rÞ2
r and N Qj ¼ ðu; v; sÞ 2
s
be the nearest 1-voxels of Qi and Qj in the 3D space,
respectively. Then, NQk ¼ ðp; q; zÞ locates between Z-planes
r
and
s . That is, r  z  s. In other words, ZN Qi  ZN Qk  ZN Qj .
Fig. 3. An illustration of Lemma 3.
976 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS, VOL. 14, NO. 10, OCTOBER 2003

Fig. 4. An illustration of Lemma 4. Fig. 5. An illustration of Lemma 5.

Pc 2i
Qc 2i
Proof. See Fig. 5 for the illustration of Lemma 5. The Proof. Since i¼0 2cþ1 1 ¼ 1, therefore, N ¼ i¼0 N 2cþ1 1 . That
statement of the lemma means that is,
20 21 22 2c
ðm  xÞ2 þ ðn  yÞ2 þ ðr  iÞ2 N ¼ N 2cþ1 1
N 2cþ1 1
N 2cþ1 1
; . . . ;
N 2cþ1 1 :
 ðp  xÞ2 þ ðq  yÞ2 þ ðz  iÞ2 ; and
For example, N can be decomposed into N 1=3
N 2=3 if
ðp  xÞ2 þ ðq  yÞ2 þ ðz  kÞ2
c ¼ 1 or N 1=7
N 2=7
N 4=7 if c ¼ 2. Our general max-
2 2 2
 ðm  xÞ þ ðn  yÞ þ ðr  kÞ :
imum (minimum) finding algorithm is proceeded in
Adding these two inequalities, we get rðk  iÞ  zðk  iÞ. iterations by applying the basic maximum (minimum)
Since i < k, r  z. Similarly,
finding method. After each iteration, a fraction of the
2 2 2
ðp  xÞ þ ðq  yÞ þ ðz  kÞ number of previously survived elements are eliminated
2 2 2
 ðu  xÞ þ ðv  yÞ þ ðs  kÞ ; and from further consideration. We describe the details as
2cþ1
2 2 2
ðu  xÞ þ ðv  yÞ þ ðs  jÞ follows: In the first step, the N 1þ (i.e., N 2cþ1 1 ) processors
2cþ1 21 20
 ðp  xÞ2 þ ðq  yÞ2 þ ðz  jÞ2 : are partitioned into N 2cþ1 1 subsets each of size N 2cþ1 1

20
N 2cþ1 1 as shown in Fig. 6a. Each subset is responsible for
Adding this two inequalities, we get zðj  kÞ  sðj  kÞ. 20
Since k < j, so z  s. Therefore, r  z  s. u
t finding the maximum (minimum) of N 2cþ1 1 numbers in
Oð1Þ time by invoking the basic maximum (minimum)
finding method. After the first step, only the maximum
3 THE GENERAL MAXIMUM (MINIMUM) (minimum) in each subset survives. Therefore, we are
FINDING ALGORITHM 2cþ1 21
left with N 2cþ1 1 data elements. In the second step, the
In [18], the well-known task of finding the maximum 2cþ1 22
N 1þ processors are further partitioned into N 2cþ1 1
(minimum) of an N-item sequence can be performed in Oð1Þ 21 21
time using N 2 CRCW processors. This method is termed as subsets each of size N 2cþ1 1
N 2cþ1 1 as shown in Fig. 6b.
the basic maximum (minimum) finding method. It first Like before, each subset is responsible for finding the
performs comparisons between all pairs of N-item. Then, 21
maximum (minimum) of N 2cþ1 1 numbers in Oð1Þ time.
based on the ability of the concurrent write of the same
value, the maximum (minimum) item can be identified as Similarly, after the second step, only the maximum
the only item that comes out a “winner” in all its (minimum) in each subset survives and we are left with
comparisons. Based on this well-known result, a general 2cþ1 22
N 2cþ1 1 data elements. The steps described above can be
maximum (minimum) finding algorithm is derived in the
same time complexity but reducing the number of performed iteratively. Finally, in the ðc þ 1Þ-th step,
processors from N 2 to N 1þ , where  ¼ 2cþ111 , c is a constant where c is a constant, the N 1þ processors are partitioned
and positive integer. 2cþ1 2cþ1 2c 2c
into N 2cþ1 1 ¼ N 0 ¼ 1 subset of size N 2cþ1 1
N 2cþ1 1 as
Lemma 6. The task of finding the maximum (minimum) of an
shown in Fig. 6c. This subset is responsible for finding
N-item sequence can be performed in Oð1Þ time using N 1þ 2c

CRCW processors, where  ¼ 2cþ111 , c is a constant and the maximum (minimum) of the remaining N 2cþ1 1
positive integer. numbers in Oð1Þ time. After this step, the maximum

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
WANG AND HORNG: AN Oð1Þ TIME ALGORITHM FOR THE 3D EUCLIDEAN DISTANCE TRANSFORM ON THE CRCW PRAM MODEL
Fig. 6. An illustration of the partition.
(minimum) of the N data elements is computed. The
overall time is OðcÞ. Since c is a constant, the maximum
2cþ1
(minimum) can be computed in Oð1Þ time using N 2cþ1 1
(i.e., N 1þ Þ processors.
A good feature of this algorithm is that the  converges
toward zero very fast, and the processors are always fully
utilized during their execution. This algorithm can be used
to solve lots of other related parallel computation problems.
4 PARALLEL ALGORITHMS FOR COMPUTING EDTs
In this section, ALGORITHM General_Dimension_Expander
is first introduced. Then, ALGORITHM 2D_EDT_CRCW and
ALGORITHM 3D_EDT_CRCW follow.
4.1 Parallel Algorithm for
General_Dimension_Expander
4.1.1 Description of Algorithm
We design this algorithm to support a route to cross from a
lower dimension to a higher dimension. It can be used to
solve the 1D nearest-one problem, to interconnect all
independent columns of a 2D plane through a row, or to
interconnect all independent Z-planes of a 3D space through
a Z-column. Throughout this algorithm, based on Lemmas 1,
3, and 5, we do the data partition to shrink the candidates of
the nearest 1-point of a point into as small range as possible.
Then, we apply Lemma 2 and Lemma 4 to find the nearest
1-point of a point. The detailed description of this parallel
algorithm is stated as follows:
ALGORITHM General_Dimension_Expander
Case 1D: To solve the 1D nearest-one problem.
Input: For a fixed column r of a 2D N
N binary image,
each point bl ¼ ðl; rÞ, 0  l  N  1, of zeros and ones.
Output: Each of the input pixels bl ¼ ðl; rÞ, 0  l  N  1,
being assigned the coordinates of N bl ðCr Þ ¼ ðXN bl ðCr Þ ; rÞ,
and the associated 1d edtbl ¼ jXN bl ðCr Þ  lj (i.e., the
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
977
1D_EDT of pixel bl ).
Case 2D: Interconnecting all independent columns of a
2D plane through a row to expand from a 1D line to a
2D plane.
u
t Input: For a fixed row r of a 2D N
N binary image, each
point bl ¼ ðr; lÞ, 0  l  N  1, holds the coordinates of
N bl ðCl Þ ¼ ðXN bl ðCl Þ ; lÞ and 1d edtbl ðCl Þ (i.e., the 1D_EDT
of pixel bl located at column l).
Output: Each of the input pixels bl ¼ ðr; lÞ, 0  l  N  1,
being assigned the coordinates of N bl ¼ðXN bl ; YN bl Þ, and
the associated 2d edtbl (i.e., the 2D_EDT of pixel bl ).
Case 3D: Interconnecting all independent Z-planes of a
3D space through a Z-column to expand from a 2D
plane to a 3D space.
Input: For a fixed Zs;t -column of a 3D N
N
N binary
image, each voxel bl ¼ ðs; t; lÞ, 0  l  N  1, holds the
coordinates of N bl ð
l Þ ¼ ðXN bl ð
l Þ ; YN bl ð
l Þ ; lÞ and
2d edtbl ð
l Þ (i.e., the 2D_EDT of voxel bl located at
l ).
Output: Each of the input pixels bl ¼ ðs; t; lÞ, 0  l  N  1,
being assigned the coordinates of
N bl ¼ ðXN bl ; YN bl ; ZN bl Þ, and the associated 3d edtbl (i.e.,
the 3D_EDT of pixel bl ).
Remarks. Without loss of generality, in this algorithm,
either a pixel of a plane or a voxel of a 3D space is
termed as a point for convenience. Different cases
perform the same routine. While invoking this
algorithm, the Input and Output depend on the
dimension of EDT computation. For simplicity, the
illustrations for this algorithm are based on Case 3D
only. Other cases can be done in a similar way.
Step 1: // Assume constant k is an acceptable constant
steps of this algorithm. We first partition the input of size
1 1
N into N k subsets each of size N 1k . Note that since both
1 1
1
N k and N k may not be an integer, so, we use the
ceilings and floors to solve this problem. First, we
1
partition the 1D input points of size N into bN k c subsets
1 1
S 1i0 , 0  i0  bN k c  1, each of size dN=bN k ce. Note that
1
since N=bN k c is not necessarily an integer also, so, we
978 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS, VOL. 14, NO. 10, OCTOBER 2003

Fig. 7. The illustrations for ALGORITHM General_Dimension_Expander of Case 3D. For clarity and simplicity, instead of presenting each N bl in its
individual Z-plane as shown in Fig. 5, we only show the Z-coordinate of N bl (i.e., ZN bl ) on a Z-column. The value of ZN bl implies in which Z-plane N bl
is located. (a) Illustration for Step 1. (b) Illustration for the result of Step 1. (c) Illustration for Step 2.1. (d) Illustration for Step 2.3.

1
use its ceilings (i.e., dN=bN k ce) as the size of each subset. 1.1 Partition the input points bl of size N into N k subsets
1

Then, the index of each point b 1 , 1 1

1
i0 dN=bN ce
k
S 1i0 , 0  i0  N k  1, each of size N 1k . Each subset
0  i0  bN k c  1, will be an integer and we can 1 1
partition these N points into equal size with no point S 1i0 ¼ fb 11
k þi1
j 0  i1  N 1k  1g; 0  i0  N k  1.
i0 N
missed. For readability and without loss of generality, in Refer to Fig. 7a for illustration.
1 1 1 1
this paper, bN k c is represented as N k and dN=bN k ce is 1.2 for point bN1 and each point b 1k1 , i0 :¼ 0 to N k  1
11k i0 N
represented as N , and all steps for partition can be pardo.
dealt with and represented in a similar way as described 1.3 Assign N 1þ processors to point bN1 and each point
above. Then, for point bN1 and each point b 1k1 , b 1k1 (the leader of each subset S 1i0 ) and find the
i0 N i0 N
1
0  i0  N k  1, find the nearest 1-points, N bN1 and nearest 1-points, N bN1 and N b 11 , respectively, within
i0 N k
N b 11 , respectively, within the input points of size N.// the input points of size N.
i0 N k

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
WANG AND HORNG: AN Oð1Þ TIME ALGORITHM FOR THE 3D EUCLIDEAN DISTANCE TRANSFORM ON THE CRCW PRAM MODEL 979

1
1.4 end; Proof. In Step 1, the input is partitioned into N k subsets;
Step 2: //Assume ½p; q denote the range from point p the nearest 1-point of each leader of each subset and
1
(included) to point q (included). Let bN1 will be computed in parallel. It takes N k
N 1þ ¼
1þk1þ
M1i0 ¼ ½ZN b ; ZN b : For the readability and N processors by Lemma 6. By Lemmas 1, 3, and 5,
11 11
i0 N k ði0 þ1ÞN k
P 1k 1 if any bk 2 S 1i0 , then ZN bk will be located within M1i0 .
analysis, assume N bN1 ¼ N bN . Also, N i0 ¼0 jM1i0 j  N:
1
In Step 2, we further partition each S 1i0 into N k subsets
Refer to Fig. 7b for illustration. For each subset S 1i0 , again, and find the nearest 1-point of the leader of
1
partition it into N k subsets and find the nearest 1-point of each newly created subset within M1i0 . In Step 2.3, for
the leader of each newly created subset again within 1
each subset S 1i0 , it takes jM1i0 j1þ
N k processors for
M1i0 . //
1 1
2.1 Partition each subset S 1i0 of size N 1k into N k subsets each point b 11 12
k þi1 N k
to find N b 11 12
within
1 2 i0 N i0 N k þi1 N k
1
S 2i0 ; i1 , 0  i0 ; i1  N k  1, each of size N k . Each Subset M1i0 by Lemma 6. Therefore, Step 2 takes
1
S 2i0 ;i1 ¼ fb 11k 12 j0  i0 ; i1  N k  1, 0 1 1
i0 N þi1 N kþi2
12k X
N k 1
0  i2  N  1g: Refer to Fig. 7c for illustration. 1
1 @ jM1i0 j1þ A
N k
2.2 for each point b 11k 12 , i0 :¼ 0 to N  1, i1 :¼ 0
k
1 i0 N þi1 N k i0 ¼0
to N k  1 pardo.
2.3 Assign jM1i0 j1þ processors to each point b 1k1
1

i0 N þi1 N
12
k
processors for every S 1i0 , 0  i0  N k  1, to be pro-
(the leader of each subset S 2i0 ;i1 ) and find its cessed in parallel. Since
1
corresponding nearest 1-point, N b 11 12
, X
N k 1
k þi1 N k
i0 N
jM1i0 j  N; then
respectively, within M1i0 . Refer to Fig. 7c for i0 ¼0
illustration. 1

2.4 end; X
N k 1

jM1i0 j1þ  N 1þ :

Step 3: Let M2i0 ;i1 ¼ ½ZN b 1 2
; ZN b 1 2
: i0 ¼0
1 1 1 1
i0 N k þi1 N k i0 N k þði1 þ1ÞN k
According to Lemmas 1, 3, and 5, if any point bk 2 S 2i0 ;i1 , So, Step 2 takes O(1) time using at most N 1þkþ
1

then ZN b will be located within M2i0 ;i1 and processors. Following Step 1 and Step 2, all computations
PN 1k 1 k
i1 ¼0 jM2i0 ;i1 j ¼ jM1i0 j: Based on Step 1 and Step 2, by done from Step 3 till Step k  1 can be done in O(1) time
1
using at most N 1þkþ processors. After k  1 steps, all
1
partitioning the S 2i0 ; i1 into N k subsets again each of size
1 1
1k3
N , the nearest 1-point of the leader of each subset can input are partitioned into N 1k subsets each of size N k . In
Step k:2, for each subset S k1i0 , it takes jMk1i0 j1þ
N k
1 1
be found in Oð1Þ time using N 1þkþ processors. Following
Step 3 till Step k  1, all computations done in each step processors for all of the points b 1k 2 S k1i0 to find
1
i0 N þi1
take Oð1Þ time and use at most N 1þkþ processors also. their corresponding nearest 1-points, N b 1 , within
i0 N k þi1
Here, the details of these steps are skipped and only Mk1i0 by Lemma 6. Therefore, Step k takes
Step k is stated as follows. 0 11 1
Step k: // From Step 1 till Step k  1, the input points bl of NX k 1
1
1
size N have been partitioned into N 1k subsets S k1i0 @ jMk1i0 j1þ A
N k
1
with each subset S k1i0 ¼ fb 1k j0  i1  N k  1g; i0 ¼0
i0 N þi1
11k 1
0  i0  N  1: For each point b
i0 N k
1 (the leader of each processors for every S k1i0 , 0  i0  N 1k  1, to be
subset S k1i0 ), its nearest 1-point N b has been processed in parallel. Since
1
i0 N k
computed also. Let Mk1i0 ¼ ½ZN b 1
; ZN b 1
: 11
NXk 1
i0 N k ði0 þ1ÞN k
jMk1i0 j  N; then
According to Lemmas 1, 3, and 5, if any point bk 2 S k1i0 , i0 ¼0
then ZN bk will be located within Mk1i0 . Also, 11
PN 11k 1 NXk 1

i0 ¼0 jMk1i0 j  N: // jMk1i0 j1þ  N 1þ :

1
k.1 for each point b 1k ; i0 :¼ 0 to N 1k  1; i1 :¼ 0 to i0 ¼0
1 i0 N þi1
N k  1 pardo. 1
So, Step k takes at most N 1þkþ processors. At the end of
k.2 For each subset S k1i0 , assign jMk1i0 j1þ processors to Step k, the nearest 1-points of all input points of size N
each point b 1k 2 S k1i0 and find its corresponding have been computed. u
t
i0 N þi1
nearest 1-point, N b 1 , respectively, within Mk1i0 .
i0 N k þi1
k.3 end; Corollary 1. The 1D nearest-one problem (i.e., 1D_EDT) of size
Therefore, ALGORITHM General_Dimension_Expander
1
N can be solved in Oð1Þ time using N 1þ
þ CRCW processors.
can be done in O(1) time using N 1þkþ processors.
4.2 Parallel Algorithm for 2D_EDT
Theorem 1. ALGORITHM General_Dimension_Expander can
be computed in Oð1Þ time using N 1þ
þ CRCW processors, 4.2.1 Description of Algorithm
where
¼ 1k ,  ¼ 2cþ111 , k, and c are constants and positive We apply ALGORITHM General_Dimension_Expander for
integers. Case 1D on a fixed column l, for every pixel br ¼ ðr; lÞ of

Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
980 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS,
column l to compute its nearest 1-pixel in column l. That is,
for a pixel br ¼ ðr; lÞ, we find its 1D_EDT from those pixels
with coordinates ð0; lÞ; ð1; lÞ; . . . ; and ðN  1; lÞ. After the
1D_EDT computation, every pixel br ¼ ðr; lÞ of column l has
held the output messages of 1D_EDT. They are 1d edtbr ðCl Þ
which is the 1D_EDT of pixel br and the coordinates of
N br ðCl Þ ¼ ðXN br ðCl Þ ; lÞ. Clearly,
1d edtbr ðCl Þ ¼ jbr N br ðCl Þj ¼ jXN br ðCl Þ  rj:
If no 1-pixel is in fð0; lÞ; ð1; lÞ; . . . ; ðN  1; lÞg, let XN br ¼ þ1.
There are N columns in a 2D binary image of size N
N. All
the N columns will execute 1D_EDT in parallel. This
completes the 1D_EDT computation phase. Now, we begin
the 2D_EDT computation phase. We compute the 2D nearest
1-pixel (i.e., 2D_EDT) for every pixel bl ¼ ðr; lÞ of a fixed row r
by invoking ALGORITHM General_Dimension_Expander for
Case 2D. There are N rows in a 2D binary image of size
N
N. All the N rows will execute ALGORITHM General_
Dimension_Expander for Case 2D in parallel. If there is no
1-pixel in the plane, let N bl ¼ ðþ1; þ1Þ. The parallel
algorithm for computing 2D_EDT is stated as follows:
ALGORITHM 2D_EDT_CRCW
Input: A 2D N
N binary image, each pixel being
represented by p ¼ ðr; lÞ, 0  r; l  N  1.
Output: A 2D N
N array, each pixel p ¼ ðr; lÞ being
assigned the coordinates of its 2D nearest 1-pixel
N p ¼ ðXN p ; YN p Þ and 2d edtp , which is the Euclidean
distance from p to its 2D nearest 1-pixel N p .
Remarks: For clarity, p ¼ ðr; lÞ is denoted by br ¼ ðr; lÞ in the
1D_EDT computation phase and denoted by bl ¼ ðr; lÞ
in the 2D_EDT computation phase.
Step 1: The 1D_EDT computation phase
1.1 for column l :¼ 0 to N  1 pardo.
1.2 Apply Corollary 1 for every pixel br ¼ ðr; lÞ of a fixed
column l to compute its 1D_EDT in parallel.
1.3 end;
Step 2: The 2D_EDT computation phase
2.1 for row r :¼ 0 to N  1 pardo
2.2 Based on the properties of Lemma 2 and Lemma 3, we
can apply ALGORITHM
General_Dimension_Expander for Case 2D on every
pixel bl ¼ ðr; lÞ of a fixed row r to compute its 2D_EDT
in parallel.
2.3 end;
4.2.2 Time Complexity Analysis
The complexity analysis of ALGORITHM 2D_EDT_CRCW
is stated as follows: We apply Corollary 1 in Step 1.2 to
solve the 1D nearest-one problem for one column of a 2D
N
N binary image. This can be performed in Oð1Þ time
using N 1þ
þ processors. So the 1D_EDT computation phase
done in Step 1 will take Oð1Þ time using N 2þ
þ processors
for all the columns l; 0  l  N  1, to compute 1D_EDT in
parallel. According to Theorem 1, Step 2.2 can be performed
in Oð1Þ time using N 1þ
þ processors for a single row. So the
2D_EDT computation phase done in Step 2 will take Oð1Þ
time using N 2þ
þ processors for all rows r; 0  r  N  1,
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
VOL. 14, NO. 10, OCTOBER 2003
to compute 2D_EDT in parallel. From the previous
discussion, we have the following result.
Theorem 2. The 2D_EDT of a binary image of size N
N can
be computed in Oð1Þ time using N 2þ
þ processors.
By Definition 7, if we assign every pixel p ¼ ði; jÞ the
coordinates of N p , instead of the Euclidean distance to its
nearest 1-pixel N p , then, for any 1-pixel q, VorðqÞ becomes
the set of all pixels which are assigned the coordinates of
1-pixel q. Then, the output of ALGORITHM 2D_EDT_
CRCW turns out to be the set fVorðqÞ j q ¼ N p ; p ¼ ði; jÞ;
0  i; j  N  1g. This concludes the following corollary.
Corollary 2. The Voronoi polygons and Voronoi diagram of a
binary image of size N
N can be constructed in Oð1Þ time
using N 2þ
þ CRCW processors.
4.3 Parallel Algorithm for 3D_EDT
4.3.1 Description of Algorithm
The parallel algorithm for computing 3D_EDT consists of
two phases: the Z-plane phase and the 3D_EDT computa-
tion phase. During the Z-plane phase, for each Z-plane
l ,
0  l  N  1, we find the 2D_EDT for each pixel in the
same
l plane. Clearly, there are total N independent planes
each of size N
N. This is a 2D_EDT problem which can be
implemented by ALGORITHM 2D_EDT_CRCW. At the end
of the Z-plane phase, each pixel Q ¼ ðs; tÞ in a fixed
l plane
has the coordinates of its nearest 1-pixel N Q ð
l Þ and the
2d edtQ ð
l Þ which represents the Euclidean distance from Q
to its nearest 1-pixel N Q ð
l Þ. If no 1-pixel is in the
l plane,
then N Q ð
l Þ ¼ ðþ1; þ1; lÞ. This completes the Z-plane
phase. Then, we begin the 3D_EDT computation phase. We
compute the 3D nearest 1-voxel (i.e., 3D_EDT) for every
voxel bl ¼ ðs; t; lÞ of a fixed Zs;t -column by invoking
ALGORITHM General_Dimension_Expander for Case 3D.
There are N
N Zs;t -columns in a 3D binary image of size
N
N
N. All of them will execute ALGORITHM
General_Dimension_Expander for Case 3D in parallel. The
parallel algorithm for computing 3D_EDT is stated as
follows:
ALGORITHM 3D_EDT_CRCW
Input: A 3D N
N
N binary image V, each voxel being
represented by Q ¼ ðs; t; lÞ, for 0  s; t; l  N  1.
Output: A 3D N
N
N array, each voxel Q being
assigned the coordinates of N Q ¼ ðXN Q ; YN Q ; ZN Q Þ and
3d edtQ which is the Euclidean distance from Q to its
nearest 1-voxel N Q .
Remarks: For clarity, Q ¼ ðs; t; lÞ is denoted by bs ¼ ðs; tÞ in
the 1D_EDT computation phase and denoted by
bt ¼ ðs; tÞ in the 2D_EDT computation phase while the
Z-plane phase is invoking ALGORITHM
2D_EDT_CRCW on each Z-plane
l . Also, Q ¼ ðs; t; lÞ is
denoted by bl ¼ ðs; t; lÞ in the 3D_EDT computation
phase.
Step 1: The Z-plane phase
1.1 for l :¼ 0 to N  1 pardo
1.2 Apply ALGORITHM 2D_EDT_CRCW on each
Z-plane
l .
1.3 end;
WANG AND HORNG: AN Oð1Þ TIME ALGORITHM FOR THE 3D EUCLIDEAN DISTANCE TRANSFORM ON THE CRCW PRAM MODEL
TABLE 1
Summary of Comparison Results for Parallel 2D_EDT Algorithms
TABLE 2
Summary of Comparison Results for Parallel 3D_EDT Algorithms
Step 2: The 3D_EDT computation phase
2.1 for s; t :¼ 0 to
N  1 pardo
2.2 Based on the properties of Lemma 4 and Lemma 5,
we can apply ALGORITHM
General_Dimension_Expander for Case 3D on every
Zs;t -column in parallel.
2.3 end;
4.3.2 Time Complexity Analysis
The complexity analysis of ALGORITHM 3D_EDT_CRCW
is stated as follows: In the Z-plane phase done in Step 1,
according to Theorem 2, each Z-plane can be processed in
Oð1Þ time using N 2þ
þ CRCW processors. Therefore, all the
N Z-planes can be processed in parallel in Oð1Þ time using
N 3þ
þ CRCW processors. In the 3D_EDT computation
phase done in Step 2, we apply ALGORITHM General_
Dimension_Expander for Case 3D on a fixed Zs;t -column in
parallel. According to Theorem 1, each of the N
N
Z-columns can be processed in Oð1Þ time using N 1þ
þ
CRCW processors. Therefore, all the N
N Z-columns can
be processed in parallel in Oð1Þ time using N 3þ
þ CRCW
processors. Based on the properties of Lemma 4 and
Lemma 5, it is easy to see that Step 2 performs the
3D_EDT computation. From the previous discussion, we
have the following result.
Theorem 3. The 3D_EDT of a binary image of size N
N
N
can be computed in Oð1Þ time using N 3þ
þ CRCW
processors.
Corollary 3. The Voronoi polyhedra and Voronoi diagram of a
binary image of size N
N
N can be constructed in Oð1Þ
time using N 3þ
þ CRCW processors.
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
981
5 CONCLUDING REMARKS
Based on the dimensionality reduction technique, we
develop a parallel algorithm for the 2D_EDT of a binary
image of size N
N in Oð1Þ time using N 2þ
þ CRCW
processors and a parallel algorithm for the 3D_EDT of a
binary image of size N
N
N in Oð1Þ time using N 3þ
þ
CRCW processors. Our parallel 2D_EDT (3D_EDT) algo-
rithm can be used to build up Voronoi diagram and
Voronoi polygons (polyhedra) and can be performed in
Oð1Þ time using N 2þ
þ ðN 3þ
þ Þ CRCW processors also.
Table 1 and Table 2 show the comparison results for parallel
2D_EDT and 3D_EDT computations. To the best of our
knowledge, all results derived above are the best Oð1Þ time
algorithms known.
ACKNOWLEDGMENTS
The authors would like to thank the anonymous referees for
their careful reading of this paper and for their valuable and
constructive comments, which have helped to improve the
quality of the paper. The work was partly supported by
National Science Council under contract number NSC-89-
2213-E011-007.
REFERENCES
[1] S.G. Akl, Parallel Computation: Models and Methods. Prentice-Hall,
1997.
[2] C. Arcelli and G. Sanniti di Baja, “Computing Voronoi Diagrams
in Digital Pictures,” Pattern Recognition Letters, vol. 4, pp. 383-389,
1986.
[3] H. Blum, “A Transformation for Extracting New Descriptors of
Shape,” Models for the Perception of Speech and Visual Form,
W. Wathen Dunn, ed., pp. 362-380, 1967.
982 IEEE TRANSACTIONS ON PARALLEL AND DISTRIBUTED SYSTEMS,
[4] G. Borgefors, “Distance Transformations in Arbitrary Dimen-
sions,” Computer Vision, Graphics, and Image Processing, vol. 27,
pp. 321-345, 1984.
[5] G. Borgefors, “Applications of Distance Transforms,” Aspects of
Visual Form Processing, pp. 83-108, 1994.
[6] G. Borgefors, “On Digital Distance Transforms in Three Dimen-
sions,” Computer Vision, Graphics, and Image Processing, vol. 64,
pp. 368-376, 1996.
[7] L. Boxer and R. Miller, “Efficient Computing of the Euclidean
Distance Transform,” Computer Vision and Image Understanding,
vol. 80, pp. 379-383, 2000.
[8] H. Breu, J. Gil, D. Kirkpatrick, and M. Werman, “Linear Time
Euclidean Distance Transform Algorithms,” IEEE Trans. Pattern
Analysis and Machine Intelligence, vol. 17, pp. 529-533, 1995.
[9] L. Chen, “Optimal Algorithm for Complete Euclidean Distance
Transform,” Chinese J. Computers, vol. 18, no. 8, pp. 611-616, 1995.
[10] L. Chen and H.Y.H. Chuang, “A Fast Algorithm for Euclidean
Distance Transforms of a 2D Binary Image,” Information Processing
Letters, vol. 51, pp. 25-29, 1994.
[11] P.E. Danielsson, “Euclidean Distance Mapping,” Computer Vision,
Graphics, and Image Processing, vol. 14, pp. 227-248, 1980.
[12] A. Datta and S. Soundaralakshmi, “Constant-Time Algorithm for
the Euclidean Distance Transform on Reconfigurable Meshes,”
J. Parallel and Distributed Computing, vol. 61, pp. 1439-1455, 2001.
[13] A. Datta and S. Soundaralakshmi, “Fast and Scalable Algorithms
for the Euclidean Distance Transform on the LARPBS,” Proc. 15th
Int’l Parallel and Distributed Processing Symp., pp. 1393-1400, 2001.
[14] H.N. Djidjev and A. Lingas, “On Computing Voronoi Diagrams
for Sorted Point Sets,” Int’l J. Computational Geometry and
Applications, 1995.
[15] A. Fujiwara, T. Masuzawa, and H. Fujiwara, “An Optimal Parallel
Algorithm for the Euclidean Distance Maps of 2D Binary Images,”
Information Processing Letters, vol. 54, pp. 295-300, 1995.
[16] T. Hayashi, K. Nakano, and S. Olariu, “Optimal Parallel
Algorithms for Finding Proximate Points, with Applications,”
IEEE Trans. Parallel and Distributed Systems, vol. 9, no. 3, pp. 1153-
1166, Mar. 1998.
[17] T. Hirata, “A Unified Linear-Time Algorithm for Computing Distant
Maps,” Information Processing Letters, vol. 58, pp. 129-133, 1996.
[18] J. JáJá, An Introduction to Parallel Algorithms. Addison-Wesley,
1992.
[19] M.N. Kolountzakis and K.N. Kutulakos, “Fast Computation of the
Euclidean Distance Maps for Binary Images,” Information Proces-
sing Letters, vol. 43, pp. 181-184, 1992.
[20] Y.H. Lee, S.J. Horng, and J. Seitzer, “Fast Computation of the
3D Euclidean Distance Transform on the EREW PRAM Model,”
Proc. 2001 Int’l Conf. Parallel Processing, pp. 471-478, 2001.
[21] Y.H. Lee, S.J. Horng, and J. Seitzer, “Parallel Computation of the
Euclidean Distance Transform on a Three Dimensional Image
Array,” IEEE Trans. Parallel and Distributed Systems, vol. 14, no. 3,
pp. 203-212, Mar. 2003.
[22] Y.H. Lee, S.J. Horng, T.W. Kao, F.S. Jaung, Y.J. Chen, and H.R.
Tsai, “Parallel Computation of Exact Euclidean Distance Trans-
form,” Parallel Computing, vol. 22, pp. 311-325, 1996.
[23] Y. Pan and K. Li, “Constant-Time Algorithm for Computing the
Euclidean Distance Maps of Binary Images on 2D Meshes with
Reconfigurable Buses,” Information Science, vol. 120, pp. 209-221,
1999.
[24] Y. Pan, Y. Li, J. Li, K. Li, and S.-Q. Zheng, “Computing Distance
Maps Efficiently Using an Optical Bus,” Proc. IPDPS 2000
Workshop Parallel and Distributed Computing in Image Processing,
Video Processing and Multimedia (PDIVM 2000), pp. 178-185, 2000.
[25] Y. Pan, Y. Li, J. Li, K. Li, and S.-Q. Zheng, “Efficient Parallel
Algorithms for Distance Maps of 2D Binary Images Using an
Optical Bus,” IEEE Trans. Systems, Man, and Cybernetics-Part A:
Systems and Humans, vol. 32, no. 2, pp. 228-236, 2002.
[26] S. Pavel and S.G. Akl, “Efficient Algorithms for Euclidean
Distance Transform,” Parallel Processing Letters, vol. 5, no. 2,
pp. 205-212, 1995.
[27] A. Rosenfeld and J.L. Pfalz, “Sequential Operations in Digital
Picture Processing,” J. ACM, vol. 13, pp. 471-494, 1966.
[28] A. Rosenfeld and J.L. Pfalz, “Distance Function on Digital
Pictures,” Pattern Recognition, vol. 1, pp. 33-61, 1968.
[29] T. Saito and J.I. Toriwaki, “New Algorithms for Euclidean
Distance Transformation of an n-Dimensional Digitized Picture
with Applications,” Pattern Recognition, vol. 27, no. 11, pp. 1551-
1565, 1994.
Authorized licensed use limited to: The University of British Columbia Library. Downloaded on October 08,2021 at 15:52:13 UTC from IEEE Xplore. Restrictions apply.
VOL. 14, NO. 10, OCTOBER 2003
[30] Y. Shiloach and U. Vishkin, “Finding the Maximum, Merging and
Sorting in a Parallel Computation Model,” J. Algorithms, vol. 2,
no. 1, pp. 88-102, 1981.
[31] Y.R. Wang, S.J. Horng, Y.H. Lee, and P.Z. Lee, “Parallel
Algorithms for Higher-Dimensional Euclidean Distance Trans-
forms with Applications,” Proc. Third Int’l Conf. Parallel and
Distributed Computing, Applications and Technologies (PDCAT ’02),
pp. 159-166, 2002.
[32] Y.R. Wang and S.J. Horng, “An Oð1Þ Time Parallel Algorithm for
the 3D Euclidean Distance Transform on the AROB,” Proc. Int’l
Conf. Parallel and Distributed Processing Techniques and Applications
(PDPTA ’02), pp. 1120-1126, 2002.
[33] Q.Z. Ye, “The Signed Euclidean Distance Transform and Its
Applications,” Proc. Ninth Int’l Conf. Pattern Recognition, pp. 495-
499, 1988.
Yuh-Rau Wang received the BS degree in
electrical engineering from National Cheng Kung
University, Taiwan, in 1976, the MS degree in
computer science from Polytechnic University,
Brooklyn Campus, New York, in 1987, and the
PhD degree in electrical engineering from
National Taiwan University of Science and
Technology, Taipei, Taiwan, in 2003. During
1987 to 1992, he was the director of the Image
Products Research and Development Depart-
ment, Peripheral Products Business Unit of Acer Group, Taipei, Taiwan.
From 1993 to 2003, he was a faculty member of Lan Yang Institute of
Technology, I-Lan, Taiwan. During 1993 to 1996, he was the director of
the Computer Center and the chairman of the Department of Information
Management of Lan Yang Institute of Technology, I-Lan, Taiwan.
Currently, he is an associate professor in the Department of Computer
Science and Information Engineering at St. John’s & St. Mary’s Institute
of Technology, Taipei, Taiwan. His research interests include image
processing, computer vision, and parallel algorithms.
Shi-Jinn Horng received the BS degree in
electronics engineering from National Taiwan
Institute of Technology, the MS degree in
information engineering from National Central
University, and the PhD degree in computer
science from National Tsing Hua University in
1980, 1984, and 1989, respectively. He has
published more than 100 research papers and
received many awards. Currently, he is a full
professor in the Department of Computer
Science and Information Engineering at National Taiwan University of
Science and Technology. His research interests include VLSI design,
multiprocessing systems, and parallel algorithms. For more information,
visit Dr. Horng’s homepage: http://gold.ee.ntust.edu.tw.
. For more information on this or any computing topic, please visit
our Digital Library at http://computer.org/publications/dlib.