एक क्यूब आधारित दुनिया (जैसे कि Minecraft, Trove, या Cube World) की कल्पना करें जहां सब कुछ पहचान के आकार के क्यूब्स से बना है और सभी क्यूब्स एक ही तरह के हैं ।
लक्ष्य दुनिया को आयताकार बक्से की सबसे कम संख्या के साथ प्रतिनिधित्व करना है (क्यूब्स को विलय करके लेकिन उत्तल आकार (उर्फ, एक आयताकार बॉक्स आकार) को बनाए रखना)। मेरा एल्गोरिथ्म इस पर सफल होता है, लेकिन इसका प्रदर्शन अपने इच्छित उद्देश्य के लिए बहुत धीमा है। क्या तेज एल्गोरिदम हैं?
मेरे एल्गोरिथ्म के लिए छद्म-सी # -कोड मूल रूप से है:
struct Coordinate { int x,y,z; }; //<-- integer based grid
HashSet<Coordinate> world; // <-- contains all the cubes
//width, height, and length represent how many cubes it spans
struct RectangularBox { Coordinate coord; int width,height,length; }
void Begin()
{
List<RectangularBox> fewestBoxes = new List<RectangularBox>();
while(world.Count > 0)
{
RectangularBox currentLargest = ExtractLargest();
fewestBoxes.Add(currentLargest);
world.RemoveRange(currentLargest.ContainedCubes());
}
//done; `fewestBoxes` contains the fewest rectangular boxes needed.
}
private RectangularBox ExtractLargest()
{
RectangularBox largestBox = new RectangularBox();
foreach (Coordinate origin in world)
{
RectangularBox box = FindMaximumSpan(origin);
if (box.CalculateVolume() >= largestBox.CalculateVolume())
largestBox = box;
}
return largestBox;
}
private RectangularBox FindMaximumSpan(Coordinate origin)
{
int maxX, maxY,maxZ;
while (world.Contains(origin.Offset(maxX, 0, 0))) maxX++;
while (world.Contains(origin.Offset(0, maxY, 0))) maxY++;
while (world.Contains(origin.Offset(0, 0, maxZ))) maxZ++;
RectangularBox largestBox;
for (int extentX = 0; extentX <= maxX; extentX++)
for (int extentY = 0; extentY <= maxY; extentY++)
for (int extentZ = 0; extentZ <= maxZ; extentZ++)
{
int lengthX = extentX + 1;
int lengthY = extentY + 1;
int lengthZ = extentZ + 1;
if (BoxIsFilledWithCubes(origin, lengthX, lengthY, lengthZ))
{
int totalVolume = lengthX * lengthY * lengthZ;
if (totalVolume >= largestBox.ComputeVolume())
largestBox = new RectangularBox(origin, lengthX, lengthY, lengthZ);
}
else
break;
}
return largestBox;
}
private bool BoxIsFilledWithCubes(Coordinate coord,
int lengthX, int lengthY, int lengthZ)
{
for (int gX = 0; gX < lengthX; gX++)
for (int gY = 0; gY < lengthY; gY++)
for (int gZ = 0; gZ < lengthZ; gZ++)
if (!world.Contains(coord.Offset(gX, gY, gZ)))
return false;
return true;
}
अनिवार्य रूप से, दुनिया के हर ब्लॉक के लिए, यह पहली बार पता चलता है कि तीन सकारात्मक आयामों (+ X, + Y, + Z) में से प्रत्येक में कितने सन्निहित ब्लॉक हैं। और फिर यह थोड़े से बाढ़ को भरता है जो कि मात्रा और जांच करता है जो सबसे बड़ा भरने वाला है जो किसी भी ब्लॉक को याद नहीं कर रहा है।
अद्यतन: जब से मुझे लगा कि यह एक गेम रेंडरिंग इंजन के लिए है, मैं सिर्फ स्पष्ट करना चाहता हूं, यह गेम रेंडरिंग इंजन के लिए नहीं है; यह एक फ़ाइल-कनवर्टर के लिए है; जीयूआई नहीं।