Determine whether a 3D object is hidden by another 3D object - wpf

Question

I have some GeometryModel3D balls in a Viewport3D, Some of them are visible and some of them are hidden by a blue cube.
(Althouth the image below is in 2d lets pretend that all the objects are 3D)
I want to determine wich of the red balls can be seen and which are hidden.
How can I do this ?

Answer 1

This problem is also known as Occlusion Culling, although you're interested in counting the occluded primitives. Given the conditions of your scene, a brute force approach to solve this problem (given that you're using perspective projection) is the following pseudocode:
occludedSpheresCount = 0
spheres = {Set of spheres}
cubes = {Set of cubes}
normalizedCubes = {}
# First, build the set of normalized cubes (it means,
# take the cubes that are free in space and transform their
# coordinates to values between [-1, -1, -1] and [1, 1, 1], they are the same
# cubes but now the coordinates are laying in that range
# To do that, use the
ProjectionMatrix
projectionMatrix = GetProjectionMatrix(perspectiveCamera)
for each cube in cubes do
Rect3D boundingBox = cube.Bounds()
Rect3D normalizedBBox = projectionMatrix.transform(boundingBox)
cubes_normalized.add(normalizedBBox)
end for
# Now search every sphere, normalize it's bounding box
# and check if it's been occluded by some normalized cube
for each sphere in spheres do
Rect3D sphereBBox = sphere.Bounds()
Rect3D normalizedSphere = projectionMatrix.transform(sphereBBox)
for each normalizedCube in normalizedCubes do
x0 = normalizedCube.Location.X - (normalizedCube.Location.SizeX / 2)
y0 = normalizedCube.Location.Y - (normalizedCube.Location.SizeY / 2)
z0 = normalizedCube.Location.Z - (normalizedCube.Location.SizeZ / 2)
xf = normalizedCube.Location.X + (normalizedCube.Location.SizeX / 2)
yf = normalizedCube.Location.Y + (normalizedCube.Location.SizeY / 2)
sx0 <- normalizedSphere.Location.X - (normalizedSphere.Location.SizeX / 2)
sy0 <- normalizedSphere.Location.X - (normalizedSphere.Location.SizeY / 2)
sz0 <- normalizedSphere.Location.X - (normalizedSphere.Location.SizeZ / 2)
sxf <- normalizedSphere.Location.X + (normalizedSphere.Location.SizeX / 2)
syf <- normalizedSphere.Location.X + (normalizedSphere.Location.SizeY / 2)
# First, let's check that the normalized-sphere is behind the
# normalized-cube, to do that, let's compare their z-front values
if z0 > sz0 then
# Now that we know that the sphere is behind the frontface of the cube
# lets check if it is fully contained inside the
# the normalized-cube, in that case, it is occluded
if sx0 >= x0 and sxf <= xf and sy0 >= y0 and syf >= yf then
occludedSpheresCount++
# Here you can even avoid rendering the sphere altogether
end if
end if
end for
end for
A way to get the projectionMatrix is using the following code (extracted from here):
private static Matrix3D GetProjectionMatrix(PerspectiveCamera camera, double aspectRatio)
{
// This math is identical to what you find documented for
// D3DXMatrixPerspectiveFovRH with the exception that in
// WPF the camera's horizontal rather the vertical
// field-of-view is specified.
double hFoV = MathUtils.DegreesToRadians(camera.FieldOfView);
double zn = camera.NearPlaneDistance;
double zf = camera.FarPlaneDistance;
double xScale = 1 / Math.Tan(hFoV / 2);
double yScale = aspectRatio * xScale;
double m33 = (zf == double.PositiveInfinity) ? -1 : (zf / (zn - zf));
double m43 = zn * m33;
return new Matrix3D(
xScale, 0, 0, 0,
0, yScale, 0, 0,
0, 0, m33, -1,
0, 0, m43, 0);
}
The only drawback of this method is in the following case:
+--------------+--------------+
| -|- |
| / | \ |
| | | | |
| \ | / |
| -|- |
+--------------+--------------+
or
interception here
|
v
+----------+--+--------------+
| | -|- |
| /| | \ |
| | | | | |
| \| | / |
| | -|- |
+----------+--+--------------+
In which two intercepting cubes occlude the sphere, in that case, you have to build a set of sets of normalized cubes (Set{ Set{ cube1, cube2}, Set{cube3, cube4}, ... }) when two or more cube areas intercepts (that can be done in the first loop) and the contention test would be more complex. Don't know if that (cubes intercepting) is allowed in your program though
This algorithm is O(n^2) because is a brute force approach, hope this could give you a hint for the definitive solution, if you're looking for an efficient-more general solution, please use something like the Hierarchical Z Buffering