yaw | Live coding a 3D World | Computer Vision library

Well, for starters, you don't need to convert your downloaded string to an ASCII encoded TBytes. TJSONObject.ParseJSONValue() has an overload that takes a string as input.

Second, LJsonObj.Get('ATTITUDE').JsonValue will return a TJSONObject, which you are incorrectly type-casting to a TJSONPair. But that doesn't matter, since you are then ignoring that TJSONPair and instead incorrectly type-casting the input parameter sVALUE from a string to a TJSONPair and then trying to access its children. That is why you are getting the Access Violation.

But even if you were able to find the TJSONPair for the roll value, you are returning the string value of its JsonString (name) property, not the string value of its JsonValue (value) property.

Try this instead:

You're trying to send the search value in the AJAX as JSON, but your PHP is not set up to read JSON. (And it makes no sense to use JSON anyway, just to send a single value).

Just send the form data in form-url-encoded format, as it would be if you submitted the form without AJAX. jQuery can help you with this - e.g.

So actually the way you are supposed to write such a code is that you register the subscribers and publisher inside the initialisation routine. The subscribers continue to work in a separate thread: Each time a new data is sent to them they will launch the callback function (which in this case saves the message data to a local copy inside the class). This is done independently of the main thread. The main thread enters an infinite loop (as long as ROS is running) in which it takes the data (that is written from the other subscriber threads) to periodically perform calculations on it and publish it with a pre-defined rate.

One can't though guarantee that the same data is not processed twice. If that is not what you need then have a look at the other communication methods such as ROS services and actionlibs. ROS topics may be dropped etc. The other communication methods are though significantly more complicated.

Your code has several errors. You are lucky that Python is translated and not compiled and it never entered the relevant code parts.

• self.car_yaw and self.car_yaw should be actually initialised with a float and not with None.
• Functions like subscriber, publisher and calculation are never called inside your call.
• ros.Rate.sleep() and rospy.spin() have nothing to do inside the publisher routine. They are used to put the thread into an endless loop as long as ROS is running. This happens once inside a program only and that inside the main loop!
• exact_pose has actually to use the local values inside the class like self.line_pos and not the subscribers like self.line_pose_sub the subscribers are only executed when they receive new data. You can't force a subscriber to check for new data the way you seem to try it!
• while and ros.spin() does not work in combination. In C++ there is ros::spinOnce() but there is no equivalent in Python. You therefore need to use while and rospy.Rate.sleep(d) instead!
• rospy.Rate.sleep requires a duration as first input argument and can't be left void.
• You include a lot of libraries your code actually does not need.

I tried to restructure it and the following code works:

See Euler angles to quaternion conversion.

Or otherwise, if you'd like to calculate quaternion components directly from the rotation matrix, see this page.

I think your issue here is that the throttle bool is assigned only once when the script is initialized. If you want to keep it similar you could turn it into a property instead.

I think you should convert your csv file to json format and then look at this site on how to transform the dictionary into a pandas dataframe : https://www.delftstack.com/fr/howto/python-pandas/how-to-convert-python-dictionary-to-pandas-dataframe/#:~:text=2%20banana%2012-,M%C3%A9thode%20pandas.,le%20nom%20de%20la%20colonne.

If I’m understanding you correctly each of these observable emit in approximately the same intervals and should be about the same time. You want to only have the new combined object after all three observable have emitted there mew values and have been combined. To do this I would mix combine latest and distinctUntilChanged like this. (Please excuse typos as this is done on my phone)

Yaw, Roll and Pitch are Euler angles - the image below shows a more easy to understand example, it is important to note that the rotations are not in relation to the global axis but are in fact in relation to objects axis that's why a plane is a good thing to think about. Also there are several different formats of Euler angles to understand better look at the wiki

looking at the github link you provided I have found the following:

1. the points contain the coordinates of different facial features within the frame, where:

   X=points[0:5] Y=points[5:10]

2. they do not measure these angles in degrees:

Roll: -x to x (0 is frontal, positive is clock-wise, negative is anti-clock-wise)

Yaw: -x to x (0 is frontal, positive is looking right, negative is looking left)

Pitch: 0 to 4 (0 is looking upward, 1 is looking straight, >1 is looking downward)

1. the function for Yaw, Roll and Pitch do not return the angle:

what is returned from Roll is the Y coordinate of the left eye minus the y coordinate of the right eye

Yaw is essentially calculating which eye the noise is closer to along the x axis - as you turn your head the nose appears closer to one eye from an observer

1. find_pose might have what you are looking for but I need to do further research into what is meant by xfrontal and yfrontal - you may need to pose the question directly to the person on github

Update: after posing the question directly to the developer, they have responded with the following:

Roll, Yaw and Pitch are in pixels and provide an estimate of where the face looking at. In case of mtcnn Roll is (-50 to 50), Yaw is (-100 to 100). Pitch is 0 to 4 because you can divide the distance between eyes and lips into 4 units where one unit is between lips to nose-tip and 3 units between nose-tip to eyes.

Xfrontal and Yfrontal provide pose (Yaw and Pitch only) in terms of angles (in degrees) along X and Y axis, respectively. These values are obtained after compensating the roll (aligning both the eyes horizontally).

https://github.com/fisakhan/Face_Pose/issues/2

If we look at the training code, and the authors' paper,* we see that the loss function is a sum of two losses:

1. the raw model output (vector of probabilities for each bin category):