Embedded QT Panda get adimensional coordinates

Hey guys, I’m struggling to find the maximum and minimum relative coordinates of an embedded Panda scene in PyQT5. I want to put an UCS there independent of 3D world. How to determine the maximum and minimum relative coordinates in this case and how to insert it close to lower left corner?

This is how it is now with the greater UCS fixed on (0,0,0) and the smallest on (-2,5,-1)

        origin = [-2, 5, -1.0]
        coords_np, axis_x_np, axis_y_np, axis_z_np = create_axes_cross("coords", 3, True)
        coords_np.setPos(self.showbase.cam, tuple(origin))

If you want to keep the orientation of your axis tripod relative to the camera, then you could just reparent it to base.a2dBottomLeft.

But if you want its orientation to follow that of the scene while rotating the camera, then perhaps this post might be of use to you.

It works on the previous version of my program (not embedded PyQT5). However when I try to insert my tripod into my embedded showbase, the tripod is not shown. Any idea what may causing it?

The working file is at tests/main_test.py
The not working file is just main.py (line 53, 54)

Ugh, looks like QPanda3D renders to a separate texture buffer instead of to the regular window, so any new display regions need to be added to that buffer. Another problem (likely for the same reason) seems to be that neither the window-event nor the aspectRatioChanged event gets thrown when the window is resized.

The way to solve this is to not use QPanda3D change the code in AxisTripod.py as follows:

class AxisTripod:

    def __init__(self, showbase):

        self._buffer = showbase.buff
        self._dr_pixel_size = 68  # size of display region in pixels
        dr = self._buffer.make_display_region(0, 1., 0., 1.)
        dr.sort = 2
        lens = OrthographicLens()
        lens.film_size = .235

        self._cam_target = cam_target = NodePath("tripod_cam_target")
        cam_node = Camera("tripod_cam")
        camera = cam_target.attach_new_node(cam_node)

        dr.camera = camera
        self._display_region = dr

        self._root = camera.attach_new_node("world_axes")
        self.model = self.__create_model()

        node = self._root.node()
        node.final = True

        self._buffer_size = (0, 0)
        showbase.task_mgr.do_method_later(.2, self.__update_region_size, "update_region_size")

    def __create_model(self):

        vertex_format = GeomVertexFormat.get_v3c4()

        vertex_data = GeomVertexData("axis_tripod_data", vertex_format, Geom.UH_static)
        pos_writer = GeomVertexWriter(vertex_data, "vertex")
        col_writer = GeomVertexWriter(vertex_data, "color")

        lines = GeomLines(Geom.UH_static)

        for i in range(3):
            v_pos = VBase3()
            v_pos[i] = .1
            color = VBase4(0., 0., 0., 1.)
            color[i] = 1.
            lines.add_vertices(i * 2, i * 2 + 1)

        geom = Geom(vertex_data)
        node = GeomNode("axis_tripod")
        model = self._root.attach_new_node(node)

        return model

    def __update_region_size(self, task):

        win_w, win_h = self._buffer.size

        if self._buffer_size == (win_w, win_h):
            return task.again

        aspect_ratio = win_w / win_h
        size_h = self._dr_pixel_size / win_w
        size_v = size_h * aspect_ratio
        self._buffer_size = (win_w, win_h)
        self._display_region.dimensions = (0., size_h, 0., size_v)

        return task.again

So __update_region_size has now become a task which runs every 0.2 seconds such that it doesn’t impact performance too much.

1 Like

Thanks, this worked!