# Obtaining the surface of a polyhedron (3D object)

advertisements

I have a 3D surface, (think about the xy plane). The plane can be slanted. (think about a slope road).

Given a list of 3D coordinates that define the surface(`Point3D1X`, `Point3D1Y`, `Point3D1Z`, `Point3D12X`, `Point3D2Y`, `Point3D2Z`, `Point3D3X`, `Point3D3Y`, `Point3D3Z`, and so on), how to calculate the area of the surface?

Note that my question here is analogous to finding area in 2D plane. In 2D plane we have a list of points that defines a polygon, and using this list of points we can find the area of the polygon. Now assuming that all these points have `z` values in such a way that they are elevated in 3D to form a surface. My question is how to find the area of that 3D surface?

Since you say it's a polyhedron, stacker's link (http://softsurfer.com/Archive/algorithm_0101/algorithm_0101.htm) is applicable.

Here's my approximate C# translation of the C code for your situation:

``````// NOTE: The original code contained the following notice:
// ---------------------------------------
// Copyright 2000 softSurfer, 2012 Dan Sunday
// This code may be freely used and modified for any purpose
// providing that this copyright notice is included with it.
// iSurfer.org makes no warranty for this code, and cannot be held
// liable for any real or imagined damage resulting from its use.
// Users of this code must verify correctness for their application.
// ---------------------------------------
// area3D_Polygon(): computes the area of a 3D planar polygon
//    Input:  int n = the number of vertices in the polygon
//            Point[] V = an array of n+2 vertices in a plane
//                       with V[n]=V and V[n+1]=V
//            Point N = unit normal vector of the polygon's plane
//    Return: the (float) area of the polygon
static float
area3D_Polygon( int n, Point3D[] V, Point3D N )
{
float area = 0;
float an, ax, ay, az;  // abs value of normal and its coords
int   coord;           // coord to ignore: 1=x, 2=y, 3=z
int   i, j, k;         // loop indices

// select largest abs coordinate to ignore for projection
ax = (N.x>0 ? N.x : -N.x);     // abs x-coord
ay = (N.y>0 ? N.y : -N.y);     // abs y-coord
az = (N.z>0 ? N.z : -N.z);     // abs z-coord

coord = 3;                     // ignore z-coord
if (ax > ay) {
if (ax > az) coord = 1;    // ignore x-coord
}
else if (ay > az) coord = 2;   // ignore y-coord

// compute area of the 2D projection
for (i=1, j=2, k=0; i<=n; i++, j++, k++)
switch (coord) {
case 1:
area += (V[i].y * (V[j].z - V[k].z));
continue;
case 2:
area += (V[i].x * (V[j].z - V[k].z));
continue;
case 3:
area += (V[i].x * (V[j].y - V[k].y));
continue;
}

// scale to get area before projection
an = Math.Sqrt( ax*ax + ay*ay + az*az);  // length of normal vector
switch (coord) {
case 1:
area *= (an / (2*ax));
break;
case 2:
area *= (an / (2*ay));
break;
case 3:
area *= (an / (2*az));
break;
}
return area;
}
```
```