Explain (कल्पना कीजिए कि चित्र 3D में है)

मैंने एक क्यूबॉइड ऑब्जेक्ट बनाया है जो कोनों के सभी निर्देशांक को क्यूबॉइड में स्टोर करता है, ठीक उसी तरह जैसे कि पाइगेम रेक्ट ऑब्जेक्ट। मुझे उपरोक्त दो घनाभों के अतिव्यापी आयतन की आवश्यकता है, फिर उसमें से एक नई घनाभ वस्तु बनाने के लिए (चित्र में ग्रे आयत, फिर से, कल्पना करें कि यह 3D में है)।

क्या इसके लिए कोई सामान्य बीजगणितीय सूत्र है या क्या मुझे प्रत्येक विशिष्ट मामले के लिए एक विधि बनानी है?

मैं पाइगलेट्स कोऑर्डिनेट सिस्टम का उपयोग कर रहा हूं, यानी ऊपर जाना सकारात्मक है y सही जाना सकारात्मक x है और आगे बढ़ना सकारात्मक z है।

घनाभ वर्ग:

def __init__(self, pos, width, height, depth):
    self.pos = pos

    self.width = width
    self.height = height
    self.depth = depth

    self.Update()

def Update(self):
    self.size = (self.width, self.height, self.depth)

    self.topleft_front = (self.pos[0], self.pos[1] + self.height, -self.pos[2])
    self.topright_front = (self.pos[0] + self.width, self.pos[1] + self.height, -self.pos[2])
    self.bottomleft_front = (self.pos[0], self.pos[1], -self.pos[2])
    self.bottomright_front = (self.pos[0] + self.width, self.pos[1], -self.pos[2])

    self.topleft_back = (self.pos[0], self.pos[1] + self.height, -self.pos[2] - self.depth)
    self.topright_back = (self.pos[0] + self.width, self.pos[1] + self.height, -self.pos[2] - self.depth)
    self.bottomleft_back = (self.pos[0], self.pos[1], -self.pos[2] - self.depth)
    self.bottomright_back = (self.pos[0] + self.width, self.pos[1], -self.pos[2] - self.depth)

    self.center = (self.pos[0] + self.width / 2, self.pos[1] + self.height / 2, -self.pos[2] - self.depth / 2)

def collidecube(self, cube):
    if (self.pos[0] < cube.pos[0] + cube.width) and (
    self.pos[0] + self.width > cube.pos[0]) and (
    self.pos[1] < cube.pos[1] + cube.height) and (
    self.pos[1] + self.height > cube.pos[1]) and (
    self.pos[2] < cube.pos[2] + cube.depth) and (
    self.pos[2] + self.depth > cube.pos[2]):
        return True

    else:
        return False

def Clip(self, cube):
    if self.collidecube(cube):
        pass
1
Lobsternator 10 मई 2019, 17:18

1 उत्तर

सबसे बढ़िया उत्तर

दो श्रेणियों की ओवरलैपिंग रेंज खोजने के लिए समस्या को कम किया जा सकता है।

जैसे श्रेणी [a0, a1] ^ [b0, b1] = [c0, c1]

a0                  a1
  x----------------x
            x-----------------x
          b0                   b1

            x======x
          c0        c1

यदि a0, a1 से कम है और b0, b1 से कम है, तो

c0 = max(a0, b0)
c1 = min(a1, b1) 

यदि c1, c0 से कम है, तो श्रेणियां प्रतिच्छेद नहीं करती हैं। यह एल्गोरिथ्म सभी 3 आयामों पर लागू किया जा सकता है।

यदि यह सत्यापित करने के लिए पर्याप्त है कि क्या श्रेणियां प्रतिच्छेद कर रही हैं, तो स्थिति है:

isect = a0 < b1 and b0 < a1  

ध्यान दें, अगर b0, a1 से बड़ा है या b1, a0 से कम है, तो कोई ओवरलैपिंग रेंज नहीं है।

1
Rabbid76 10 मई 2019, 15:09