private Branch ChooseSubtree(Triangle triangle)
{
Branch currentBranch = _root;
currentBranch.RefindVolume(triangle);
while (true)
{
if (currentBranch.GetNodeType() == "PreBranch")
{
return(currentBranch);
}
Branch childBranch1 = (Branch)currentBranch.GetChilds()[0];
Branch childBranch2 = (Branch)currentBranch.GetChilds()[1];
if (childBranch1.GetNodeType() == "PreBranch")
{
if (MBB.CheckOverlapChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) !=
0)
{
currentBranch = MBB.CheckOverlapChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) > 0
? childBranch1
: childBranch2;
}
else
{
if (MBB.CheckVolumeChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) != 0)
{
currentBranch = MBB.CheckVolumeChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) > 0
? childBranch1
: childBranch2;
}
else
{
currentBranch = childBranch1.MBB.Volume <= childBranch2.MBB.Volume
? childBranch1
: childBranch2;
}
}
}
else
{
if (MBB.CheckVolumeChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) != 0)
{
currentBranch = MBB.CheckVolumeChange(childBranch1.MBB, childBranch2.MBB, triangle.Center) > 0
? childBranch1
: childBranch2;
}
else
{
currentBranch = childBranch1.MBB.Volume <= childBranch2.MBB.Volume
? childBranch1
: childBranch2;
}
}
currentBranch.RefindVolume(triangle);
}
}
public static double CheckOverlapChange(MBB mbb1, MBB mbb2, Point trCenter)
{
MBB[] mbbs = { mbb1, mbb2 };
double[] overlapChanges = new double[2];
for (int i = 0; i < 2; i++)
{
double volume1 = CheckOverlapVolume(mbbs[i], mbbs[(i + 1) % 2]);
double xMax = trCenter.x > mbbs[i]._xMax ? trCenter.x : mbbs[i]._xMax;
double yMax = trCenter.y > mbbs[i]._yMax ? trCenter.y : mbbs[i]._yMax;
double zMax = trCenter.z > mbbs[i]._zMax ? trCenter.z : mbbs[i]._zMax;
double xMin = trCenter.x < mbbs[i]._xMin ? trCenter.x : mbbs[i]._xMin;
double yMin = trCenter.y < mbbs[i]._yMin ? trCenter.y : mbbs[i]._yMin;
double zMin = trCenter.z < mbbs[i]._zMin ? trCenter.z : mbbs[i]._zMin;
MBB newMbb = new MBB();
newMbb.AddPoint(new Point(xMax, yMax, zMax));
newMbb.AddPoint(new Point(xMin, yMin, zMin));
double volume2 = CheckOverlapVolume(newMbb, mbbs[(i + 1) % 2]);
overlapChanges[i] = volume2 - volume1;
}
return(overlapChanges[1] - overlapChanges[0]);
}
private double MinMarginDiv(IComparer <Leaf> comparer)
{
int k = _maxChild - 2 * _minChild + 2;
Leaf[] sorted = GetChilds().Select(node => (Leaf)node).ToArray();
Array.Sort(sorted, comparer);
double[] S = new double[k];
for (int i = 1; i <= k; i++)
{
MBB mbb1 = new MBB();
MBB mbb2 = new MBB();
for (int j = 0; j < sorted.Length; j++)
{
if (j < _minChild - 1 + i)
{
mbb1.AddTriangle(sorted[j].Triangle);
}
else
{
mbb2.AddTriangle(sorted[j].Triangle);
}
}
S[i - 1] = mbb1.Margin + mbb2.Margin;
}
(double result, _) = MinOfArray(S);
return(result);
}
private static double CheckVolumeChange(MBB mbb, Point trCenter)
{
double xMax = trCenter.x > mbb._xMax ? trCenter.x : mbb._xMax;
double yMax = trCenter.y > mbb._yMax ? trCenter.y : mbb._yMax;
double zMax = trCenter.z > mbb._zMax ? trCenter.z : mbb._zMax;
double xMin = trCenter.x < mbb._xMin ? trCenter.x : mbb._xMin;
double yMin = trCenter.y < mbb._yMin ? trCenter.y : mbb._yMin;
double zMin = trCenter.z < mbb._zMin ? trCenter.z : mbb._zMin;
double volumeChange = (xMax - xMin) * (yMax - yMin) * (zMax - zMin) - mbb.Volume;
return(volumeChange);
}
private int ChooseSplitIndex(Leaf[] sortedLeaf)
{
int k = _maxChild - 2 * _minChild + 2;
double[] overlapShapes = new double[k];
double[] volumes = new double[k];
for (int i = 1; i <= k; i++)
{
MBB mbb1 = new MBB();
MBB mbb2 = new MBB();
for (int j = 0; j < sortedLeaf.Length; j++)
{
if (j < _minChild - 1 + i)
{
mbb1.AddTriangle(sortedLeaf[j].Triangle);
}
else
{
mbb2.AddTriangle(sortedLeaf[j].Triangle);
}
}
overlapShapes[i - 1] = MBB.CheckOverlapVolume(mbb1, mbb2);
volumes[i - 1] = mbb1.Volume + mbb2.Volume;
}
(double minOverlap, int splitIndex) = MinOfArray(overlapShapes);
int repeatedMinOverlap = 0;
for (int i = 0; i < overlapShapes.Length; i++)
{
if (overlapShapes[i] == minOverlap)
{
repeatedMinOverlap++;
}
}
if (repeatedMinOverlap == 1)
{
return(splitIndex + _minChild);
}
(_, splitIndex) = MinOfArray(volumes);
return(splitIndex + _minChild);
}
public static double CheckOverlapVolume(MBB mbb1, MBB mbb2)
{
double xMin = Math.Max(mbb1._xMin, mbb2._xMin);
double xMax = Math.Min(mbb1._xMax, mbb2._xMax);
double yMin = Math.Max(mbb1._yMin, mbb2._yMin);
double yMax = Math.Min(mbb1._yMax, mbb2._yMax);
double zMin = Math.Max(mbb1._zMin, mbb2._zMin);
double zMax = Math.Min(mbb1._zMax, mbb2._zMax);
if (mbb1._xMax <= mbb2._xMin || mbb2._xMax <= mbb1._xMin ||
mbb1._yMax <= mbb2._yMin || mbb2._yMax <= mbb1._yMin ||
mbb1._zMax <= mbb2._zMin || mbb2._zMax <= mbb1._zMin)
{
return(0);
}
MBB newMbb = new MBB(new(xMin, yMin, zMin), new(xMax, yMax, zMax));
return(newMbb.Volume);
}
public static double CheckVolumeChange(MBB mbb1, MBB mbb2, Point trCenter)
{
return(CheckVolumeChange(mbb2, trCenter) - CheckVolumeChange(mbb1, trCenter));
}
public Branch(Branch mother, MBB mbb)
{
_mother = mother;
_mbb = mbb;
}
public Branch(List <Node> childs, Branch mother, MBB mbb)
{
_childs = childs;
_mother = mother;
_mbb = mbb;
}
private void InitMBB(Triangle triangle)
{
_mbb = new MBB(triangle);
}
