protected static float FindDistanceToAbnormalVoxelInRange(
VoxelField volume,
Vector3i voxel,
int startX, int startY, int startZ,
int endX, int endY, int endZ)
{
// 1. Ignore directions that take us outside the bounds of the voxel volume.
if (startX < 0 || startY < 0 || startZ < 0)
return float.MaxValue;
float closestValueDist = float.MaxValue;
// 2. Find the value along the axis
for (Int32 z = startZ; z <= endZ; ++z)
{
for (Int32 y = startY; y <= endY; ++y)
{
for (Int32 x = startX; x <= endX; ++x)
{
byte value = volume.GetVoxel(x, y, z);
if (value != 1)
{
float dist = (float)(voxel - new Vector3i(x, y, z)).LengthSquared;
if (dist < closestValueDist)
{
closestValueDist = dist;
}
}
}
}
}
return closestValueDist;
}
protected static bool FillRange(VoxelField volume, Vector3i start, Vector3i end, Byte fillByte)
{
// 1. Ensure that we can safely expand into the area.
if (!TestRangeForFreeSpace(volume, start, end))
return false;
// 2. Fill area
for (Int32 z = start.Z; z <= end.Z; ++z)
{
for (Int32 y = start.Y; y <= end.Y; ++y)
{
for (Int32 x = start.X; x <= end.X; ++x)
{
volume.SetVoxel(x, y, z, fillByte);
}
}
}
return true;
}
protected static Vector3i FindHighestDensityVoxel(VoxelField volume)
{
float denestDistance = float.MinValue;
Vector3i densestVoxel = new Vector3i(0, 0, 0);
Object syncroot = new Object();
Parallel.For(0, volume.VoxelSize.Z, z =>
{
for (Int32 y = 0; y < volume.VoxelSize.Y; ++y)
{
for (Int32 x = 0; x < volume.VoxelSize.X; ++x)
{
byte value = volume.GetVoxel(x, y, z);
// Ignore empty voxels and already boxed voxels
if (value != 1)
continue;
float closestExtDist = FindShortestDistanceToAbnormalVoxel(volume, x, y, z);
if (closestExtDist > denestDistance)
{
lock (syncroot)
{
if (closestExtDist > denestDistance)
{
denestDistance = closestExtDist;
densestVoxel = new Vector3i(x, y, z);
}
}
}
}
}
});
return densestVoxel;
}
AABBi SimulatedAnnealingFill(VoxelizationInput input, SilhouetteOcclusionValidator sov, VoxelField volume, ref Vector3i densestVoxel, byte fillByte, List<Occluder> currentOccluders)
{
AABBi current = new AABBi(densestVoxel.X, densestVoxel.Y, densestVoxel.Z, densestVoxel.X + 1, densestVoxel.Y + 1, densestVoxel.Z + 1);
AABBi next = new AABBi(0, 0, 0, 0, 0, 0);
int iteration = -1;
List<AABBi> relevantOccluders = GetRelevantOccluders(input, currentOccluders);
List<AABBi> occluders = relevantOccluders.ToList();
occluders.Add(current);
long coverage = MeasureOccluderOcclusion(sov, input, occluders);
double coolignAlpha = 0.999;
double temperature = 400.0;
double epsilon = 0.001;
Random random = new Random(1337);
int maxItterations = 1000;
long delta = 0;
while (temperature > epsilon && iteration < maxItterations)
{
iteration++;
ComputeNext(random, current, next, volume, ref densestVoxel, delta, temperature);
occluders = relevantOccluders.ToList();
occluders.Add(next);
delta = MeasureOccluderOcclusion(sov, input, occluders) - coverage;
if (delta < 0)
{
next.Clone(current);
coverage = delta + coverage;
}
else
{
double probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
{
next.Clone(current);
coverage = delta + coverage;
}
}
temperature *= coolignAlpha;
if (iteration % 400 == 0)
Console.WriteLine(coverage);
}
FillRange(volume,
new Vector3i(current.MinX, current.MinY, current.MinZ),
new Vector3i(current.MaxX, current.MaxY, current.MaxZ),
fillByte);
return current;
}
void ComputeNext(Random random, AABBi current, AABBi next, VoxelField volume, ref Vector3i densestVoxel, long delta, double temperature)
{
current.Clone(next);
do
{
double probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MinX = densestVoxel.X + random.Next(0 - densestVoxel.X, 0);
probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MinY = densestVoxel.Y + random.Next(0 - densestVoxel.Y, 0);
probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MinZ = densestVoxel.Z + random.Next(0 - densestVoxel.Z, 0);
probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MaxX = densestVoxel.X + random.Next(0, volume.VoxelSize.X - densestVoxel.X) + 1;
probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MaxY = densestVoxel.Y + random.Next(0, volume.VoxelSize.Y - densestVoxel.Y) + 1;
probability = random.NextDouble();
if (probability < Math.Exp(-delta / temperature))
next.MaxZ = densestVoxel.Z + random.Next(0, volume.VoxelSize.Z - densestVoxel.Z) + 1;
} while (!TestRangeForFreeSpace(volume,
new Vector3i(next.MinX, next.MinY, next.MinZ),
new Vector3i(next.MaxX, next.MaxY, next.MaxZ)));
}
AABBi BruteForceFill(VoxelizationInput input, SilhouetteOcclusionValidator sov, VoxelField voxelField, Vector3i densestVoxel, byte fillByte, List<Occluder> currentOccluders)
{
Object syncroot = new Object();
Int64 largestVolume = 1;
AABBi largestOccluder = new AABBi(densestVoxel.X, densestVoxel.Y, densestVoxel.Z, densestVoxel.X + 1, densestVoxel.Y + 1, densestVoxel.Z + 1);
int MaxTopOccluders = 2000;
List<AABBi> bestOccluders = new List<AABBi>(MaxTopOccluders);
Parallel.For(densestVoxel.Z + 1, voxelField.VoxelSize.Z, max_z =>
{
for (Int32 min_z = densestVoxel.Z; min_z >= 0; --min_z)
{
for (Int32 max_y = densestVoxel.Y + 1; max_y < voxelField.VoxelSize.Y; ++max_y)
{
for (Int32 min_y = densestVoxel.Y; min_y >= 0; --min_y)
{
for (Int32 max_x = densestVoxel.X + 1; max_x < voxelField.VoxelSize.X; ++max_x)
{
for (Int32 min_x = densestVoxel.X; min_x >= 0; --min_x)
{
Int32 dx = max_x - min_x;
Int32 dy = max_y - min_y;
Int32 dz = max_z - min_z;
Int64 volume = dx * dy * dz;
if (TestRangeForFreeSpace(voxelField, new AABBi(min_x, min_y, min_z, max_x, max_y, max_z)))
{
lock (syncroot)
{
if (volume > largestVolume)
{
largestVolume = volume;
largestOccluder = new AABBi(min_x, min_y, min_z, max_x, max_y, max_z);
if (bestOccluders.Count >= MaxTopOccluders)
bestOccluders.RemoveAt(MaxTopOccluders - 1);
bestOccluders.Insert(0, largestOccluder);
}
}
}
else
{
// if we can't expand outward any further there's no point in checking more.
break;
}
}
}
}
}
}
Debug.WriteLine("Checked " + max_z);
});
List<AABBi> relevantOccluders = GetRelevantOccluders(input, currentOccluders);
long bestCoverage = 0;
AABBi bestCoverageVolume = largestOccluder;
foreach (AABBi occluder in bestOccluders)
{
List<AABBi> tempOccluders = relevantOccluders.ToList();
tempOccluders.Add(occluder);
long coverage = MeasureOccluderOcclusion(sov, input, tempOccluders);
if (coverage > bestCoverage)
{
bestCoverage = coverage;
bestCoverageVolume = occluder;
}
}
FillRange(voxelField, bestCoverageVolume, fillByte);
return bestCoverageVolume;
}
private void CreateSolidVolume(VoxelizingOctree tree, VoxelizingOctreeCell cell, Vector3i volumeLength)
{
if (cell.Status == CellStatus.Inside)
{
int min_x = cell.VoxelBounds.MinX + tree.WorldVoxelOffset.X;
int min_y = cell.VoxelBounds.MinY + tree.WorldVoxelOffset.Y;
int min_z = cell.VoxelBounds.MinZ + tree.WorldVoxelOffset.Z;
int max_x = cell.VoxelBounds.MaxX + tree.WorldVoxelOffset.X;
int max_y = cell.VoxelBounds.MaxY + tree.WorldVoxelOffset.Y;
int max_z = cell.VoxelBounds.MaxZ + tree.WorldVoxelOffset.Z;
for (int x = min_x; x < max_x; x++)
{
for (int y = min_y; y < max_y; y++)
{
for (int z = min_z; z < max_z; z++)
{
SetVoxel(x, y, z, 1);
}
}
}
}
foreach (var child in cell.Children)
{
CreateSolidVolume(tree, child, volumeLength);
}
}
protected static float FindShortestDistanceToAbnormalVoxel(VoxelField volume, int x, int y, int z)
{
int pX, nX, pY, nY, pZ, nZ;
pX = nX = pY = nY = pZ = nZ = 0;
Vector3i voxel = new Vector3i(x, y, z);
do
{
// +Z Axis
float distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x - nX, y - nY, z + (pZ + 1),
x + pX, y + pY, z + (pZ + 1));
if (distance != float.MaxValue)
return distance;
pZ++;
// -Z Axis
distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x - nX, y - nY, z - (nZ + 1),
x + pX, y + pY, z - (nZ + 1));
if (distance != float.MaxValue)
return distance;
nZ++;
// +Y Axis
distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x - nX, y + (pY + 1), z - nZ,
x + pX, y + (pY + 1), z + pZ);
if (distance != float.MaxValue)
return distance;
pY++;
// -Y Axis
distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x - nX, y - (nY + 1), z - nZ,
x + pX, y - (nY + 1), z + pZ);
if (distance != float.MaxValue)
return distance;
nY++;
// +X Axis
distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x + (pX + 1), y - nY, z - nZ,
x + (pX + 1), y + pY, z + pZ);
if (distance != float.MaxValue)
return distance;
pX++;
// -X Axis
distance = FindDistanceToAbnormalVoxelInRange(volume, voxel,
x - (nX + 1), y - nY, z - nZ,
x - (nX + 1), y + pY, z + pZ);
if (distance != float.MaxValue)
return distance;
nX++;
} while (true);
}
public bool GenerateOctree(MeshData mesh)
{
if (mesh == null)
return false;
// Create a list of triangles from the list of faces in the model
List<Triangle> triangles = new List<Triangle>();
for (int i = 0; i < mesh.Tris.Length; i++)
{
Tri face = mesh.Tris[i];
Triangle tri = new Triangle();
tri.v0 = mesh.Vertices[face.P1.Vertex];
tri.v1 = mesh.Vertices[face.P2.Vertex];
tri.v2 = mesh.Vertices[face.P3.Vertex];
triangles.Add(tri);
}
// Determine the axis-aligned bounding box for the triangles
Vector3 center;
CreateUniformBoundingBox(triangles, out MeshBounds, out VoxelBounds, out center, out SideLength);
{
SmallestVoxelSideLength = SideLength;
for (int i = 1; i < m_maxLevels; i++)
SmallestVoxelSideLength *= 0.5;
VoxelSize = new Vector3i();
VoxelSize.X = (Int32)Math.Pow(2, m_maxLevels);
VoxelSize.Y = (Int32)Math.Pow(2, m_maxLevels);
VoxelSize.Z = (Int32)Math.Pow(2, m_maxLevels);
}
m_root = new VoxelizingOctreeCell(this, null, center, SideLength, 0);
m_root.Root = m_root;
m_root.Triangles = new List<Triangle>(triangles);
m_root.Status = CellStatus.IntersectingBounds;
m_root.RecursiveSubdivide(m_maxLevels - 1);
WorldVoxelOffset = new Vector3i(
0 - Root.VoxelBounds.MinX,
0 - Root.VoxelBounds.MinY,
0 - Root.VoxelBounds.MinZ);
return true;
}
protected static bool TestRangeForFreeSpace(VoxelField volume, Vector3i start, Vector3i end)
{
// 1. Ignore directions that take us outside the bounds of the voxel volume.
if (start.X < 0 || start.Y < 0 || start.Z < 0)
return false;
// 2. Ensure that we can safely expand into the area, expand as long as the voxel isn't empty.
// Note: it is ok to expand into a space already occupied.
for (Int32 z = start.Z; z <= end.Z; ++z)
{
for (Int32 y = start.Y; y <= end.Y; ++y)
{
for (Int32 x = start.X; x <= end.X; ++x)
{
byte value = volume.GetVoxel(x, y, z);
// If a voxel has a '1' then it's unused volume space, if it is '0' it is empty,
// and if anything else, it has a box in it already.
if (value != 1)
return false;
}
}
}
return true;
}
protected static AABBi ExpandAndFillBox(VoxelField volume, ref Vector3i originVoxel, Byte fillByte)
{
int pX, nX, pY, nY, pZ, nZ;
pX = nX = pY = nY = pZ = nZ = 0;
volume.SetVoxel(originVoxel.X, originVoxel.Y, originVoxel.Z, fillByte);
bool boxGrew = false;
do
{
// +Z Axis
bool pZGrew = FillRange(volume,
new Vector3i(originVoxel.X - nX, originVoxel.Y - nY, originVoxel.Z + (pZ + 1)),
new Vector3i(originVoxel.X + pX, originVoxel.Y + pY, originVoxel.Z + (pZ + 1)), fillByte);
if (pZGrew)
pZ++;
// -Z Axis
bool nZGrew = FillRange(volume,
new Vector3i(originVoxel.X - nX, originVoxel.Y - nY, originVoxel.Z - (nZ + 1)),
new Vector3i(originVoxel.X + pX, originVoxel.Y + pY, originVoxel.Z - (nZ + 1)), fillByte);
if (nZGrew)
nZ++;
// +Y Axis
bool pYGrew = FillRange(volume,
new Vector3i(originVoxel.X - nX, originVoxel.Y + (pY + 1), originVoxel.Z - nZ),
new Vector3i(originVoxel.X + pX, originVoxel.Y + (pY + 1), originVoxel.Z + pZ), fillByte);
if (pYGrew)
pY++;
// -Y Axis
bool nYGrew = FillRange(volume,
new Vector3i(originVoxel.X - nX, originVoxel.Y - (nY + 1), originVoxel.Z - nZ),
new Vector3i(originVoxel.X + pX, originVoxel.Y - (nY + 1), originVoxel.Z + pZ), fillByte);
if (nYGrew)
nY++;
// +X Axis
bool pXGrew = FillRange(volume,
new Vector3i(originVoxel.X + (pX + 1), originVoxel.Y - nY, originVoxel.Z - nZ),
new Vector3i(originVoxel.X + (pX + 1), originVoxel.Y + pY, originVoxel.Z + pZ), fillByte);
if (pXGrew)
pX++;
// -X Axis
bool nXGrew = FillRange(volume,
new Vector3i(originVoxel.X - (nX + 1), originVoxel.Y - nY, originVoxel.Z - nZ),
new Vector3i(originVoxel.X - (nX + 1), originVoxel.Y + pY, originVoxel.Z + pZ), fillByte);
if (nXGrew)
nX++;
boxGrew = (pZGrew || nZGrew || pYGrew || nYGrew || pXGrew || nXGrew);
} while (boxGrew);
AABBi box = new AABBi();
box.MinX = originVoxel.X - nX;
box.MinY = originVoxel.Y - nY;
box.MinZ = originVoxel.Z - nZ;
box.MaxX = originVoxel.X + pX + 1;
box.MaxY = originVoxel.Y + pY + 1;
box.MaxZ = originVoxel.Z + pZ + 1;
return box;
}
