Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Can anybody point me in a direction that will guide me to extend the VoronoiDiagram function in Mathematica to handle 3D (three dimensional) situations (i.e. points in 3D)? Any help will be greatly appreciated.


The current VoronoiMesh function in V10 still does not compute 3D Voronoi diagrams, which is strange since both the DelaunayMesh and ConvexHullMesh functions work with 3D data sets. I guess the waiting continues.... For the Wolfram Research employees, any ideas on why this was omitted and timeframe for when this functionality will be included in Mathematica?

share|improve this question
see `ComputationalGeometryPackage – kglr Feb 1 '13 at 23:24
@kguler, the VoronoiDiagram function only takes 2D data points and outputs the Voronoi diagram of points in a plane. What I'm trying to create is an equivalent VoronoiDiagram that accepts 3D vectors. – RunnyKine Feb 1 '13 at 23:43

Update: Using Raster3D and a variation of func that returns 4-tuples

 data3C = RandomReal[1, {10, 6}]; 
 func3C = Nearest[{#, #2, #3} -> {##4, .03} & @@@ data3C];
 tbl3C = Table[  First[func3C[{x, y, z}]] // Quiet, {x, 0, 1, .01}, 
  {y, 0, 1, .01}, {z, 0, 1, .01}];


 Row[Labeled[Graphics3D[Raster3D[tbl3C, ColorFunction -> #,
  Method -> {"InterpolateValues" -> True}],
 Background -> Black, ImageSize -> 400, 
 SphericalRegion -> True], #, Top] & /@
{Hue, RGBColor, (GrayLevel[#[[1]], .03] &)}, Spacer[5]]

enter image description here

colorRules = Thread[# -> (ColorData[1, "ColorList"][[;; Length@#]])] &[
Flatten[tbl3C, 2] // DeleteDuplicates] /.  RGBColor -> List;
Row[Labeled[ Graphics3D[Raster3D[tbl3C /. colorRules, ColorFunction -> #,
  Method -> {"InterpolateValues" -> True}],
 Background -> Black, ImageSize -> 400, 
 SphericalRegion -> True], #, Top] & /@
{(RGBColor[#[[1]], #[[2]], #[[3]], .01] &),
(RGBColor[#[[1]], #[[2]], #[[3]], .03] &),
(RGBColor[#[[1]], #[[2]], #[[3]], .05] &)}, Spacer[5]]

enter image description here

Using version-9 built-in Image3D with @Mr.Wizard's func:

  data = RandomReal[1, {20, 4}]; 
  func = Nearest[{#, #2, #3} -> #4 & @@@ data];
  dta = Table[func[{x, y, z}] // Quiet, {x, 0, 1, .005}, {y, 0, 1, .005}, {z, 0,    1, .005}];

   ImageSize -> 350, ColorFunction -> #, Background -> Black] & /@
   {"SunsetColorsOpacity", "RainbowOpacity", "WhiteBlackOpacity",
    (Append[Blend[{LightBlue, Blue, Yellow}, #], #] &)}, 2]]

enter image description here

share|improve this answer
The free package Voro++ does all the tricks, but it is in C++. This package is used in LAMMPS (Large-scale Atomic/Molecular Massively Parallel Simulator) – saturasl Jul 15 '14 at 6:25

Mathematica ships with a TetGen interface called TetGenLink. To learn how to use TetGenLink is a bit more work than using the usual Mathematica functions, so I am not going to post a complete solution now.

But the way to go is using TetGenLink. It can compute a Delaunay tetrahedral mesh, which is the dual of the Voronoi partitioning. TetGen can also compute Voronoi partitions, but I am not sure if this function is exposed in TetGenLink, you'd have to check.

The function to use is TetGenTetrahedralize and I think you need to read the TetGen docs to understand the second argument (those flags should be the same as the command line options to TetGen).

share|improve this answer
Yes, TetGenLink is the way to go. – user21 Feb 2 '13 at 3:17
@ruebenko If you post an answer with the precise command, I'll delete this one. I'd have to keep reading the docs for a while to figure out the right syntax. – Szabolcs Feb 2 '13 at 3:18
well TetGen will not give you the Voronoi directly. You will need to construct the Voronoi from the tetrahedralization. – user21 Feb 2 '13 at 5:55
Have you found any undocumented Mathematica feature of the TetGenLink regarding Voronoi partitioning yet? I was not able to find any command which does the trick. – Rainer Sep 22 '13 at 22:02
Or one can use TetGen through LibraryLink. However when I have to obtain 3D Voronoi mesh I just write points to a text file p.node and run the sytem command tetgen -v p.node :) – ybeltukov Sep 21 '14 at 12:13

It would help if you gave an example of a 3D Voronoi diagram.

Perhaps you want something like this, using Nearest as I did here.

Warning: this is very slow and uses a lot of memory!

data = RandomReal[1, {20, 4}];

func = Nearest[{#, #2, #3} -> #4 & @@@ data];

 func[{x, y, z}] // Quiet,
 {x, 0, 1}, {y, 0, 1}, {z, 0, 1},
 ColorFunction -> (Hue@#3 &)

Mathematica graphics

Is that roughly what you want?

share|improve this answer

mPower is what your are looking for, which interfaces with Qhull

I have used this package with Mathematica 7 and 8 regularly on both Mac and Windows. let' do a testing installation with Mathematica 9 on Mac 10.8, you can just delete the folder directly after testing

mPower 1.0 for Mathematica 6.0

Qhull 12.01 Mac Bindary

for Windows binary, you can grab it directly from

uzip both packages, create a folder "qhull" under mpower folder, then copy "bin" folder from uzipped qhull package, put it under qhull folder you just created

in mPower folder open mPower.m in Mathematica

$QHULL::usage="$QHULL should contain the name (as a string) of the folder that contains the QHULL binaries on your system.
$QHULL=ToFileName[{$UserBaseDirectory, "Applications", "qhull", "src"}];

modify it to


or you can use absolute path directly

then create a new notebook file "test.nb" at the mPower folder

<< "mPower.m"

you will get two warnings

Warning: regtet binary not found. Expected location: /mPower-1.0-11-May-2008-1631/qhull/bin/

Warning: pwrvtx binary not found. Expected location: /mPower-1.0-11-May-2008-1631/qhull/bin/

ignore them, you are ready to use qhull interface now.

run the following code for testing:

(* random 3D points *)
points = RandomReal[1, {40, 3}];
(* construct 3D convexhull *)
ch = convexHull[points, convexHullFormat -> {facetNormals -> True, facets -> True}];
(* generate facets for 3D convexhull *)
facetIndices = facets /. ch;
loop[alist_] := Append[alist, alist[[1]]];
loopedFacetIndices = loop /@ facetIndices;
index2xyz[ijklist_] := points[[#]] & /@ ijklist;
loopedFacetCoordinates = index2xyz /@ loopedFacetIndices;
(* visulization 3D convexhull *)
convexObject = 
 Graphics3D[{PointSize[Large], Point[points], FaceForm[], 
   EdgeForm[Blue], Polygon /@ loopedFacetCoordinates}, 
  ImageSize -> 500]

check the documentation on boundedCellVoronoi, you can run the example code by copying them into test.nb you just created.

share|improve this answer
Looks relevant: – DavidC Feb 2 '13 at 3:43
This is quite a bare-bones answer. Please consider extending it, and adding an example if possible. – Mr.Wizard Feb 2 '13 at 5:53
@Mr.Wizard It's a link to a ready-made package that contains the functionality. The package seems to interface with a mature library, i.e. I expect it to be fast and accurate. I think this is a very useful answer and it leads the way to a solution that is much better than anything with Nearest. Lately I have the feeling that on this site we expect too much. Answers which don't give working code are not upvoted even if they give the key to the solution. The OP should really be able to handle it from here. If I were the OP, I'd focus on this answer first and accept as soon as I got it working. – Szabolcs Feb 2 '13 at 18:11
I took a look at the package, and it seems it's not immediately trivial to set it up with the current version of qhull. So I agree with MrW, if anyone gets it working, please describe how to do it. @Tuku did you get it working? – Szabolcs Feb 2 '13 at 20:25
@Szabolcs I don't discount that we ask a lot on this site, but I disagree that it is too much. Your reversal in the following comment is proof enough of this to me. Answers must be more than a signpost to the information needed to do it yourself, or half the Q's could be answered with a naked link to It is often very hard to determine what is or is not trivial until you attempt it yourself, and those who would vote on such as answer are negligent in their duty if they vote without the knowledge from doing so. And that would be expecting too much. – Mr.Wizard Feb 3 '13 at 4:55

The extension to 3D is quite non-trivial, and although Wizard's contour plot is impressive, it is an approximation. What you want does not exist in Mathematica. I might suggest Manifold Lab, which has its own issues but some incredible capabilities as well:
      enter image description here
Source: ggaliens [link broken, cannot find new one].

share|improve this answer
Actually it does exist in Mathematica, see my answer. – Szabolcs Feb 2 '13 at 3:23
Say, we have a tetrahedralization of the points and the circumcenter to the tets, how does on construct the Voronoi cell of these tetrahedron? – user21 Feb 2 '13 at 5:57
The Voronoi cells are bounded by the planar polygons formed by the centers of the circumspheres which include a given link in the tetrahedralization. – Xerxes Feb 2 '13 at 6:35
@Szabolcs: I am pleased to learn of TetGen! – Joseph O'Rourke Feb 2 '13 at 14:46
@reubenko: I don't understand your question; sorry. Let me say this. Moving from the Delaunay triangulation graph to the Voronoi diagram is a nontrivial computation. The edges of the DT graph give you bisector planes. To compute the Voronoi cells, you would have to compute the convex body delimited by these planes. It is theoretically simple but in practice not easy. This is why I am so impressed with the ManifoldLab capabilities. – Joseph O'Rourke Feb 3 '13 at 0:43

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.