Merge pull request #1593 from paroj:ovisup

alalek · alalek · commit 768deade1f6e · 2018-03-30T15:27:32.000Z
diff --git a/modules/ovis/samples/aruco_ar_demo.py b/modules/ovis/samples/aruco_ar_demo.py
@@ -14,8 +14,8 @@
 
 win = cv.ovis.createWindow("arucoAR", imsize, flags=0)
 win.setCameraIntrinsics(K, imsize)
-win.createEntity("figure", "Sinbad.mesh", (0, 0, -5), (-1.57, 0, 0))
-win.createLightEntity("sun", (0, 0, -100))
+win.createEntity("figure", "Sinbad.mesh", (0, 0, 5), (1.57, 0, 0))
+win.createLightEntity("sun", (0, 0, 100))
 
 # video capture
 cap = cv.VideoCapture(0)
diff --git a/modules/ovis/src/meshes.cpp b/modules/ovis/src/meshes.cpp
@@ -28,9 +28,9 @@ void createPlaneMesh(const String& name, const Size2f& size, InputArray image)
     }
 
     // plane
-    MovablePlane plane(Vector3::UNIT_Z, 0);
+    MovablePlane plane(-Vector3::UNIT_Z, 0);
     MeshPtr mesh = MeshManager::getSingleton().createPlane(
-        name, RESOURCEGROUP_NAME, plane, size.width, size.height, 1, 1, true, 1, 1, 1, Vector3::UNIT_Y);
+        name, RESOURCEGROUP_NAME, plane, size.width, size.height, 1, 1, true, 1, 1, 1, -Vector3::UNIT_Y);
     mesh->getSubMesh(0)->setMaterialName(name);
 }
 
diff --git a/modules/ovis/src/ovis.cpp b/modules/ovis/src/ovis.cpp
@@ -23,8 +23,7 @@ static const char* RENDERSYSTEM_NAME = "OpenGL 3+ Rendering Subsystem";
 static std::vector<String> _extraResourceLocations;
 
 // convert from OpenCV to Ogre coordinates:
-// rotation by 180° around x axis
-static Matrix3 toOGRE = Matrix3(1, 0, 0, 0, -1, 0, 0, 0, -1);
+static Quaternion toOGRE(Degree(180), Vector3::UNIT_X);
 static Vector2 toOGRE_SS = Vector2(1, -1);
 
 WindowScene::~WindowScene() {}
@@ -48,15 +47,12 @@ void _createTexture(const String& name, Mat image)
     texMgr.loadImage(name, RESOURCEGROUP_NAME, im);
 }
 
-static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3& t,
-                       bool invert = false, bool init = false)
+static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3& t, bool invert = false)
 {
     CV_Assert(rot.empty() || rot.rows() == 3 || rot.size() == Size(3, 3),
               tvec.empty() || tvec.rows() == 3);
 
-    // make sure the entity is oriented by the OpenCV coordinate conventions
-    // when initialised
-    q = init ? Quaternion(toOGRE) : Quaternion::IDENTITY;
+    q = Quaternion::IDENTITY;
     t = Vector3::ZERO;
 
     if (!rot.empty())
@@ -74,7 +70,7 @@ static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3&
 
         Matrix3 R;
         _R.copyTo(Mat_<Real>(3, 3, R[0]));
-        q = Quaternion(toOGRE * R);
+        q = Quaternion(R);
 
         if (invert)
         {
@@ -85,7 +81,6 @@ static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3&
     if (!tvec.empty())
     {
         tvec.copyTo(Mat_<Real>(3, 1, t.ptr()));
-        t = toOGRE * t;
 
         if(invert)
         {
@@ -124,6 +119,10 @@ static SceneNode& _getSceneNode(SceneManager* sceneMgr, const String& name)
     try
     {
         mo = sceneMgr->getMovableObject(name, "Camera");
+
+        // with cameras we have an extra CS flip node
+        if(mo)
+            return *mo->getParentSceneNode()->getParentSceneNode();
     }
     catch (ItemIdentityException&)
     {
@@ -281,12 +280,14 @@ class WindowSceneImpl : public WindowScene
         cam->setNearClipDistance(0.5);
         cam->setAutoAspectRatio(true);
         camNode = sceneMgr->getRootSceneNode()->createChildSceneNode();
+        camNode->setOrientation(toOGRE);
         camNode->attachObject(cam);
 
         if (flags & SCENE_INTERACTIVE)
         {
             camman.reset(new OgreBites::CameraMan(camNode));
             camman->setStyle(OgreBites::CS_ORBIT);
+            camNode->setFixedYawAxis(true, Vector3::NEGATIVE_UNIT_Y);
         }
 
         if (!app->sceneMgr)
@@ -356,7 +357,7 @@ class WindowSceneImpl : public WindowScene
 
         Quaternion q;
         Vector3 t;
-        _convertRT(rot, tvec, q, t, false, true);
+        _convertRT(rot, tvec, q, t);
         SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);
         node->attachObject(ent);
     }
@@ -387,8 +388,10 @@ class WindowSceneImpl : public WindowScene
 
         Quaternion q;
         Vector3 t;
-        _convertRT(rot, tvec, q, t, false, true);
+        _convertRT(rot, tvec, q, t);
         SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);
+        node = node->createChildSceneNode();
+        node->setOrientation(toOGRE); // camera mesh is oriented by OGRE conventions by default
         node->attachObject(cam);
 
         RealRect ext = cam->getFrustumExtents();
@@ -410,7 +413,7 @@ class WindowSceneImpl : public WindowScene
 
         Quaternion q;
         Vector3 t;
-        _convertRT(rot, tvec, q, t, false, true);
+        _convertRT(rot, tvec, q, t);
         SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);
         node->attachObject(light);
     }
@@ -430,7 +433,7 @@ class WindowSceneImpl : public WindowScene
         SceneNode& node = _getSceneNode(sceneMgr, name);
         Quaternion q;
         Vector3 t;
-        _convertRT(rot, tvec, q, t, invert, true);
+        _convertRT(rot, tvec, q, t, invert);
         node.setOrientation(q);
         node.setPosition(t);
     }
@@ -539,40 +542,33 @@ class WindowSceneImpl : public WindowScene
 
     void fixCameraYawAxis(bool useFixed, InputArray _up)
     {
-        Vector3 up = Vector3::UNIT_Y;
+        Vector3 up = Vector3::NEGATIVE_UNIT_Y;
         if (!_up.empty())
         {
             _up.copyTo(Mat_<Real>(3, 1, up.ptr()));
-            up = toOGRE * up;
         }
 
-        Camera* cam = sceneMgr->getCamera(title);
-        cam->getParentSceneNode()->setFixedYawAxis(useFixed, up);
+        camNode->setFixedYawAxis(useFixed, up);
     }
 
     void setCameraPose(InputArray tvec, InputArray rot, bool invert)
     {
-        Camera* cam = sceneMgr->getCamera(title);
-
-        SceneNode* node = cam->getParentSceneNode();
         Quaternion q;
         Vector3 t;
-        _convertRT(rot, tvec, q, t, invert, true);
+        _convertRT(rot, tvec, q, t, invert);
 
         if (!rot.empty())
-            node->setOrientation(q);
+            camNode->setOrientation(q*toOGRE);
 
         if (!tvec.empty())
-            node->setPosition(t);
+            camNode->setPosition(t);
     }
 
     void getCameraPose(OutputArray R, OutputArray tvec, bool invert)
     {
-        Camera* cam = sceneMgr->getCamera(title);
-        SceneNode* node = cam->getParentSceneNode();
-
         Matrix3 _R;
-        node->getOrientation().ToRotationMatrix(_R);
+        // toOGRE.Inverse() == toOGRE
+        (camNode->getOrientation()*toOGRE).ToRotationMatrix(_R);
 
         if (invert)
         {
@@ -581,20 +577,18 @@ class WindowSceneImpl : public WindowScene
 
         if (tvec.needed())
         {
-            Vector3 _tvec = node->getPosition();
+            Vector3 _tvec = camNode->getPosition();
 
             if (invert)
             {
                 _tvec = _R * -_tvec;
             }
 
-            _tvec = toOGRE.Transpose() * _tvec;
             Mat_<Real>(3, 1, _tvec.ptr()).copyTo(tvec);
         }
 
         if (R.needed())
         {
-            _R = toOGRE.Transpose() * _R;
             Mat_<Real>(3, 3, _R[0]).copyTo(R);
         }
     }
@@ -607,18 +601,16 @@ class WindowSceneImpl : public WindowScene
 
     void setCameraLookAt(const String& target, InputArray offset)
     {
-        SceneNode* cam = sceneMgr->getCamera(title)->getParentSceneNode();
         SceneNode* tgt = sceneMgr->getEntity(target)->getParentSceneNode();
 
         Vector3 _offset = Vector3::ZERO;
 
         if (!offset.empty())
         {
             offset.copyTo(Mat_<Real>(3, 1, _offset.ptr()));
-            _offset = toOGRE * _offset;
         }
 
-        cam->lookAt(tgt->_getDerivedPosition() + _offset, Ogre::Node::TS_WORLD);
+        camNode->lookAt(tgt->_getDerivedPosition() + _offset, Ogre::Node::TS_WORLD);
     }
 };
 

Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ void createPlaneMesh(const String& name, const Size2f& size, InputArray image)`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`// plane`
`31`		`- MovablePlane plane(Vector3::UNIT_Z, 0);`
	`31`	`+ MovablePlane plane(-Vector3::UNIT_Z, 0);`
`32`	`32`	`MeshPtr mesh = MeshManager::getSingleton().createPlane(`
`33`		`- name, RESOURCEGROUP_NAME, plane, size.width, size.height, 1, 1, true, 1, 1, 1, Vector3::UNIT_Y);`
	`33`	`+ name, RESOURCEGROUP_NAME, plane, size.width, size.height, 1, 1, true, 1, 1, 1, -Vector3::UNIT_Y);`
`34`	`34`	`mesh->getSubMesh(0)->setMaterialName(name);`
`35`	`35`	`}`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -23,8 +23,7 @@ static const char* RENDERSYSTEM_NAME = "OpenGL 3+ Rendering Subsystem";`
`23`	`23`	`static std::vector<String> _extraResourceLocations;`
`24`	`24`
`25`	`25`	`// convert from OpenCV to Ogre coordinates:`
`26`		`-// rotation by 180° around x axis`
`27`		`-static Matrix3 toOGRE = Matrix3(1, 0, 0, 0, -1, 0, 0, 0, -1);`
	`26`	`+static Quaternion toOGRE(Degree(180), Vector3::UNIT_X);`
`28`	`27`	`static Vector2 toOGRE_SS = Vector2(1, -1);`
`29`	`28`
`30`	`29`	`WindowScene::~WindowScene() {}`
`@@ -48,15 +47,12 @@ void _createTexture(const String& name, Mat image)`
`48`	`47`	`texMgr.loadImage(name, RESOURCEGROUP_NAME, im);`
`49`	`48`	`}`
`50`	`49`
`51`		`-static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3& t,`
`52`		`- bool invert = false, bool init = false)`
	`50`	`+static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3& t, bool invert = false)`
`53`	`51`	`{`
`54`	`52`	`CV_Assert(rot.empty() \|\| rot.rows() == 3 \|\| rot.size() == Size(3, 3),`
`55`	`53`	`tvec.empty() \|\| tvec.rows() == 3);`
`56`	`54`
`57`		`- // make sure the entity is oriented by the OpenCV coordinate conventions`
`58`		`- // when initialised`
`59`		`- q = init ? Quaternion(toOGRE) : Quaternion::IDENTITY;`
	`55`	`+ q = Quaternion::IDENTITY;`
`60`	`56`	`t = Vector3::ZERO;`
`61`	`57`
`62`	`58`	`if (!rot.empty())`
`@@ -74,7 +70,7 @@ static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3&`
`74`	`70`
`75`	`71`	`Matrix3 R;`
`76`	`72`	`_R.copyTo(Mat_<Real>(3, 3, R[0]));`
`77`		`- q = Quaternion(toOGRE * R);`
	`73`	`+ q = Quaternion(R);`
`78`	`74`
`79`	`75`	`if (invert)`
`80`	`76`	`{`
`@@ -85,7 +81,6 @@ static void _convertRT(InputArray rot, InputArray tvec, Quaternion& q, Vector3&`
`85`	`81`	`if (!tvec.empty())`
`86`	`82`	`{`
`87`	`83`	`tvec.copyTo(Mat_<Real>(3, 1, t.ptr()));`
`88`		`- t = toOGRE * t;`
`89`	`84`
`90`	`85`	`if(invert)`
`91`	`86`	`{`
`@@ -124,6 +119,10 @@ static SceneNode& _getSceneNode(SceneManager* sceneMgr, const String& name)`
`124`	`119`	`try`
`125`	`120`	`{`
`126`	`121`	`mo = sceneMgr->getMovableObject(name, "Camera");`
	`122`	`+`
	`123`	`+ // with cameras we have an extra CS flip node`
	`124`	`+ if(mo)`
	`125`	`+ return *mo->getParentSceneNode()->getParentSceneNode();`
`127`	`126`	`}`
`128`	`127`	`catch (ItemIdentityException&)`
`129`	`128`	`{`
`@@ -281,12 +280,14 @@ class WindowSceneImpl : public WindowScene`
`281`	`280`	`cam->setNearClipDistance(0.5);`
`282`	`281`	`cam->setAutoAspectRatio(true);`
`283`	`282`	`camNode = sceneMgr->getRootSceneNode()->createChildSceneNode();`
	`283`	`+ camNode->setOrientation(toOGRE);`
`284`	`284`	`camNode->attachObject(cam);`
`285`	`285`
`286`	`286`	`if (flags & SCENE_INTERACTIVE)`
`287`	`287`	`{`
`288`	`288`	`camman.reset(new OgreBites::CameraMan(camNode));`
`289`	`289`	`camman->setStyle(OgreBites::CS_ORBIT);`
	`290`	`+ camNode->setFixedYawAxis(true, Vector3::NEGATIVE_UNIT_Y);`
`290`	`291`	`}`
`291`	`292`
`292`	`293`	`if (!app->sceneMgr)`
`@@ -356,7 +357,7 @@ class WindowSceneImpl : public WindowScene`
`356`	`357`
`357`	`358`	`Quaternion q;`
`358`	`359`	`Vector3 t;`
`359`		`- _convertRT(rot, tvec, q, t, false, true);`
	`360`	`+ _convertRT(rot, tvec, q, t);`
`360`	`361`	`SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);`
`361`	`362`	`node->attachObject(ent);`
`362`	`363`	`}`
`@@ -387,8 +388,10 @@ class WindowSceneImpl : public WindowScene`
`387`	`388`
`388`	`389`	`Quaternion q;`
`389`	`390`	`Vector3 t;`
`390`		`- _convertRT(rot, tvec, q, t, false, true);`
	`391`	`+ _convertRT(rot, tvec, q, t);`
`391`	`392`	`SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);`
	`393`	`+ node = node->createChildSceneNode();`
	`394`	`+ node->setOrientation(toOGRE); // camera mesh is oriented by OGRE conventions by default`
`392`	`395`	`node->attachObject(cam);`
`393`	`396`
`394`	`397`	`RealRect ext = cam->getFrustumExtents();`
`@@ -410,7 +413,7 @@ class WindowSceneImpl : public WindowScene`
`410`	`413`
`411`	`414`	`Quaternion q;`
`412`	`415`	`Vector3 t;`
`413`		`- _convertRT(rot, tvec, q, t, false, true);`
	`416`	`+ _convertRT(rot, tvec, q, t);`
`414`	`417`	`SceneNode* node = sceneMgr->getRootSceneNode()->createChildSceneNode(t, q);`
`415`	`418`	`node->attachObject(light);`
`416`	`419`	`}`
`@@ -430,7 +433,7 @@ class WindowSceneImpl : public WindowScene`
`430`	`433`	`SceneNode& node = _getSceneNode(sceneMgr, name);`
`431`	`434`	`Quaternion q;`
`432`	`435`	`Vector3 t;`
`433`		`- _convertRT(rot, tvec, q, t, invert, true);`
	`436`	`+ _convertRT(rot, tvec, q, t, invert);`
`434`	`437`	`node.setOrientation(q);`
`435`	`438`	`node.setPosition(t);`
`436`	`439`	`}`
`@@ -539,40 +542,33 @@ class WindowSceneImpl : public WindowScene`
`539`	`542`
`540`	`543`	`void fixCameraYawAxis(bool useFixed, InputArray _up)`
`541`	`544`	`{`
`542`		`- Vector3 up = Vector3::UNIT_Y;`
	`545`	`+ Vector3 up = Vector3::NEGATIVE_UNIT_Y;`
`543`	`546`	`if (!_up.empty())`
`544`	`547`	`{`
`545`	`548`	`_up.copyTo(Mat_<Real>(3, 1, up.ptr()));`
`546`		`- up = toOGRE * up;`
`547`	`549`	`}`
`548`	`550`
`549`		`- Camera* cam = sceneMgr->getCamera(title);`
`550`		`- cam->getParentSceneNode()->setFixedYawAxis(useFixed, up);`
	`551`	`+ camNode->setFixedYawAxis(useFixed, up);`
`551`	`552`	`}`
`552`	`553`
`553`	`554`	`void setCameraPose(InputArray tvec, InputArray rot, bool invert)`
`554`	`555`	`{`
`555`		`- Camera* cam = sceneMgr->getCamera(title);`
`556`		`-`
`557`		`- SceneNode* node = cam->getParentSceneNode();`
`558`	`556`	`Quaternion q;`
`559`	`557`	`Vector3 t;`
`560`		`- _convertRT(rot, tvec, q, t, invert, true);`
	`558`	`+ _convertRT(rot, tvec, q, t, invert);`
`561`	`559`
`562`	`560`	`if (!rot.empty())`
`563`		`- node->setOrientation(q);`
	`561`	`+ camNode->setOrientation(q*toOGRE);`
`564`	`562`
`565`	`563`	`if (!tvec.empty())`
`566`		`- node->setPosition(t);`
	`564`	`+ camNode->setPosition(t);`
`567`	`565`	`}`
`568`	`566`
`569`	`567`	`void getCameraPose(OutputArray R, OutputArray tvec, bool invert)`
`570`	`568`	`{`
`571`		`- Camera* cam = sceneMgr->getCamera(title);`
`572`		`- SceneNode* node = cam->getParentSceneNode();`
`573`		`-`
`574`	`569`	`Matrix3 _R;`
`575`		`- node->getOrientation().ToRotationMatrix(_R);`
	`570`	`+ // toOGRE.Inverse() == toOGRE`
	`571`	`+ (camNode->getOrientation()*toOGRE).ToRotationMatrix(_R);`
`576`	`572`
`577`	`573`	`if (invert)`
`578`	`574`	`{`
`@@ -581,20 +577,18 @@ class WindowSceneImpl : public WindowScene`
`581`	`577`
`582`	`578`	`if (tvec.needed())`
`583`	`579`	`{`
`584`		`- Vector3 _tvec = node->getPosition();`
	`580`	`+ Vector3 _tvec = camNode->getPosition();`
`585`	`581`
`586`	`582`	`if (invert)`
`587`	`583`	`{`
`588`	`584`	`_tvec = _R * -_tvec;`
`589`	`585`	`}`
`590`	`586`
`591`		`- _tvec = toOGRE.Transpose() * _tvec;`
`592`	`587`	`Mat_<Real>(3, 1, _tvec.ptr()).copyTo(tvec);`
`593`	`588`	`}`
`594`	`589`
`595`	`590`	`if (R.needed())`
`596`	`591`	`{`
`597`		`- _R = toOGRE.Transpose() * _R;`
`598`	`592`	`Mat_<Real>(3, 3, _R[0]).copyTo(R);`
`599`	`593`	`}`
`600`	`594`	`}`
`@@ -607,18 +601,16 @@ class WindowSceneImpl : public WindowScene`
`607`	`601`
`608`	`602`	`void setCameraLookAt(const String& target, InputArray offset)`
`609`	`603`	`{`
`610`		`- SceneNode* cam = sceneMgr->getCamera(title)->getParentSceneNode();`
`611`	`604`	`SceneNode* tgt = sceneMgr->getEntity(target)->getParentSceneNode();`
`612`	`605`
`613`	`606`	`Vector3 _offset = Vector3::ZERO;`
`614`	`607`
`615`	`608`	`if (!offset.empty())`
`616`	`609`	`{`
`617`	`610`	`offset.copyTo(Mat_<Real>(3, 1, _offset.ptr()));`
`618`		`- _offset = toOGRE * _offset;`
`619`	`611`	`}`
`620`	`612`
`621`		`- cam->lookAt(tgt->_getDerivedPosition() + _offset, Ogre::Node::TS_WORLD);`
	`613`	`+ camNode->lookAt(tgt->_getDerivedPosition() + _offset, Ogre::Node::TS_WORLD);`
`622`	`614`	`}`
`623`	`615`	`};`
`624`	`616`