How to make a drop-shadow for Graphics3D objects

Question

What's the best way to make a drop shadow for a 3D object?

 image = Graphics3D[Sphere[], Boxed -> False]

I can get a blurry black outline of this:

imageShadow = 
 Blur[RegionBinarize[ColorNegate[image], (* bottom left corner --> *) {{1, 1}}, 
   0.1], 20]

which could act as a good shadow:

But combining them together is a bit harder... Any suggestions?

Answer 1

This produces a 2D shadow. If you meant a 3D shadow (on the x-y plane), see code below.

image = Rasterize[Graphics3D[Sphere[], Boxed -> False]];
shadow = Blur[RegionBinarize[ColorNegate[image], {{1, 1}}, 0.1], 20];

image = SetAlphaChannel[image, ColorNegate@Binarize[image, {1, 1}]];

Show[{shadow, image}]

The position of the shadow has to be fine tuned manually.

I also managed to construct it in 3D (rotatable), though I cannot make the bottom polygon transparent.

shadow = Blur[
   RegionBinarize[Graphics[Circle[], ImagePadding -> 60], {{1, 1}}, 
    0.1], 40];
shadow = SetAlphaChannel[shadow, ColorNegate@shadow];

Graphics3D[{
  Sphere[],
  EdgeForm@None, Opacity@.7, Texture@shadow, 
  Polygon[{{-1, -1, -2}, {1, -1, -2}, {1, 1, -2}, {-1, 
     1, -2}, {-1, -1, -2}}, 
   VertexTextureCoordinates -> {{0, 0}, {1, 0}, {1, 1}, {0, 1}}]
  }, Boxed -> False]

Answer 2

Suppose you have a flat surface with normal n going through point p0 and a directional light with direction dir, then the shadow of a point p onto this surface can be calculated according to

proj[p0_, n_, dir_][p_] := p - (p - p0).Normalize[n]/dir.Normalize[n] dir

Suppose you have a shape created with a ParametricPlot3D, for example

pt[r_, ph_, th_] := {r Cos[ph] Sin[th], r Sin[ph] Sin[th], r Cos[th]}
rf[ph_, th_] := 3/2 + 2 Cos[2 th] Sin[ph]^2

shape = ParametricPlot3D[pt[rf[ph, th], ph, th], {ph, 0, 2 Pi}, {th, 0, Pi}, 
  Mesh -> False]

Then the shadow of this shape could be calculated according to

shdw = With[{p0 = {0, 0, -4}, n = {0, 0, 1}, dir = {1, 0, -1}},
   ParametricPlot3D[proj[p0, n, dir][pt[rf[ph, th], ph, th]], 
    {ph, 0, 2 Pi}, {th, 0, Pi}, Mesh -> False, PlotStyle -> Black]];

Show[shape, shdw, PlotRange -> All]

---

To get blurry edges on the shadow you could do something like this

With[{p0 = {0, 0, -4}, n = {0, 0, 1}, dir = {1/3, 1/2, -1},
    plotr = {{-8, 8}, {-8, 8}, {-5, 4}}},

  (* blurred image of shadow to be used as a texture *)
  tex = Blur[Rasterize[
    ParametricPlot[proj[p0, n, dir][pt[rf[ph, th], ph, th]][[;; 2]], 
      {ph, 0, 2 Pi}, {th, 0, Pi}, 
      Mesh -> False, 
      PlotStyle -> {Black, Opacity[1]}, 
      Axes -> False, Frame -> False,
      PlotRange -> plotr[[;; 2]],
      Background -> None], 
    Background -> None], 10];

  shdw = Graphics3D[{Texture[ImageData[tex]], EdgeForm[],
    Polygon[
      p0 + RotationTransform[{{0, 0, 1}, n}][Flatten[{#, 0}]] & /@ 
        Tuples[plotr[[;; 2]]][[{1, 2, 4, 3}]],
      VertexTextureCoordinates -> Tuples[{0, 1}, 2][[{1, 2, 4, 3}]]]}];

  Show[shdw, shape,
    Lighting -> {{"Directional", White, {0, -1, 1}}}, 
    PlotRange -> plotr,
    Axes -> False]]
  ]

Similar to István's solutions, I'm using a blurred rasterized image of the projected shape as a texture for the surface on which the shadow is projected. To get a transparent texture I'm using ImageData[tex] as the texture rather than tex itself. To get the scaling right when applying the texture, I'm using the same PlotRange for tex as for the polygon.

Answer 3

Since a drop shadow is a projection, I thought it's useful to provide a more general solution that creates this projection for arbitrary Graphics3D objects with less manual tuning. I am skipping the blur effect because I want to focus on the projection issue (Mathematica isn't a ray tracer, so I feel it's a bit too painful to simulate shadow boundaries using blur).

Here is my code:

project[x_, direction_, normal_] := 
 Module[{d, n},
  d = Normalize[direction];
  n = Normalize[normal];
  x /. Graphics3D[gr_, opts___] :> Graphics3D[{Black,
       GeometricTransformation[
        gr /. {Glow[_] -> Glow[], 
          r_?(MemberQ[{RGBColor, Hue, CMYKColor, GrayLevel}, 
               Head[#]] &) -> Black},
        Composition[TranslationTransform[direction],
         RotationTransform[{d, n}],
         ScalingTransform[10^-3, d], 
         Quiet@Check[ScalingTransform[1./(n.d), n - (n.d) d], Identity]
         ]
        ]}, opts
      ]
  ]

The argument x is a 3D plot or graphics object. The second variable, direction, is parallel to the light rays and its length is equal to the offset between the object and its shadow. The third argument, normal, is the normal vector of the surface onto which the shadow is projected.

To illustrate this, I'll define a sample object (displayed below with its shadow):

gg = Graphics3D[{{Opacity[.5], Cuboid[]}, {Blue, 
    Translate[Scale[Cuboid[], .2], {1, 1, 1}/2]}, , {Glow[Red], Red, 
    Translate[Scale[Sphere[], .5], -{1, 1, 1}/4]}}, Boxed -> False]

Now display it with some coordinate axis for orientation, assuming light going in the direction {0,1,1} and falling on a surface tilted into the space diagonal {1,1,1}:

Show[gg, 
     project[gg, 2.1 {0, 1, 1}, {1, 1, 1}],
     Graphics3D[{Map[{Apply[RGBColor, #], Arrow[Tube[{{0, 0, 0}, #}]]} &, 
    2 IdentityMatrix[3]]}]
]

The projection is stretched if the shadow surface isn't perpendicular to the rays. Of course there is the special case where the shadow surface is at a grazing angle to the light. I decided to handle this by not stretching the shadow.

Also observe that translucent regions create less dark shadows. And the whole thing is still a 3D object, not a bitmap.

Another example:

Show[gg, 
     project[gg, -1.5 {0, 0, 1}, {0, 1, 1}], 
     Graphics3D[{Map[{Apply[RGBColor, #], Arrow[Tube[{{0, 0, 0}, #}]]} &, 
    2 IdentityMatrix[3]]}]
]