# Parallel Raster Scan for Euclidean Distance Transform

^{1}

^{2}

^{3}

^{*}

## Abstract

**:**

## 1. Introduction

## 2. Materials and Methods

Algorithm 1. Sequential Raster Scan DT. | |

REQUIRE | Img—A binary image |

ENSURE | $d$—A bidimentional matrix with distances of Img |

Initialize $d$for y = each line from the top of the Img thenfor x = each cell in the line from left to right thend(x,y) = min{ d(x,y), d(x,y) + C(x − 1,y), d(x,y) + C(x − 1,y − 1), d(x,y) + C(x,y − 1), d(x,y) + C(x + 1,y + 1)} for y = each line from the bottom of the Img thenfor x = each cell in the line from right to left thend(x,y) = min{ d(x,y), d(x,y) + C(x − 1,y + 1), d(x,y) + C(x,y + 1), d(x,y) + C(x + 1,y + 1), d(x,y) + C(x + 1,y)} |

Algorithm 2. Main PRSEDT | |

REQUIRE | Img—A binary image |

ENSURE | $DT$—A bidimentional matrix with distances of Img |

$VD$—The voronoi diagram of Img | |

cudaMemcpy($VD$, Img, cudaMemcpyHostToDevice)//copy Img from Host to Device blocks = (DIM/$n$, DIM/$n$)//Grid dimensions threads = ($n,n$)//Block dimensions initKernel<<blocks, threads>>($DT$, $VD$, $OB)$//Init $DT$ Equation (1), $VD$ Equation (2) and $OB$ blocks = (DIM/($n\times m$),DIM/($n\times m$))//Grid dimensions threads = (n,n)//Block dimensions cudaBindTexture(VD_Tex, VD) ;//Bind the $VD$ in global memory to VD_Tex in texture cudaBindTexture(DT_Tex, DT) ;//Bind the $VD$ in global memory to VD_Tex in texture cudaBindTexture(OB_Tex,OB) ;//Bind the $VD$ in global memory to VD_Tex in texture $count\text{}\leftarrow 1$ $ctrl\text{}\leftarrow 1$ repeat $flag\text{}\leftarrow false$//use memSet to set false the flag of the device blocks(DIM/($n\times m$),DIM/($n\times m$))//Grid dimensions threads($n,n$)//Block dimensions PRSEDTKernel <<blocks,threads>>($DT$, $VD$, $OB$, $flag$, $ctrl$) $count\text{}\leftarrow count+1$ if $count\text{}\text{}2\text{}$ then $ctrl\leftarrow {\left(\left(count-2\right)\times n\times m/2\right)}^{2}$ else $ctrl\leftarrow coun{t}^{2}$ Use cudaMemcpy to copy back the flag from device to host until $!flag$ float *DT_Host = (float*)malloc(imageSize); cudaMemcpy(DT_Host, $DT$, cudaMemcpyDeviceToHost); int *VD_Host = (int*)malloc(imageSize); cudaMemcpy(VD_Host, $VD$, cudaMemcpyDeviceToHost); |

Algorithm 3. | |

PRSEDTKernel (*$DT$, *$VD$, *$OB$, *$flag$, *$ctrl)$ | |

__shared__ bool $\mathrm{shOpt}$ __shared__ int $\mathrm{optimized}$ int $\mathrm{optreg}\leftarrow 0$ if $threadIdx.x==0$ AND $threadIdx.y==0\text{}$ then$optimized\leftarrow 0$ $\mathrm{shOpt}\leftarrow \mathrm{false}$ if $\mathrm{OB}\_Tex\left[blockIdx.x+blockIdx.y*gridDim.x\right]==1$ then$shOpt\leftarrow true$ syncthreads(); if $shOpt$ thenreturnshared float $memC\left[n\times m\right]\left[n\times m\right]$ shared int $ptr\left[n\times m+2\right]\left[n\times m+2\right]$ shared bool $shEnter$; $memC\leftarrow DT\_Tex\text{}\mathrm{TILE}\text{}\mathrm{of}\text{}{m}^{2}$ (access in a coalesced form) for each cell in $TILE\text{}of\text{}memC\text{}$if ${\mathrm{memC}}_{\mathrm{cell}}\le \mathrm{ctrl}$ then$\mathrm{optreg}++$ atomicAdd($optimized,optreg$) syncthreads() if $\mathrm{optimized}=={\left(n\times m\right)}^{2}$ then$\mathrm{OB}\left[\mathrm{blockIdx}.\mathrm{x}+\mathrm{blockIdx}.\mathrm{y}\times \mathrm{gridDim}.\mathrm{x}\right]\leftarrow \mathrm{true}$ return$\mathrm{ptr}\leftarrow VD\_Tex\text{}\mathrm{TILE}\text{}\mathrm{of}\text{}{\left(n\times m+2\right)}^{2}$ (access in a coalesced form) repeatsyncthreads(); if $\mathrm{threadIdx}.\mathrm{y}==0\text{}$and $\mathrm{threadIdx}.\mathrm{x}==0$ then$\mathrm{shEnter}\text{}\leftarrow \mathrm{false}$ syncthreads(); for each line from the top of the TILE thenfor each cell in the line of the TILE from left to right thenapply scan mask 1 (Figure 3a) evaluate $\text{}\mathrm{memC}$ and $\mathrm{ptr}$ according to Equations (3) and (4). if any update is made then$shEnter\text{}\leftarrow \mathrm{true}$ for each line from the bottom of the TILE thenfor each cell in the line of the TILE from right to left thenapply scan mask 2 (Figure 3b) evaluate $\text{}\mathrm{memC}$ and $\mathrm{ptr}$ according to Equations (3) and (4). if any update is made then$shEnter\text{}\leftarrow \mathrm{true}$ syncthreads() until $!shEnter$if any change in the TILE thenupdate $DT$ with corresponding TILE of $\mathrm{memC}$ update $VD$ with corresponding TILE of $\mathrm{ptr}$ $\mathrm{flag}\text{}\leftarrow \mathrm{true}$ |

## 3. Results

## 4. Conclusions

## Author Contributions

## Funding

## Conflicts of Interest

## References

- Lo Castro, D.; Tegolo, D.; Valenti, C. A visual framework to create photorealistic retinal vessels for diagnosis purposes. J. Biomed. Inform.
**2020**, 108, 103490. [Google Scholar] [CrossRef] [PubMed] - Fabbri, R.; Costa, L.D.F.; Torelli, J.C.; Bruno, O.M. 2D Euclidean distance transform algorithms: A comparative survey. ACM Comput. Surv.
**2008**, 40, 1–44. [Google Scholar] [CrossRef] - Ghafoor, A.; Iqbal, R.N.; Khan, S. Image matching using distance transform. In Image Analysis; Bigun, J., Gustavsson, T., Eds.; Springer: Berlin/Heidelberg, Germany, 2003; Volume 2749, pp. 654–660. ISBN 9783540406013. [Google Scholar]
- de Berg, M.; van Kreveld, M.; Overmars, M.; Schwarzkopf, O.C. Computational Geometry: Algorithms and Applications; Springer: Berlin/Heidelberg, Germany, 2000; ISBN 9783662042472. [Google Scholar]
- Arcelli, C.; di Baja, G.S.; Serino, L. Distance-Driven Skeletonization in Voxel Images. IEEE Trans. Pattern Anal. Mach. Intell.
**2011**, 33, 709–720. [Google Scholar] [CrossRef] - Noreen, I.; Khan, A.; Asghar, K.; Habib, Z. A Path-Planning Performance Comparison of RRT*-AB with MEA* in a 2-Dimensional Environment. Symmetry
**2019**, 11, 945. [Google Scholar] [CrossRef] [Green Version] - Lam, L.; Lee, S.-W.; Suen, C.Y. Thinning methodologies-a comprehensive survey. IEEE Trans. Pattern Anal. Mach. Intell.
**1992**, 14, 869–885. [Google Scholar] [CrossRef] [Green Version] - Rosenfeld, A.; Pfaltz, J.L. Sequential Operations in Digital Picture Processing. J. ACM
**1966**, 13, 471–494. [Google Scholar] [CrossRef] - Rosenfeld, A.; Pfaltz, J.L. Distance functions on digital pictures. Pattern Recognit.
**1968**, 1, 33–61. [Google Scholar] [CrossRef] - Borgefors, G. Distance transformations in digital images. Comput. Vis. Graph. Image Process.
**1986**, 34, 344–371. [Google Scholar] [CrossRef] - Akmal Butt, M.; Maragos, P. Optimum design of chamfer distance transforms. IEEE Trans. Image Process.
**1998**, 7, 1477–1484. [Google Scholar] [CrossRef] - Danielsson, P.-E. Euclidean distance mapping. Comput. Vis. Graph. Image Process.
**1980**, 14, 227–248. [Google Scholar] [CrossRef] [Green Version] - Ye, Q.-Z. The signed Euclidean distance transform and its applications. In Proceedings of the 9th International Conference on Pattern Recognition, Rome, Italy, 14 May–17 November 1988; IEEE Computer Society Press: Rome, Italy, 1988; pp. 495–499. [Google Scholar]
- Leymarie, F.; Levine, M.D. Fast raster scan distance propagation on the discrete rectangular lattice. CVGIP Image Underst.
**1992**, 55, 84–94. [Google Scholar] [CrossRef] - Ragnemalm, I. The Euclidean distance transform in arbitrary dimensions. Pattern Recognit. Lett.
**1993**, 14, 883–888. [Google Scholar] [CrossRef] - Cuisenaire, O.; Macq, V. Fast and exact signed Euclidean distance transformation with linear complexity. In Proceedings of the ICASSP99 (Cat. No.99CH36258), Phoenix, AZ, USA, 15–19 March 1999; Volume 6, pp. 3293–3296. [Google Scholar]
- Shih, F.Y.; Wu, Y.-T. The Efficient Algorithms for Achieving Euclidean Distance Transformation. IEEE Trans. Image Process.
**2004**, 13, 1078–1091. [Google Scholar] [CrossRef] [PubMed] - Shih, F.Y.; Wu, Y.-T. Fast Euclidean distance transformation in two scans using a 3 × 3 neighborhood. Comput. Vis. Image Underst.
**2004**, 93, 195–205. [Google Scholar] [CrossRef] - Grevera, G.J. The “dead reckoning” signed distance transform. Comput. Vis. Image Underst.
**2004**, 95, 317–333. [Google Scholar] [CrossRef] - Paglieroni, D.W. Distance transforms: Properties and machine vision applications. CVGIP Graph. Models Image Process.
**1992**, 54, 56–74. [Google Scholar] [CrossRef] - Paglieroni, D.W. A unified distance transform algorithm and architecture. Mach. Vis. Appl.
**1992**, 5, 47–55. [Google Scholar] [CrossRef] - Saito, T.; Toriwaki, J.-I. New algorithms for euclidean distance transformation of an n-dimensional digitized picture with applications. Pattern Recognit.
**1994**, 27, 1551–1565. [Google Scholar] [CrossRef] - Piper, J.; Granum, E. Computing distance transformations in convex and non-convex domains. Pattern Recognit.
**1987**, 20, 599–615. [Google Scholar] [CrossRef] - Verwer, B.J.H.; Verbeek, P.W.; Dekker, S.T. An efficient uniform cost algorithm applied to distance transforms. IEEE Trans. Pattern Anal. Mach. Intell.
**1989**, 11, 425–429. [Google Scholar] [CrossRef] - Ragnemalm, I. Neighborhoods for distance transformations using ordered propagation. CVGIP Image Underst.
**1992**, 56, 399–409. [Google Scholar] [CrossRef] - Eggers, H. Two Fast Euclidean Distance Transformations in Z2 Based on Sufficient Propagation. Comput. Vis. Image Underst.
**1998**, 69, 106–116. [Google Scholar] [CrossRef] - Sharaiha, Y.M.; Christofides, N. A graph-theoretic approach to distance transformations. Pattern Recognit. Lett.
**1994**, 15, 1035–1041. [Google Scholar] [CrossRef] - Falcao, A.X.; Stolfi, J.; de Alencar Lotufo, R. The image foresting transform: Theory, algorithms, and applications. IEEE Trans. Pattern Anal. Mach. Intell.
**2004**, 26, 19–29. [Google Scholar] [CrossRef] [PubMed] [Green Version] - Cuisenaire, O.; Macq, B. Fast Euclidean Distance Transformation by Propagation Using Multiple Neighborhoods. Comput. Vis. Image Underst.
**1999**, 76, 163–172. [Google Scholar] [CrossRef] [Green Version] - Cao, T.-T.; Tang, K.; Mohamed, A.; Tan, T.-S. Parallel Banding Algorithm to compute exact distance transform with the GPU. In Proceedings of the ACM SIGGRAPH Symposium on Interactive 3D Graphics and Games-I3D 10, Maryland, MD, USA, 19–21 February 2010; ACM Press: Washington, DC, USA, 2010; p. 83. [Google Scholar]
- Manduhu, M.; Jones, M.W. A Work Efficient Parallel Algorithm for Exact Euclidean Distance Transform. IEEE Trans. Image Process.
**2019**, 28, 5322–5335. [Google Scholar] [CrossRef] - de Assis Zampirolli, F.; Filipe, L. A Fast CUDA-Based Implementation for the Euclidean Distance Transform. In Proceedings of the 2017 International Conference on High Performance Computing & Simulation (HPCS), Genoa, Italy, 17 July 2017; IEEE: Genoa, Italy, 2017; pp. 815–818. [Google Scholar]
- Rong, G.; Tan, T.-S. Jump flooding in GPU with applications to Voronoi diagram and distance transform. In Proceedings of the 2006 symposium on Interactive 3D graphics and games-SI3D ’06, Redwood City, CA, USA, 14–17 March 2006; ACM Press: Redwood City, CA, USA; p. 109. [Google Scholar]
- Zheng, L.; Gui, Z.; Cai, R.; Fei, Y.; Zhang, G.; Xu, B. GPU-based efficient computation of power diagram. Comput. Graph.
**2019**, 80, 29–36. [Google Scholar] [CrossRef] - Schneider, J.; Kraus, M.; Westermann, R. GPU-based real-time discrete Euclidean distance transforms with precise error bounds. In Proceedings of the Fourth International Conference on Computer Vision Theory and Applications, Lisboa, Portugal, 5 February 2009; SciTePress—Science and Technology Publications: Lisboa, Portugal, 2009; pp. 435–442. [Google Scholar]
- Honda, T.; Yamamoto, S.; Honda, H.; Nakano, K.; Ito, Y. Simple and Fast Parallel Algorithms for the Voronoi Map and the Euclidean Distance Map, with GPU Implementations. In Proceedings of the 2017 46th International Conference on Parallel Processing (ICPP), Bristol, UK, 14 August 2017; IEEE: Bristol, UK, 2017; pp. 362–371. [Google Scholar]
- Cao, T.-T.; Tang, K.; Mohamed, A.; Tan, T.-S. Parallel Banding Algorithm Plus to Compute Exact Distance Transform with the GPU. Available online: https://www.comp.nus.edu.sg/~tants/pba.htm (accessed on 22 September 2020).

**Figure 1.**Scan mask metrics. (

**a**) City block forward mask; (

**b**) city block backward mask; (

**c**) chess board forward mask; (

**d**) chess board forward mask; (

**e**) Euclidean forward mask; (

**f**) Euclidean backward mask.

**Figure 2.**Grid of thread blocks. The block(k,l) represents each block of CUDA; a block of CUDA contains a number of threads, T(n,n), and a thread process a TILE; each cell of TILE C(x,y) represents a pixel of the input image.

**Figure 3.**Scan masks used in Parallel Raster Scan for Euclidean Distance Transform (PRSEDT). (

**a**) Raster scan mask 1, forward pass, from left to right, top to bottom; (

**b**) raster scan mask 2, backward pass, from right to left, bottom to top.

**Figure 5.**Input images with different densities of black pixels ($1024\times 1024$). (

**a**) 1%; (

**b**) 10%; (

**c**) 30%; (

**d**) 50%; (

**e**) 70%; (

**f**) 90%.

**Figure 6.**Example of distance transform and Voronoi diagram for an input image with random features. (

**a**) Input image with 0.1% density of black pixels; (

**b**) grayscale distance map, the color gradient is caused by the color table, to better visualize the distances; (

**c**) Voronoi diagram.

**Figure 7.**Timelines for an input image for 2048 × 2048 pixels and 30% density, showing memory data transfers and computing times. (

**a**) PRSEDT profiling; (

**b**) PBA+ profiling.

**Figure 9.**Results obtained from Lena input image for the $2048\times 2048$-pixel image. (

**a**) Gray scale distance map, the color gradient is caused by the color table, to better visualize the distances; (

**b**) Voronoi diagram.

**Figure 10.**Timelines for $2048\times 2048$-pixel Lena input image, showing memory data transfers and computing times. (

**a**) PRSEDT profiling; (

**b**) PBA+ profiling.

**Figure 11.**Results obtained from Mandril input image for the $2048\times 2048$-pixel image. (

**a**) Gray scale distance map, the color gradient is caused by the color table, to better visualize the distances; (

**b**) Voronoi diagram.

**Figure 12.**Timeline from Mandril input image for the $2048\times 2048$-pixel image showing memory copy and computing times. (

**a**) PRSEDT profiling; (

**b**) PBA+ profiling.

**Figure 13.**Results obtained from Retina input image for the $2048\times 2048$-pixel image. (

**a**) Gray scale distance map, the color gradient is caused by the color table, to better visualize the distances; (

**b**) Voronoi diagram.

**Figure 14.**Timelines for the $2048\times 2048$-pixel Retina input image, showing memory data transfers and computing times. (

**a**) PRSEDT profiling; (

**b**) PBA+ profiling.

Texture Size | m1 | m2 | m3 |
---|---|---|---|

512 × 512 | 8 | 16 | 8 |

1024 × 1024 | 16 | 32 | 8 |

2048 × 2048 | 32 | 32 | 8 |

4096 × 4096 | 64 | 32 | 4 |

8192 × 8192 | 64 | 32 | 4 |

16,384 × 16,384 | 128 | 32 | 4 |

Texture Size | TILERES | BSIZE |
---|---|---|

512 × 512 | 2 | 8 |

1024 × 1024 | 2 | 8 |

2048 × 2048 | 2 | 8 |

4096 × 4096 | 4 | 8 |

8192 × 8192 | 4 | 8 |

16,384 × 16,384 | 4 | 8 |

**Table 3.**Memory transfer times (milliseconds). Column HostToDevice indicates the transfer time of the image from the host to the device, while the DeviceToHost columns indicate the transfer time from the device to the host of the Distance transform (DT) and Voronoi diagram (VD) matrices, respectively.

Texture Size | PRSEDT | PBA+ | ||||
---|---|---|---|---|---|---|

HostToDevice | DeviceToHost | HostToDevice | DeviceToHost | |||

512 × 512 | 0.082 | 0.08042 | 0.0881 | 0.082 | 0.0809 | 0.0811 |

1024 × 1024 | 0.598 | 1.31 | 1.28 | 0.593 | 1.28 | 1.27 |

2048 × 2048 | 2.7979 | 6.49 | 6.56 | 2.91 | 6.35 | 6.19 |

4096 × 4096 | 12.11 | 26.95 | 26.93 | 12.1 | 26.79 | 26.68 |

8192 × 8192 | 49.5 | 108.64 | 108.89 | 48.8 | 108.72 | 109.01 |

16,384 × 16,384 | 191.63 | 438.94 | 439.01 | 194.01 | 438.61 | 438.5 |

**Table 4.**Running time (milliseconds) of each image with different densities of black pixels and different resolutions.

Density | Algorithm | $512\times 512$ | $1024\times 1024$ | $2048\times 2048$ | |||

ms | Speedup | ms | Speedup | ms | Speedup | ||

1% | PBA+ | 0.335 | 1.044 | 0.801 | 0.803 | 2.545 | 0.745 |

PRSEDT | 0.321 | 0.998 | 3.415 | ||||

10% | PBA+ | 0.38 | 1.827 | 0.968 | 1.763 | 3.111 | 1.590 |

PRSEDT | 0.208 | 0.549 | 1.956 | ||||

30% | PBA+ | 0.41 | 2.343 | 1.066 | 2.406 | 3.214 | 2.169 |

PRSEDT | 0.175 | 0.443 | 1.482 | ||||

50% | PBA+ | 0.408 | 2.684 | 1.074 | 3.294 | 3.181 | 3.233 |

PRSEDT | 0.152 | 0.326 | 0.984 | ||||

70% | PBA+ | 0.395 | 3.110 | 1.034 | 3.517 | 2.996 | 3.428 |

PRSEDT | 0.127 | 0.294 | 0.874 | ||||

90% | PBA+ | 0.382 | 3.441 | 0.985 | 3.717 | 2.87 | 3.470 |

PRSEDT | 0.111 | 0.265 | 0.827 | ||||

Density | Algorithm | $4096\times 4096$ | $8192\times 8192$ | $16,384\times 16,384$ | |||

ms | Speedup | ms | Speedup | ms | Speedup | ||

1% | PBA+ | 8.89 | 0.800 | 30.49 | 0.881 | 117.87 | 0.865 |

PRSEDT | 11.11 | 34.61 | 136.24 | ||||

10% | PBA+ | 10.25 | 1.253 | 36.13 | 1.401 | 136.95 | 1.363 |

PRSEDT | 8.18 | 25.79 | 100.5 | ||||

30% | PBA+ | 10.21 | 1.383 | 36.94 | 1.564 | 139.28 | 1.481 |

PRSEDT | 7.38 | 23.62 | 94.04 | ||||

50% | PBA+ | 9.93 | 2.315 | 35.82 | 2.588 | 135.99 | 2.508 |

PRSEDT | 4.29 | 13.84 | 54.23 | ||||

70% | PBA+ | 9.44 | 2.275 | 34.06 | 2.604 | 130.15 | 2.503 |

PRSEDT | 4.15 | 13.08 | 52 | ||||

90% | PBA+ | 9.01 | 2.346 | 32.78 | 2.646 | 121.08 | 2.478 |

PRSEDT | 3.84 | 12.39 | 48.86 |

Density | $512\times 512$ | $1024\times 1024$ | $2048\times 2048$ | $4096\times 4096$ | $8192\times 8192$ | $16,384\times 16,384$ |
---|---|---|---|---|---|---|

1% | 4 | 4 | 5 | 4 | 4 | 4 |

10% | 3 | 3 | 3 | 3 | 3 | 3 |

30% | 3 | 3 | 3 | 3 | 3 | 3 |

50% | 3 | 3 | 3 | 3 | 3 | 3 |

70% | 2 | 2 | 2 | 3 | 3 | 3 |

90% | 2 | 2 | 2 | 3 | 3 | 3 |

**Table 6.**Running time (milliseconds) of each image with different input images and different resolutions.

Image | Algorithm | 512 × 512 | 1024 × 1024 | 2048 × 2048 | |||

ms | Speedup | ms | Speedup | ms | Speedup | ||

Lena | PBA+ | 0.401 | 1.604 | 1.029 | 1.790 | 2.87 | 1.535 |

PRSEDT | 0.25 | 0.575 | 1.87 | ||||

Mandril | PBA+ | 0.434 | 1.507 | 1.074 | 1.554 | 2.99 | 1.187 |

PRSEDT | 0.288 | 0.691 | 2.52 | ||||

Retina | PBA+ | 0.402 | 2.871 | 0.993 | 3.193 | 2.82 | 3.099 |

PRSEDT | 0.14 | 0.311 | 0.91 | ||||

Image | Algorithm | 4096 × 4096 | 8192 × 8192 | 16,384 × 16,384 | |||

ms | Speedup | ms | Speedup | ms | Speedup | ||

Lena | PBA+ | 8.68 | 1.072 | 29.69 | 1.107 | 116.93 | 0.809 |

PRSEDT | 8.1 | 26.82 | 144.51 | ||||

Mandril | PBA+ | 9.24 | 0.857 | 30.81 | 0.812 | 116.66 | 0.566 |

PRSEDT | 10.78 | 37.94 | 206.29 | ||||

Retina | PBA+ | 8.72 | 2.047 | 30.24 | 2.625 | 114.24 | 2.587 |

PRSEDT | 4.26 | 11.52 | 44.16 |

Image | $512\times 512$ | $1024\times 1024$ | $2048\times 2048$ | $4096\times 4096$ | $8192\times 8192$ | $16,384\times 16,384$ |
---|---|---|---|---|---|---|

Lena | 5 | 8 | 14 | 15 | 27 | 51 |

Mandril | 6 | 8 | 14 | 14 | 28 | 54 |

Retina | 3 | 4 | 5 | 5 | 7 | 11 |

Publisher’s Note: MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations. |

© 2020 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Elizondo-Leal, J.C.; Ramirez-Torres, J.G.; Barrón-Zambrano, J.H.; Diaz-Manríquez, A.; Nuño-Maganda, M.A.; Saldivar-Alonso, V.P.
Parallel Raster Scan for Euclidean Distance Transform. *Symmetry* **2020**, *12*, 1808.
https://doi.org/10.3390/sym12111808

**AMA Style**

Elizondo-Leal JC, Ramirez-Torres JG, Barrón-Zambrano JH, Diaz-Manríquez A, Nuño-Maganda MA, Saldivar-Alonso VP.
Parallel Raster Scan for Euclidean Distance Transform. *Symmetry*. 2020; 12(11):1808.
https://doi.org/10.3390/sym12111808

**Chicago/Turabian Style**

Elizondo-Leal, Juan Carlos, José Gabriel Ramirez-Torres, Jose Hugo Barrón-Zambrano, Alan Diaz-Manríquez, Marco Aurelio Nuño-Maganda, and Vicente Paul Saldivar-Alonso.
2020. "Parallel Raster Scan for Euclidean Distance Transform" *Symmetry* 12, no. 11: 1808.
https://doi.org/10.3390/sym12111808