How to extract the final position after a simulation?

[alyflex-fys]

I am currently testing out Newton and it seems pretty promising, however I think there is something I'm missing.

I'm using the classic bunny obj as a test and drops it on a ground plane and want to extract the final transformation of the bunny after the simulation. However I must be doing something wrong because the boundary box for the bunny object consistently ends up well below 0 even though I can see the bunny resting on the ground plane which should be at height 0.

Is there some extra transformation happening behind the scene or what exactly am I missing here? or doing wrong?

[bunny.obj.txt](https://github.com/user-attachments/files/25096291/bunny.obj.txt)

import newton

import warp as wp
import numpy as np
import openmesh

class NewtonSimTest:

    def __init__(self, meshfile):
        self.fps = 60
        self.frame_dt = 1.0 / self.fps
        self.sim_substeps = 10
        self.sim_dt = self.frame_dt / self.sim_substeps
        self.gravity = -9.82
        self.max_steps = 20
        self.sim_time = 0.0
        self.load_viewer()
        m = openmesh.read_trimesh(meshfile)
        mesh_points = np.array(m.points())
        mesh_indices = np.array(m.face_vertex_indices(), dtype=np.int32).flatten()
        mesh = newton.Mesh(mesh_points, mesh_indices)
        self.mesh = mesh

    def load_viewer(self):
        self.viewer = newton.viewer.ViewerViser(port=8080)

    def build_scene_model(self):
        scene = newton.ModelBuilder(up_axis=newton.Axis.Z, gravity=self.gravity)
        scene.add_ground_plane(key="ground")

        body_id = scene.add_body(mass=1.0)
        scene.add_shape_mesh(
            body=body_id,
            xform=wp.transform(wp.vec3([0.1, 0.1, 0.3]), wp.quat([0.0, 0.0, 0.0, 1.0])),
            mesh=self.mesh,
        )
        scene.color()
        model = scene.finalize()
        return model

    def capture(self):
        if wp.get_device().is_cuda:
            with wp.ScopedCapture() as capture:
                self.run_simulate()
            self.graph = capture.graph
        else:
            self.graph = None

    def run_simulate(self):
        for _ in range(self.sim_substeps):
            self.state_0.clear_forces()

            # apply forces to the model
            self.viewer.apply_forces(self.state_0)

            self.contacts = self.model.collide(self.state_0)
            self.solver.step(self.state_0, self.state_1, self.control, self.contacts, self.sim_dt)

            # swap states
            self.state_0, self.state_1 = self.state_1, self.state_0

    def step(self):
        if self.graph:
            wp.capture_launch(self.graph)
        else:
            self.run_simulate()

        self.sim_time += self.frame_dt
    def render(self):
        self.viewer.begin_frame(self.sim_time)
        self.viewer.log_state(self.state_0)
        self.viewer.log_contacts(self.contacts, self.state_0)
        self.viewer.end_frame()


    def simulate(self):
        for i in range(self.max_steps):
            with wp.ScopedTimer("step", active=False):
                self.step()
            with wp.ScopedTimer("render", active=False):
                self.render()
            if self.early_stopping():
                break

    def early_stopping(self) -> bool:
        """
        Test whether we can stop early
        :return:
        """
        return False


    def reset(self):
        self.sim_time = 0.0

    def extract_results(self):
        def apply_to_point_cloud(pc, pos, rot):
            from scipy.spatial.transform import Rotation
            rotation_mat = Rotation.from_quat(rot).as_matrix()
            pc_transformed = pc @ rotation_mat.T + pos
            return pc_transformed

        transform = self.state_0.body_q.numpy()[-1]
        pos = transform[:3]
        rot = transform[3:]
        pc = self.mesh.vertices
        pc_transformed = apply_to_point_cloud(pc,pos,rot)
        lower_bounds = np.min(pc_transformed, axis=0)
        print(lower_bounds)
        return


    def build_and_run_simulation(self):
        print("Starting physics simulation")

        # First we build the scene.
        self.model = self.build_scene_model()

        # Next use a solver on it.
        self.solver = newton.solvers.SolverXPBD(self.model, iterations=10)
        # self.solver = newton.solvers.SolverVBD(self.model)

        self.state_0 = self.model.state()
        self.state_1 = self.model.state()
        self.control = self.model.control()
        self.contacts = self.model.collide(self.state_0)

        try:
            self.viewer.set_model(self.model)
            self.capture()
        except:
            pass

        self.simulate()
        self.extract_results()
        self.viewer.close()
        print("Finished physics simulation")

if __name__ == '__main__':
    meshfile = './data/meshes_org/bunny.obj'
    sim = NewtonSimTest(meshfile)
    sim.build_and_run_simulation()
    print("done")

[jvonmuralt]

You are applying body_q directly to the mesh vertices to get world positions, but that ignores the shape transform offset which was passed to add_shape_mesh.

scene.add_shape_mesh(
    body=body_id,
    xform=wp.transform(wp.vec3([0.1, 0.1, 0.3]), ...),  # <-- shape offset from body origin
    mesh=self.mesh,
)

def extract_results(self):
    from scipy.spatial.transform import Rotation

    # Body world transform
    body_tf = self.state_0.body_q.numpy()[-1]
    body_pos = body_tf[:3]
    body_rot = body_tf[3:]  # xyzw

    # Shape transform (the xform you passed to add_shape_mesh)
    shape_tf = self.model.shape_transform.numpy()[-1]
    shape_pos = shape_tf[:3]
    shape_rot = shape_tf[3:]

    R_shape = Rotation.from_quat(shape_rot).as_matrix()
    R_body = Rotation.from_quat(body_rot).as_matrix()

    # Apply shape xform first (mesh-local → body-local), then body xform (body-local → world)
    pc = self.mesh.vertices
    pc_body = pc @ R_shape.T + shape_pos
    pc_world = pc_body @ R_body.T + body_pos

    lower_bounds = np.min(pc_world, axis=0)
    print(lower_bounds)

[alyflex-fys]

Thank you that was indeed it!