Changeset 9939 for code/trunk/src/libraries

Timestamp:

Dec 21, 2013, 11:16:54 PM (11 years ago)

Author:

jo

Message:

presentationHS13 branch merged into trunk

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/libraries/util/Math.cc (modified) (3 diffs)
• src/libraries/util/Math.h (modified) (2 diffs)

code/trunk/src/libraries/util/Math.cc

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Wolfgang Roenninger
  *
  */
@@ -147 +147 @@
 
     /**
-        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0° = 0, 180° = 1).
+        @brief Gets the 2D viewing direction (up/down, left/right) to the position of the other object, multiplied with the viewing distance to the object (0� = 0, 180� = 1).
         @param myposition My position
         @param mydirection My viewing direction
@@ -189 +189 @@
         else
             return orxonox::Vector2( -sin_value * radius, cos_value * radius);
+    }
+
+
+    /**
+            @brief Gets the 2D project vector for the 3D Radar .
+            @param myposition My position
+            @param mydirection My viewing direction
+            @param myorthonormal My orthonormalvector (pointing upwards through my head)
+            @param otherposition The position of the other object
+            @param mapangle The angle between line of sight on screen and the 3Dmap-x/z-plain in radian
+            @param detectionlimit The limit in which objects are shown on the map
+            @return The viewing direction
+    */
+    orxonox::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit)
+    {
+        // Orxonox Vectors: x_direction you are looking, y_direction points up, z_direction points to the right
+        orxonox::Vector3 distance = otherposition - myposition; // get vector from Ship to object
+
+        // new coordinate system:       x_axsis:        mydirection             (points front)
+        //                                                      y_axsis:        myorthonormal   (points up)
+        //                                                      z_axsis:        myside                  (points right)
+
+        orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal); // get 3. base vector
+
+        distance = 4*distance / detectionlimit; // shrink vector on map
+        if(distance.length() > 1.0f) // if object would wander outside of the map
+                {
+                distance = distance / distance.length();
+                        }
+
+        // perform a coordinate transformation to get distance in relation of the position of the ship
+        orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+        // calculate 2D vector on the map (with angle between x/z - plain and line of sight)
+        float xcoordinate = distanceShip.z; // z; cause x direction on screen is to the right side
+        float ycoordinate = distanceShip.x*sin(mapangle)+distanceShip.y*cos(mapangle);
+        return orxonox::Vector2(xcoordinate , ycoordinate);
+    }
+
+    /**
+               @brief Gets if a object is over the x/z - plain on map
+               @param myposition My position
+               @param mydirection My viewing direction
+               @param myorthonormal My orthonormalvector (pointing upwards through my head)
+               @param otherposition The position of the other object
+               @param mapangle The angle you look on the 3Dmap in radian
+               @return If distancevector to the other object has a positive y-coordinate
+
+               Examples:
+                Returns true if object is over x/z - plain
+                Returns false if object is below x/z -plain
+    */
+    bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle)
+    {
+        // Orxonox Vectors: x_direction you are looking, y_direction points up, z_direction points to the right
+        orxonox::Vector3 distance = otherposition - myposition;
+
+        // new coordinate system:       x_axsis:        mydirection             (points front)
+        //                                                      y_axsis:        myorthonormal   (points up)
+        //                                                      z_axsis:        myside                  (points right)
+
+        orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal); // get vector from Ship to object
+
+
+        // perform a coordinate transformation to get distance in relation of the position of the ship
+        orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+        if(distanceShip.y >= 0)
+                return true;
+        else
+                return false;
+    }
+
+    /**
+                   @brief A value between 0 and 10, in order how other object is in front or in back
+                   @param myposition My position
+                   @param mydirection My viewing direction
+                   @param myorthonormal My orthonormalvector (pointing upwards through my head)
+                   @param otherposition The position of the other object
+                   @param detectionlimit The limit in which objects are shown on the map
+                   @return value between 0 and 100
+    */
+    int determineMap3DZOrder(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float detectionlimit)
+    {
+        orxonox::Vector3 distance = otherposition - myposition; // get vector from Ship to object
+        orxonox::Vector3 myside = mydirection.crossProduct(myorthonormal);      // get vector to the side
+
+        distance = 4*distance / detectionlimit; // shrink vector on map
+        if(distance.length() > 1.0f) // if object would wander outside of the map
+        {
+                distance = distance / distance.length();
+        }
+
+        // perform a coordinate transformation to get distance in relation of the position of the ship
+        orxonox::Vector3 distanceShip = getTransformedVector(distance, mydirection, myorthonormal, myside);
+
+        return (int) 50 - 100*distanceShip.x;
+    }
+
+
+    /**
+                @brief Gets the new vector after a coordinate transformation
+                @param distance Vector which will be transformed
+                @param mydirection New x basevector
+                @param myorthonormal New y basevector
+                @param otherposition New z basevector
+                @return direction in the new coordinates
+
+                x is vector in old coordinates
+                y is vector in old coordinates
+                T is transform matrix with:
+                        T = (t1 , t2 , t3)
+                        t1 = mydirection
+                        t2 = myorthonormal
+                        t3 = myside
+
+                y = T^(-1)*x
+            */
+    orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside)
+    {
+        // inverse of the transform matrix
+        float determinant = +mydirection.x * (myorthonormal.y*myside.z - myside.y*myorthonormal.z)
+                                                -mydirection.y * (myorthonormal.x*myside.z - myorthonormal.z*myside.x)
+                                                +mydirection.z * (myorthonormal.x*myside.y - myorthonormal.y*myside.x);
+        float invdet = 1/determinant;
+
+        // transform matrix
+        orxonox::Vector3 xinvtransform;
+        orxonox::Vector3 yinvtransform;
+        orxonox::Vector3 zinvtransform;
+
+        xinvtransform.x = (myorthonormal.y * myside.z        - myside.y        * myorthonormal.z)*invdet;
+        xinvtransform.y = (mydirection.z   * myside.y        - mydirection.y   * myside.z       )*invdet;
+        xinvtransform.z = (mydirection.y   * myorthonormal.z - mydirection.z   * myorthonormal.y)*invdet;
+        yinvtransform.x = (myorthonormal.z * myside.x        - myorthonormal.x * myside.z       )*invdet;
+        yinvtransform.y = (mydirection.x   * myside.z        - mydirection.z   * myside.x       )*invdet;
+        yinvtransform.z = (myorthonormal.x * mydirection.z   - mydirection.x   * myorthonormal.z)*invdet;
+        zinvtransform.x = (myorthonormal.x * myside.y        - myside.x        * myorthonormal.y)*invdet;
+        zinvtransform.y = (myside.x        * mydirection.y   - mydirection.x   * myside.y       )*invdet;
+        zinvtransform.z = (mydirection.x   * myorthonormal.y - myorthonormal.x * mydirection.y  )*invdet;
+
+        // coordinate transformation
+        orxonox::Vector3 distanceShip;
+        distanceShip.x = xinvtransform.x * distance.x + yinvtransform.x * distance.y + zinvtransform.x * distance.z;
+        distanceShip.y = xinvtransform.y * distance.x + yinvtransform.y * distance.y + zinvtransform.y * distance.z;
+        distanceShip.z = xinvtransform.z * distance.x + yinvtransform.z * distance.y + zinvtransform.z * distance.z;
+
+        return distanceShip;
     }
 

code/trunk/src/libraries/util/Math.h

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Wolfgang Roenninger
  *
  */
@@ -92 +92 @@
     _UtilExport orxonox::Vector2 get2DViewdirection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
     _UtilExport orxonox::Vector2 get2DViewcoordinates(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition);
+    _UtilExport orxonox::Vector2 get3DProjection(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle, const float detectionlimit);
+    _UtilExport bool isObjectHigherThanShipOnMap(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float mapangle);
+    _UtilExport int determineMap3DZOrder(const orxonox::Vector3& myposition, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& otherposition, const float detectionlimit);
+    _UtilExport orxonox::Vector3 getTransformedVector(const orxonox::Vector3& distance, const orxonox::Vector3& mydirection, const orxonox::Vector3& myorthonormal, const orxonox::Vector3& myside);
     _UtilExport orxonox::Vector3 getPredictedPosition(const orxonox::Vector3& myposition, float projectilespeed, const orxonox::Vector3& targetposition, const orxonox::Vector3& targetvelocity);