Aircraft rotations in an external program

[sr71684]

Greetings,

I am building a 3D visualisation tool for JSBSim in Unity.

I am having trouble rendering aircraft rotation in Unity.

So far, I can access the Euler angles describing rotation on the JSBSim side:

theta_deg = self.fdm.get_property_value("attitude/theta-deg")  # pitch
psi_deg = self.fdm.get_property_value("attitude/psi-deg")  # yaw
phi_deg = self.fdm.get_property_value("attitude/phi-deg")  # roll

Naievely plugging theta_deg, psi_deg, and phi_deg into Unity (as shown below) causes incorrect rotation. when the pitch angle is >90 or < -90.

Vector3 eulerAngles = new Vector3(
    Message.psi_deg,
    Message.phi_deg,
    Message.theta_deg
);
transform.eulerAngles = eulerAngles;

I know The order of rotations used in JSBSim is a 3-2-1 sequence or Y-P-R, or Z-Y-X.

However, the Unity documentation on Euler angles says rotations are performed around the Z axis, the X axis, and the Y axis, in that order.

Question 1: How can I convert JSBSim Euler angles to Unity Euler angles?

I tried using quaternions to fix this issue. I used SciPy to derive a quaternion

from scipy.spatial.transform import Rotation as R
r = R.from_euler("zyx", [psi_deg, theta_deg, phi_deg], degrees=True).as_quat()

and plugged that into Unity like this:

transform.rotation = new Quaternion(Message.qx, Message.qy, Message.qz, Message.qw);

but the same broken behaviour resulted.

Question 2: Is it possible to read JSBSim's aircraft quaternion from python?**

[seanmcleod]

You can't retrieve the quaternion via the property tree.

jsbsim/src/models/FGPropagate.cpp

Lines 873 to 883 in 1095804

	PropertyManager->Tie("attitude/phi-rad", this, (int)ePhi, (PMF)&FGPropagate::GetEuler);
	PropertyManager->Tie("attitude/theta-rad", this, (int)eTht, (PMF)&FGPropagate::GetEuler);
	PropertyManager->Tie("attitude/psi-rad", this, (int)ePsi, (PMF)&FGPropagate::GetEuler);
	PropertyManager->Tie("attitude/phi-deg", this, (int)ePhi, (PMF)&FGPropagate::GetEulerDeg);
	PropertyManager->Tie("attitude/theta-deg", this, (int)eTht, (PMF)&FGPropagate::GetEulerDeg);
	PropertyManager->Tie("attitude/psi-deg", this, (int)ePsi, (PMF)&FGPropagate::GetEulerDeg);
	PropertyManager->Tie("attitude/roll-rad", this, (int)ePhi, (PMF)&FGPropagate::GetEuler);
	PropertyManager->Tie("attitude/pitch-rad", this, (int)eTht, (PMF)&FGPropagate::GetEuler);
	PropertyManager->Tie("attitude/heading-true-rad", this, (int)ePsi, (PMF)&FGPropagate::GetEuler);

P.S The following are equivalent ways of accessing the property tree.

theta_deg = self.fdm.get_property_value("attitude/theta-deg")
theta_deg = self.fdm["attitude/theta-deg"]

There is a FGPropagate python class available.

jsbsim/python/jsbsim.pyx.in

Lines 105 to 137 in 1095804

	cdef class FGPropagate:
	"""@Dox(JSBSim::FGPropagate)"""
	cdef shared_ptr[c_FGPropagate] thisptr
	def __cinit__(self, FGFDMExec fdmex, *args, **kwargs):
	if fdmex is not None:
	self.thisptr.reset(new c_FGPropagate(fdmex.thisptr))
	def __bool__(self):
	"""Check if the object is initialized."""
	if self.thisptr:
	return True
	return False
	def __intercept_invalid_pointer(self):
	if not self.thisptr:
	raise AttributeError("Object is not initialized")
	def get_Tl2b(self):
	"""@Dox(JSBSim::FGPropagate::GetTl2b)"""
	self.__intercept_invalid_pointer()
	return _convertToNumpyMat(deref(self.thisptr).GetTl2b())
	def get_Tec2b(self):
	"""@Dox(JSBSim::FGPropagate::GetTec2b)"""
	self.__intercept_invalid_pointer()
	return _convertToNumpyMat(deref(self.thisptr).GetTec2b())
	def get_uvw(self):
	"""@Dox(JSBSim::FGPropagate::GetUVW)"""
	self.__intercept_invalid_pointer()
	return _convertToNumpyVec(deref(self.thisptr).GetUVW())

Which returns the matrix l2b, which internally in the C++ code has a GetQuaternion() method.

jsbsim/src/models/FGPropagate.cpp

Line 680 in 1095804

VState.qAttitudeLocal = Tl2b.GetQuaternion();

With the following implementation:

Returns the quaternion associated with this direction cosine (rotation) matrix.

jsbsim/src/math/FGMatrix33.cpp

Lines 106 to 153 in 1095804

	FGQuaternion FGMatrix33::GetQuaternion(void) const
	{
	FGQuaternion Q;
	double tempQ[4];
	int idx;
	tempQ[0] = 1.0 + data[0] + data[4] + data[8];
	tempQ[1] = 1.0 + data[0] - data[4] - data[8];
	tempQ[2] = 1.0 - data[0] + data[4] - data[8];
	tempQ[3] = 1.0 - data[0] - data[4] + data[8];
	// Find largest of the above
	idx = 0;
	for (int i=1; i<4; i++) if (tempQ[i] > tempQ[idx]) idx = i;
	switch(idx) {
	case 0:
	Q(1) = 0.50*sqrt(tempQ[0]);
	Q(2) = 0.25*(data[7] - data[5])/Q(1);
	Q(3) = 0.25*(data[2] - data[6])/Q(1);
	Q(4) = 0.25*(data[3] - data[1])/Q(1);
	break;
	case 1:
	Q(2) = 0.50*sqrt(tempQ[1]);
	Q(1) = 0.25*(data[7] - data[5])/Q(2);
	Q(3) = 0.25*(data[3] + data[1])/Q(2);
	Q(4) = 0.25*(data[2] + data[6])/Q(2);
	break;
	case 2:
	Q(3) = 0.50*sqrt(tempQ[2]);
	Q(1) = 0.25*(data[2] - data[6])/Q(3);
	Q(2) = 0.25*(data[3] + data[1])/Q(3);
	Q(4) = 0.25*(data[7] + data[5])/Q(3);
	break;
	case 3:
	Q(4) = 0.50*sqrt(tempQ[3]);
	Q(1) = 0.25*(data[3] - data[1])/Q(4);
	Q(2) = 0.25*(data[6] + data[2])/Q(4);
	Q(3) = 0.25*(data[7] + data[5])/Q(4);
	break;
	default:
	//error
	break;
	}
	return (Q);
	}

[sr71684]

Your pointers helped me find a solution. Thanks for your help.

[seanmcleod]

What was your solution? It may help someone else in the future.

[bcoconni]

@sr71684, I'd suggest to check if Unity is expecting the transformation from the body frame to the local frame or the transformation from the local frame to the body frame. These transformations are the inverse of each another and so are their matrices and quaternions so the difference matters.

Also may be you could check that scipy.spatial.transform.Rotation uses the Euler angles the same way than JSBSim does by comparing R.from_euler("zyx", [psi_deg, theta_deg, phi_deg], degrees=True).as_matrix() with the matrix fdm.get_propagate().get_Tl2b().T ?

Finally, I'm a bit surprised by your statement

Naively plugging theta_deg, psi_deg, and phi_deg into Unity (as shown below) causes incorrect rotation when the pitch angle is >90 or < -90.

The pitch angle should never be higher than 90 degrees in absolute value.