Matrix Calc issue

[colorful]

Hey Juj,

Thanks for your quick response, while I create a OBB instance, I found below 2 issues,

Line 629 of file "OBB.cpp", Mathod [void OBBTransform(OBB &o, const Matrix &transform)] 

1.  I have tried many matrix for testing, and every time I couldn't get the OBB I expecting after rotated. 
     (the position of OBB is NOT equal to the result calculated by MATLAB or written calculation )

2.  There input a 4x4 matrix, it should include the translate parameter, but the OBB will not do the translate job.

Maybe we should use CrossProduct instead DotProduct ?

[juj]

Hi, I can't outright spot an issue there. Can you post some example of the data you are having issues with?

One thing I notice is that when I originally wrote OBBTransform, I have assumed that it could contain scaling. However, now I notice that it is a very bad idea, since if scaled, the result remains an unskewed/undistorted OBB only if the scaling occurs along the primary axes of the OBB. Therefore I think I should at least remove the support for scaling present in OBBTransform, that will simplify and optimize the code. I'm not sure with the cross product. What do you think?

[colorful]

Sure, Please check below test case:

float3 min(0,0,0);
float3 max(1,1,1);

float3 min1(0,0,0);
float3 max1(2,2,2);


AABB a(min, max);
AABB b(min1, max1);

OBB oa(a);
OBB ob(b);

float4x4 transMatrix1(1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,
                     0.0000000000, 1.0000000000, 0.0000000000, 0.0000000000,
                     0.0000000000, 0.0000000000, 1.0000000000, 0.0000000000,
                     0.0000000000, 0.0000000000, 0.0000000000, 1.0000000000);

float4x4 transMatrix2(0.00000000000000, 0.00000000000000, 1.00000000000000, 0.00000000000000,
                        -0.50000000000000,  0.86602540378444, 0.00000000000000, 0.00000000000000,
                        -0.86602540378444, -0.50000000000000, 0.00000000000000, 0.00000000000000,
                        0.00000000000000,  0.00000000000000, 0.00000000000000, 1.00000000000000);


oa.Transform(transMatrix1);

ob.Transform(transMatrix2);
ob.Translate(float3(-1.00000000000000,  0.00000000000000, 0.00000000000000));  //because the OBB will not do the translate job via Transform, I revoke a Translate here

bool res = oa.Intersects(ob, 1e-7f);





These 2 OBB should not intersect, but returned a "true"

[juj]

As a quick note, looking at this now.

[juj]

I have now run some tests on this. To check this, I implemented a visual rendering application to see what is going on.

1. I visualized your code as-is, and it looks like this: https://dl.dropbox.com/u/40949268/Bugs/OBB_original.html Code: https://dl.dropbox.com/u/40949268/Bugs/obb_original.cpp

This is a very ambiguous case. It looks like the OBBs are barely touching, but still, intersection is being reported. I do think the OBBs touch in the corners, so it should be ok to report intersection in this case.

1. To test translating OBBs using the Transform function instead of Translate, I replaced the original code with this code: https://dl.dropbox.com/u/40949268/Bugs/obb_TranslateInTransform.cpp The result can be run here: https://dl.dropbox.com/u/40949268/Bugs/OBB_TranslateInTransform.html . On my system, the results are identical. Perhaps you set the translation to the last row of the matrix instead of the last column in your test? I see that OBB::Transform also properly translates the object.
2. To test that the intersection of the two OBBs really is a corner case, and moving the OBBs only slightly will make them not collide, I implemented a translation animation to one of the boxes. The result can be run interactively here: https://dl.dropbox.com/u/40949268/Bugs/OBB_TranslateAnimate.html The code I used is here: https://dl.dropbox.com/u/40949268/Bugs/obb_TranslateAnimate.cpp In the program, the boxes are drawn in red if there is a detected intersection (OBB::Intersects(OBB) returns true)
3. To test that the intersection test works in different orientations of the OBBs, I also implemented a rotation animation to the boxes. The result can be run here: https://dl.dropbox.com/u/40949268/Bugs/OBB_RotateAnimate.html The code I used is here: https://dl.dropbox.com/u/40949268/Bugs/obb_RotateAnimate.cpp

I cannot spot a problem here. After the fix you mentioned in the bug #12, I can observe that OBB-OBB collision test is done perfectly.

Perhaps in your comparing tests you use the 'vector_Matrix' convention for matrices, which would result in you specifying the matrices in a transposed manner? MathGeoLib functions use the convention 'Matrix_vector', so the translation part is the last column of the matrix. In memory layout, this is different than e.g. the memory layout used by Direct3D or OpenGL. (For memory layout related item, see #3)

[colorful]

Hei juj,

You are right, I checked again and found that I used 'vector*Matrix' convention, you mean in MathGeoLib functions, the format of transformation matrix should be like this,

         c1   c2   c3   c4
  r1 ( r00   r01  r02   t1 )
  r2 ( r10   r11  r12   t2 ) 
  r3 ( r20   r21  r22   t3 )
  r4 ( p1    p2    p3    w )

All the “r”-parameters are rotation components, which can be used to scale or rotate your object. The “t”- components translate your object. The “p”-components used for perspective (meaning, which point of view you set up on an object). And the “w” is the parameter for indicating the vector.

Please let me know if my understanding is wrong. Thanks a lot.

[juj]

Yeah, that's absolutely correct. The default form taken by MathGeoLib assumes the logical order of 'M*v', which corresponds exactly to the structure you mention here. The physical memory layout is row-major, meaning that the elements are linearly in form

( r00, r01, r02, t1, r10, r11, r12, t2, t20, r21, r22, t3, p1, p2, p3, w)

If you prefer to use the logical convention of 'v*M', you will need to .Transpose() the matrices before use. See also #3 and #11. Perhaps both conventions become supported via an #ifdef at some point.

[colorful]

Ya, that makes sense. Thank you for your quick response, I think this issue could be closed.

[colorful]

Hey juj could you please run a group of test case ? this case is I stripped from a JT file.

Point P1_min = (-14.936, -14.918, 0)
Point P1_max = (11,14.993,31)

Matrix M1 =
-1.07208257030456E-16, -1.00000000000001, -8.7286263159544E-16, 0,
-1.26981758441502E-15, -1.74738116012849E-15, 1.00000000000002, 0,
-1.00000000000002, 2.18444210319027E-16, -1.49880108324396E-15, 0,
25.0000000000001, 15.0000000000001, 55, 1

Point P2_min = (-12.31, 0, -12.5)
Point P2_max = (12.31, 21, 12.5)

Matrix M2 =
-7.49400541621981E-16, -1.74801672368006E-15, 1.00000000000004, 0,
-1.00000000000003, 2.18593446936421E-16, -7.42461647718073E-16, 0,
-1.05511595112313E-15, -1.00000000000004, 9.50176821687596E-16, 0,
-6.00000000000481, 15.0000000000002, 55.0000000000012, 1

The last row of the matrix is my translation.
Expected result is "TRUE"
Thank you.

[juj]

I tested the data you gave as OBB-OBB intersections, and I do detect an intersection.

Go to this page: https://dl.dropbox.com/u/40949268/emcc/MathGeoLibTest.html

and try replacing the default code with this:

Clear(0.6,0.9,0.9);

var P1_min = new float3(-14.936, -14.918, 0);
var P1_max = new float3(11,14.993,31);

var M1 = new float4x4();
M1.Set_float_float_float_float_float_float_float_float_float_float_float_float_float_float_float_float(
-1.07208257030456E-16, -1.00000000000001, -8.7286263159544E-16, 0,
-1.26981758441502E-15, -1.74738116012849E-15, 1.00000000000002, 0,
-1.00000000000002, 2.18444210319027E-16, -1.49880108324396E-15, 0,
25.0000000000001, 15.0000000000001, 55, 1);
M1.Transpose(); // M1 was inputted above in 'v_M' notation, but AABB::Transform(float4x4) uses a matrix with 'M_v' notation, so transpose.

var P2_min = new float3(-12.31, 0, -12.5);
var P2_max = new float3(12.31, 21, 12.5);

var M2 = new float4x4();
M2.Set_float_float_float_float_float_float_float_float_float_float_float_float_float_float_float_float(
-7.49400541621981E-16, -1.74801672368006E-15, 1.00000000000004, 0,
-1.00000000000003, 2.18593446936421E-16, -7.42461647718073E-16, 0,
-1.05511595112313E-15, -1.00000000000004, 9.50176821687596E-16, 0,
-6.00000000000481, 15.0000000000002, 55.0000000000012, 1);
M2.Transpose(); // M1 was inputted above in 'v_M' notation, but AABB::Transform(float4x4) uses a matrix with 'M_v' notation, so transpose.

var a1 = AABB_(P1_min, P1_max);
a1.proto = Module.AABB.prototype;
var a2 = AABB_(P2_min, P2_max);
a2.proto = Module.AABB.prototype;
var o1 = a1.Transform(M1);
o1.proto = Module.OBB.prototype;
var o2 = a2.Transform(M2);
o2.proto = Module.OBB.prototype;
var dist = o1.Distance(o2); // .Intersects doesn't yet work due to a bug, so use Distance() instead.
print("Distance between OBBs: " + dist);
var red = new float3(1,0,0);
var blue = new float3(0,1,0);

// Set up camera.
var t = Time();
var d = a1.Diagonal().Length() + a2.Diagonal().Length();
var cameraTargetPos = (o1.CenterPoint().Add_float3(o2.CenterPoint())).Mul_float(0.5);
var cameraPos = cameraTargetPos.Add_float3(new float3(Math.sin(t_0.2)_d, 10, Math.cos(t_0.2)_d));
SetPerspectiveCamera(cameraPos, cameraTargetPos, new float3(0,1,0), 1.0, 1000.0, 3.14/2);

if (dist <= 0)
{
col = red;
print("The objects intersect.");
}
else
{
col = blue;
print("The objects do not intersect.");
}
DrawOBB(o1, col);
DrawOBB(o2, col);

[juj]

For reference, here's the same code I had tested in C++, and it also detects an intersection:

    float3 P1_min(-14.936, -14.918, 0);
    float3 P1_max(11,14.993,31);

    float4x4 M1(
     -1.07208257030456E-16, -1.00000000000001, -8.7286263159544E-16, 0,
     -1.26981758441502E-15, -1.74738116012849E-15, 1.00000000000002, 0, 
     -1.00000000000002, 2.18444210319027E-16, -1.49880108324396E-15, 0,
     25.0000000000001, 15.0000000000001, 55, 1);
    M1 = M1.Transposed(); // M1 was inputted above in 'v*M' notation, but AABB::Transform(float4x4) uses a matrix with 'M*v' notation, so transpose.

    float3 P2_min(-12.31, 0, -12.5);
    float3 P2_max(12.31, 21, 12.5);

    float4x4 M2(
     -7.49400541621981E-16, -1.74801672368006E-15, 1.00000000000004, 0, 
     -1.00000000000003, 2.18593446936421E-16, -7.42461647718073E-16, 0,
     -1.05511595112313E-15, -1.00000000000004, 9.50176821687596E-16, 0,
     -6.00000000000481, 15.0000000000002, 55.0000000000012, 1);
    M2 = M2.Transposed(); // M1 was inputted above in 'v*M' notation, but AABB::Transform(float4x4) uses a matrix with 'M*v' notation, so transpose.

    AABB a1(P1_min, P1_max);
    AABB a2(P2_min, P2_max);
    OBB o1 = a1.Transform(M1);
    OBB o2 = a2.Transform(M2);
    bool intersects = o1.Intersects(o2);
    float3 col = intersects ? float3(1,0,0) : float3(0,0,1);

    // Set up camera.
    float d = a1.Diagonal().Length() + a2.Diagonal().Length();
    float3 CameraTargetPos = (o1.CenterPoint() + o2.CenterPoint()) * 0.5f;
    float3 CameraPos = CameraTargetPos + d*float3(Sin(t*0.2f), 0, Cos(t*0.2f)) + float3(0,10,0);
    SetPerspectiveCamera(CameraPos, CameraTargetPos, float3(0,1,0), 1.0, 1000.0, 3.14/2);

    DrawOBB(o1, col);
    DrawOBB(o2, col);