Scale/normalize point clouds of different dimensions

Hi @marcomusy,

I have two point clouds (see attached file), they are of different dimensions and in different positions (actually in principle room4 is subpart of room6 with a different design). Now I wanted to scale/normalize them so that they are both in the same range e.g. (-1,1) in all three axis and without losing the aspect ratio.

I’ve tried to use the normalize() function but it didn’t really do what I want. Thus, I wanted to ask if there is another method which I can use, I did not find something on the documentation and scale() doesn’t seem to do what I want.

import numpy as np
import vedo as vd

room4 = np.genfromtxt('room4.csv', delimiter=',', dtype='float')
room6 = np.genfromtxt('room6.csv', delimiter=',', dtype='float')

pcd4 = vd.pointcloud.Points(room4).normalize()
pcd6 = vd.pointcloud.Points(room6).normalize()



axes4 = vd.addons.buildAxes(pcd4, c='k')
axes6 = vd.addons.buildAxes(pcd6, c='dg')
vd.show(pcd4, pcd6, axes4, axes6, axes=4)

rooms.zip

[ttsesm]

I see, thanks.

I think, I will close this now.

[marcomusy]

Hi - thanks for rising the issue. I think it’s actually something useful so i’ve added it as a vedo.base method (for the next release):

    def alignToBoundingBox(self, msh, rigid=False):
        """
        Align the current object's bounding box to the bounding box
        of the input object.

        :param bool rigid: do not allow scaling if set to True

        :Example:

            .. code-block:: python

                from vedo import *
                eli = Ellipsoid().alpha(0.4)
                cube= Cube().pos(3,2,1).rotateX(10).rotateZ(10).alpha(0.4)
                eli.alignToBoundingBox(cube, rigid=False)
                axes1 = Axes(eli, c='db')
                axes2 = Axes(cube, c='dg')
                show(eli, cube, axes1, axes2)
        """
        lmt = vtk.vtkLandmarkTransform()
        ss = vtk.vtkPoints()
        xss0,xss1,yss0,yss1,zss0,zss1 = self.bounds()
        for p in [[xss0, yss0, zss0],
                  [xss1, yss0, zss0],
                  [xss1, yss1, zss0],
                  [xss0, yss1, zss0],
                  [xss0, yss0, zss1],
                  [xss1, yss0, zss1],
                  [xss1, yss1, zss1],
                  [xss0, yss1, zss1],
                 ]:
            ss.InsertNextPoint(p)
        st = vtk.vtkPoints()
        xst0,xst1,yst0,yst1,zst0,zst1 = msh.bounds()
        for p in [[xst0, yst0, zst0],
                  [xst1, yst0, zst0],
                  [xst1, yst1, zst0],
                  [xst0, yst1, zst0],
                  [xst0, yst0, zst1],
                  [xst1, yst0, zst1],
                  [xst1, yst1, zst1],
                  [xst0, yst1, zst1],
                 ]:
            st.InsertNextPoint(p)

        lmt.SetSourceLandmarks(ss)
        lmt.SetTargetLandmarks(st)
        if rigid:
            lmt.SetModeToRigidBody()
        lmt.Update()
        self.applyTransform(lmt)
        self.transform = lmt
        return self

You can only keep the aspect ratio if you apply the same scaling in the 3 cartesian coordinates. If you want the origins to coincide you need to choose which axes to scale to match the target.