Sự khác biệt về Project Tango onPoseAvailable() và getPoseAtTime()

Question

Tôi thấy sự khác biệt đáng kể giữa các tư thế từ số gọi lại onPoseAvailable() và Tango.getPoseAtTime(). Tôi đã viết một chương trình thử nghiệm trong đó trong onPoseAvailable() Tôi đã đăng nhập các tư thế giao và sử dụng getPoseAtTime() để yêu cầu tư thế bằng cách sử dụng dấu thời gian từ 2 cuộc gọi lại trước đó. KEY_BOOLEAN_SMOOTH_POSE được định cấu hình false. Đây là đoạn mã nào đó (biến timestamps_ thành viên là một LinkedList<Double>):

@Override 
public void onPoseAvailable(TangoPoseData poseData) { 
    if (poseData != null && poseData.statusCode == TangoPoseData.POSE_VALID) { 
     Log.v("bug", 
     String.format("onPoseAvailable t: %f, base: %d, target %d, p: (%f, %f, %f)", 
      poseData.timestamp, 
      poseData.baseFrame, 
      poseData.targetFrame, 
      poseData.translation[0], poseData.translation[1], poseData.translation[2])); 
     timestamps_.add(poseData.timestamp); 
     if (timestamps_.size() > 3) 
     timestamps_.remove(); 
    } 

    if (timestamps_.isEmpty()) 
     return; 

    TangoCoordinateFramePair framePair = new TangoCoordinateFramePair(
     TangoPoseData.COORDINATE_FRAME_START_OF_SERVICE, 
     TangoPoseData.COORDINATE_FRAME_DEVICE); 
    poseData = tango_.getPoseAtTime(timestamps_.getFirst(), framePair); 
    if (poseData != null && poseData.statusCode == TangoPoseData.POSE_VALID) { 
     Log.v("bug", 
     String.format("getPoseAtTime t: %f, base: %d, target %d, p: (%f, %f, %f)", 
      poseData.timestamp, 
      poseData.baseFrame, 
      poseData.targetFrame, 
      poseData.translation[0], poseData.translation[1], poseData.translation[2])); 
    } 
} 

Dưới đây là một đoạn trích từ một bản ghi thực tế (tôi đã deinterleaved các cuộc gọi đăng nhập cho rõ ràng):

onPoseAvailable t: 2732.762486, base: 2, target 4, p: (0.280245, 0.412468, 0.562201) 
onPoseAvailable t: 2732.802553, base: 2, target 4, p: (0.296951, 0.420919, 0.599938) 
onPoseAvailable t: 2732.852638, base: 2, target 4, p: (0.317444, 0.429809, 0.646445) 
onPoseAvailable t: 2732.882689, base: 2, target 4, p: (0.330845, 0.434106, 0.676810) 
onPoseAvailable t: 2732.932774, base: 2, target 4, p: (0.350995, 0.439777, 0.723639) 
onPoseAvailable t: 2732.962825, base: 2, target 4, p: (0.363319, 0.442731, 0.754508) 
onPoseAvailable t: 2732.992875, base: 2, target 4, p: (0.373911, 0.445289, 0.784786) 
onPoseAvailable t: 2733.032943, base: 2, target 4, p: (0.387709, 0.448182, 0.822682) 
onPoseAvailable t: 2733.062994, base: 2, target 4, p: (0.398502, 0.450481, 0.852662) 
onPoseAvailable t: 2733.073011, base: 2, target 4, p: (0.401869, 0.451084, 0.862530) 
onPoseAvailable t: 2733.103062, base: 2, target 4, p: (0.411136, 0.452486, 0.890441) 

getPoseAtTime t: 2732.712401, base: 2, target 4, p: (0.269301, 0.410911, 0.549182) 
getPoseAtTime t: 2732.732435, base: 2, target 4, p: (0.277217, 0.415130, 0.567040) 
getPoseAtTime t: 2732.762486, base: 2, target 4, p: (0.288928, 0.421914, 0.595162) 
getPoseAtTime t: 2732.802553, base: 2, target 4, p: (0.305241, 0.429648, 0.632158) 
getPoseAtTime t: 2732.852638, base: 2, target 4, p: (0.324359, 0.437655, 0.680300) 
getPoseAtTime t: 2732.882689, base: 2, target 4, p: (0.332997, 0.442538, 0.712727) 
getPoseAtTime t: 2732.932774, base: 2, target 4, p: (0.353665, 0.447269, 0.759725) 
getPoseAtTime t: 2732.962825, base: 2, target 4, p: (0.369174, 0.451645, 0.790263) 
getPoseAtTime t: 2732.992875, base: 2, target 4, p: (0.382584, 0.454754, 0.819555) 
getPoseAtTime t: 2733.032943, base: 2, target 4, p: (0.396857, 0.456922, 0.856626) 
getPoseAtTime t: 2733.062994, base: 2, target 4, p: (0.409672, 0.460060, 0.888748) 

Hãy xem mục getPoseAtTime() cuối cùng, với dấu thời gian 2733.062994. Lưu ý rằng giá trị vị trí của nó không khớp với tư thế từ onPoseAvailable với dấu thời gian giống nhau. Có gì đó không đúng ở đây.

Tôi đã xem xét rằng một phù hợp spline của tư thế sẽ không nhất thiết cần phải đi qua các điểm kiểm soát, nhưng tôi không nghĩ rằng đó là một lời giải thích chấp nhận được. Trước hết, nó không có nhiều ý nghĩa để có một API cung cấp các giá trị khác nhau cho cùng một phép đo. Nhưng ngoài các con số thực tế không trở lại phỏng đoán đó.

Nhìn vào giá trị getPoseAtTime() Y, 0,460060. Điều này nằm ngoài phạm vi Y của tất cả các giá trị Y onPoseAvailable() Y, cả trước và sau (trên toàn bộ nhật ký là vấn đề thực tế). Không có mô hình nội suy hợp lý nào có thể tạo ra giá trị này.

Tôi đoán câu hỏi là những gì đang diễn ra ở đây? Các tư thế không nhất quán nên ít nhất một trong số chúng sai (nếu không phải cả hai). Tôi đoán là onPoseAvailable() có nhiều khả năng là chính xác hơn.

Đây là một đồ thị của vị trí Y so với thời điểm hai pose phương pháp (Nash phát hành) với văn phòng phẩm tablet trong dock của nó:

Dòng màu xanh là onPoseAvailable() callback và đường màu đỏ là số phiếu bầu là getPoseAtTime(). Những kết quả này thật kỳ lạ. Nếu các giá trị sẽ khác nhau, tôi cho rằng giá trị được thăm dò sẽ mượt mà hơn vì nó có thể được lọc bằng cách sử dụng các đóng góp từ mẫu trước và sau thời gian thăm dò, trong khi giá trị gọi lại sẽ không được lọc hoặc lọc chỉ bằng cách sử dụng trước mẫu. Nhưng đó không phải là những gì chúng ta thấy - giá trị được thăm dò xuất hiện nhiều ồn ào hơn.

Đây là biểu đồ tương tự được chụp trong khi tôi di chuyển máy tính bảng lên và xuống. Giá trị được thăm dò vẫn có tần số cao hơn, và hai tín hiệu không theo dõi đặc biệt chặt chẽ.

Answer 1

Cảm ơn rhashimoto đã chỉ ra điều đó!

EDIT

tôi phải chỉnh sửa bài trước của tôi. Tôi tuyên bố rằng tôi đã có một trôi dạt lớn hơn trong khi sử dụng GetPoseAtTime thay vì tư thế của cuộc gọi lại OnPoseAvailable.

Nó chỉ là một cách khác. Tôi nhận được kết quả tốt hơn nhiều với GetPoseAtTime.

Tôi đã thực hiện quét bằng cách quay 360 ° trên ghế của mình. Tôi bắt đầu và dừng lại ở bàn của tôi như bạn có thể thấy trong hình.

bắt đầu và kết thúc chu kỳ quét (nhấp vào nó để giải quyết hơn)

Những đám mây điểm trên sử dụng đặt ra GetPoseAtTime và những đám mây điểm dưới đây sử dụng gây ra bởi các callback OnPoseAvailable. Cả hai đều bị bắt cùng một lúc. Việc trôi dạt với GetPoseAtTime là biên, nhưng với OnPoseAvailable gọi lại thực sự rất lớn.

Điều tôi phát hiện ra cho đến nay là GetPoseAtTime sử dụng biểu đồ đặt ra và sửa các tư thế nếu phát hiện kết thúc vòng lặp see this article. Tôi đã thử nghiệm nếu kết quả trở nên tốt hơn, nếu tôi truy cập tư thế ngay lập tức với một đám mây điểm có sẵn hoặc chỉ ở cuối khi tôi đang hợp nhất tất cả các đám mây điểm.

Và quả thực là kết quả tốt hơn. Vì vậy, kinh nghiệm của tôi cho đến nay là:

OnPoseAvailabe callback < GetPoseAtTime ngay lập tức với một điểm đám mây có sẵn < GetPoseAtTime vào cuối quét