python (pygame и pyopenGL) Конвертировать трехмерные модели (файл.jpg) в последовательность серых изображений

Question

В настоящее время я работаю над системами распознавания объектов, которые нуждаются в большом количестве обучающих данных.

Я пытаюсь преобразовать 3D-модель в последовательность серых изображений, вращая модель и выбирая 2D-изображение с определенным интервалом времени.

Поскольку я в основном работаю над Python, поэтому я пытаюсь решить эту проблему на основе pygame и pyopenGL, я нашел этот пример для загрузки файла.obj, но он не будет работать в самом начале, что заняло у меня довольно много времени выяснить, где проблема.

И теперь основная проблема как-то сводится к следующему:

Класс Point3D:

def __init__(self, x = 0, y = 0, z = 0):
    self.x, self.y, self.z = float(x), float(y), float(z)

def rotateX(self, angle):
    """ Rotates the point around the X axis by the given angle in degrees. """
    rad = angle * math.pi / 180
    cosa = math.cos(rad)
    sina = math.sin(rad)
    y = self.y * cosa - self.z * sina
    z = self.y * sina + self.z * cosa
    return Point3D(self.x, y, z)

def rotateY(self, angle):
    """ Rotates the point around the Y axis by the given angle in degrees. """
    rad = angle * math.pi / 180
    cosa = math.cos(rad)
    sina = math.sin(rad)
    z = self.z * cosa - self.x * sina
    x = self.z * sina + self.x * cosa
    return Point3D(x, self.y, z)

def rotateZ(self, angle):
    """ Rotates the point around the Z axis by the given angle in degrees. """
    rad = angle * math.pi / 180
    cosa = math.cos(rad)
    sina = math.sin(rad)
    x = self.x * cosa - self.y * sina
    y = self.x * sina + self.y * cosa
    return Point3D(x, y, self.z)

def project(self, win_width, win_height, fov, viewer_distance):
    """ Transforms this 3D point to 2D using a perspective projection. """
    factor = fov / (viewer_distance + self.z)
    x = self.x * factor + win_width / 2
    y = -self.y * factor + win_height / 2
    return Point3D(x, y, self.z)

Класс симуляции:

    def __init__(self, win_width = 640, win_height = 480):
    pygame.init()

    self.screen = pygame.display.set_mode((win_width, win_height))
    pygame.display.set_caption("Simulation of a rotating 3D Cube (http://codeNtronix.com)")

    self.clock = pygame.time.Clock()

    self.vertices = [
        Point3D(-1,1,-1),
        Point3D(1,1,-1),
        Point3D(1,-1,-1),
        Point3D(-1,-1,-1),
        Point3D(-1,1,1),
        Point3D(1,1,1),
        Point3D(1,-1,1),
        Point3D(-1,-1,1)
    ]

    # Define the vertices that compose each of the 6 faces. These numbers are
    # indices to the vertices list defined above.
    self.faces  = [(0,1,2,3),(1,5,6,2),(5,4,7,6),(4,0,3,7),(0,4,5,1),(3,2,6,7)]

    # Define colors for each face
    self.colors = [(255,0,255),(255,0,0),(0,255,0),(0,0,255),(0,255,255),(255,255,0)]

    self.angle = 0

def run(self):
    """ Main Loop """
    while 1:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()

        self.clock.tick(50)
        self.screen.fill((0,32,0))

        # It will hold transformed vertices.
        t = []

        for v in self.vertices:
            # Rotate the point around X axis, then around Y axis, and finally around Z axis.
            r = v.rotateX(self.angle).rotateY(self.angle).rotateZ(self.angle)
            # Transform the point from 3D to 2D
            p = r.project(self.screen.get_width(), self.screen.get_height(), 256, 4)
            # Put the point in the list of transformed vertices
            t.append(p)

        # Calculate the average Z values of each face.
        avg_z = []
        i = 0
        for f in self.faces:
            z = (t[f[0]].z + t[f[1]].z + t[f[2]].z + t[f[3]].z) / 4.0
            avg_z.append([i,z])
            i = i + 1

        # Draw the faces using the Painter's algorithm:
        # Distant faces are drawn before the closer ones.
        for tmp in sorted(avg_z,key=itemgetter(1),reverse=True):
            face_index = tmp[0]
            f = self.faces[face_index]
            pointlist = [(t[f[0]].x, t[f[0]].y), (t[f[1]].x, t[f[1]].y),
                         (t[f[1]].x, t[f[1]].y), (t[f[2]].x, t[f[2]].y),
                         (t[f[2]].x, t[f[2]].y), (t[f[3]].x, t[f[3]].y),
                         (t[f[3]].x, t[f[3]].y), (t[f[0]].x, t[f[0]].y)]
            pygame.draw.polygon(self.screen,self.colors[face_index],pointlist)


        self.angle += 1

        pygame.display.flip()

if name == "main": Simulation (). run ()

Приведенный выше пример рисует куб и продолжает его вращать, тогда как я могу получить данные пикселей напрямую? Какая библиотека или пакет может предоставить мне возможность напрямую получать пиксельные данные 2D проекта. (IPL? Или pyopenGL?)

Спасибо

Answer 1

Вы можете сделать "скриншот", используя glreadpixels. Затем вы можете передать его в библиотеку изображений Python, которая сохраняет его в виде файла на диск: /questions/764451/poluchit-dannyie-iz-opengl-glreadpixelsispolzuya-pyglet/764473#764473