• Create Account

Transforming a large number of 3D points

Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

3 replies to this topic

#1Shawn876  Members   -  Reputation: 130

Like
0Likes
Like

Posted 09 October 2012 - 01:07 AM

Hi,

I currently apply a matrix transform a series of 3D points, which is quite expensive in terms of processing time.

Is it possible to transform just the extent points (I create a bounding box which encapsulates the points) and do some kind of linear interpolation to shift all the points without having to apply the transform to each of them?

Thanks.

#2JTippetts  Moderators   -  Reputation: 6655

Like
2Likes
Like

Posted 09 October 2012 - 07:45 AM

Operations to apply a 3D transform (rotation+translation) to a 3D point:


P' = M x P
|a b c d|   |x|
P' = |e f g h| * |y|
|i j k l|   |z|
|m n o p|

P'x = ax+by+cz+d
P'y = ix+jy+kz+l
P'z = mx+ny+oz+p



Operations to apply a bi-linear interpolation to a 3D point:

Enclosing points (8): a, b, c, d, e, f, g, h
Interpolants generated per point: Ps, Pt, Pu

Lerp(t, P1, P2)=P1+t*(P2-P1)

P' = Lerp(Pu, Lerp(Ps, Lerp(Pt, A, B), Lerp(Pt, C, D) ), Lerp(Ps, Lerp(Pt, E, F), Lerp(Pt, G, H)))
P' = (((a+s*(b-a))+t*((c+s*(d-c))-(a+s*(b-a))))+u*(((e+s*(f-e))+t*((g+s*(h-g))-(e+s*(f-e))))-((a+s*(b-a))+t*((c+s*(d-c))-(a+s*(b-a))))))
P' = Ps*(b-a) + Pt*(c-a) + Pu*(e-a) + Ps*Pt*(d-c-b+a) + Ps*Pu*(f-e-b+a) + Pt*Pu*(g-e-c+a) + Ps*Pt*Pu*(h-g-f+e-d+c+b-a)

simplify out the coefficients:
P' = Ps*(A) + Pt*(B) + Pu*(C) + Ps*Pt*(D) + Ps*Pu*(E) + Pt*Pu*(F) + Ps*Pt*Pu*(G)


Granted, in the bi-linear interpolation you can simplify the terms a bit by pre-multiplying Ps*Pt, Ps*Pu, Pt*Pu and Ps*Pt*Pu and pre-calculating the coefficients from the transformed bounding box but you're still doing seven multiplies per point component, rather than the three multiplies in a matrix transform. So I don't see how this would be any kind of improvement over a simple matrix transform, especially since the matrix transform is extremely well supported on GPU, whereas the bi-linear interp is less so. In the best case, the bi-linear interp would probably simplify down to the matrix transformation anyway.

Are you doing these calcs on the GPU or CPU? Have you profiled to find out where your real bottlenecks are?

Edited by JTippetts, 09 October 2012 - 07:48 AM.

#3FLeBlanc  Crossbones+   -  Reputation: 2720

Like
0Likes
Like

Posted 09 October 2012 - 08:07 AM

To take what JTippetts said even further, that's basically what a 3D matrix transform is: an interpolation along 3 axes defined by the forward, up and left/right vectors of the transform space. So if you pre-process your transformed box correctly, it will define a transform space that can be converted to a matrix to transform your points.

Edited by FLeBlanc, 09 October 2012 - 08:12 AM.

#4HappyCoder  Members   -  Reputation: 1165

Like
0Likes
Like

Posted 09 October 2012 - 03:33 PM

Like JTippetts said, you are going to slow down the transform more by doing the interpolation.

First you need to identify if transforming all of the data is actually a problem. Unless you have actual data showing your program spending too much time doing the transformations then you shouldn't assume it will take too much time.

If you do find that this is a problem then you can see if there is a faster way of doing the calculations. If these transformations are for rendering geometry try to offload the calculations to the gpu if possible. Dont draw any objects that are off screen. Apply a LOD system for objects that are far away.

If these transformations are used for collision detection then see if you cant transform shapes for collision detection into the local space of the mesh instead of transforming the mesh into world space. For example, if you want to see if a ray collides with a mesh instead of doing this
tranformedMesh = transform(mesh, object.worldMatrix)
if ray.intersects(tranformedMesh)
\\collision

Do this
transformedRay = transform(ray, object.worldMatrix.inverse)
if transformedRay.intersects(mesh)
\\collision

this way you only have to transform a ray that consists of two vectors instead of all of the mesh data

Edited by HappyCoder, 09 October 2012 - 03:36 PM.

Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

PARTNERS