Пример #1
0
 public TransformStorage(Transform data, uint frameId, uint childFrameId)
 {
     this.rotation       = data.basis;
     this.translation    = data.origin;
     this.stamp          = TimeCache.toLong(data.stamp.data);
     this.frame_id       = frameId;
     this.child_frame_id = childFrameId;
 }
Пример #2
0
        private bool canTransformNoLock(uint target_id, uint source_id, Time time, out string error_msg)
        {
            error_msg = null;
            if (target_id == 0 || source_id == 0)
            {
                return(false);
            }

            CanTransformAccum accum = new CanTransformAccum();

            if (walkToTopParent(accum, TimeCache.toLong(time.data), target_id, source_id, out error_msg) == TF_STATUS.NO_ERROR)
            {
                return(true);
            }
            return(false);
        }
Пример #3
0
        private TF_STATUS getLatestCommonTime(uint target_id, uint source_id, ref ulong time, out string error_str)
        {
            error_str = null;
            if (target_id == source_id)
            {
                time = TimeCache.toLong(ROS.GetTime(DateTime.UtcNow).data);
                return(TF_STATUS.NO_ERROR);
            }

            List <TimeAndFrameID> lct = new List <TimeAndFrameID>();

            uint  frame       = source_id;
            uint  depth       = 0;
            ulong common_time = ulong.MaxValue;

            while (frame != 0)
            {
                TimeCache cache;
                if (!frames.ContainsKey(frame))
                {
                    break;
                }
                cache = frames[frame];
                TimeAndFrameID latest = cache.getLatestTimeAndParent();
                if (latest.frame_id == 0)
                {
                    break;
                }
                if (latest.time != 0)
                {
                    common_time = Math.Min(latest.time, common_time);
                }
                lct.Add(latest);
                frame = latest.frame_id;
                if (frame == target_id)
                {
                    time = common_time;
                    if (time == ulong.MaxValue)
                    {
                        time = 0;
                    }
                    return(TF_STATUS.NO_ERROR);
                }
                ++depth;
                if (depth > MAX_GRAPH_DEPTH)
                {
                    if (error_str != null)
                    {
                        error_str = "The tf tree is invalid because it contains a loop.";
                    }
                    return(TF_STATUS.LOOKUP_ERROR);
                }
            }

            frame       = target_id;
            depth       = 0;
            common_time = ulong.MaxValue;
            uint common_parent = 0;

            while (true)
            {
                TimeCache cache;
                if (!frames.ContainsKey(frame))
                {
                    break;
                }
                cache = frames[frame];
                TimeAndFrameID latest = cache.getLatestTimeAndParent();
                if (latest.frame_id == 0)
                {
                    break;
                }
                if (latest.time != 0)
                {
                    common_time = Math.Min(latest.time, common_time);
                }

                foreach (TimeAndFrameID tf in lct)
                {
                    if (tf.frame_id == latest.frame_id)
                    {
                        common_parent = tf.frame_id;
                        break;
                    }
                }
                frame = latest.frame_id;

                if (frame == source_id)
                {
                    time = common_time;
                    if (time == uint.MaxValue)
                    {
                        time = 0;
                    }
                    return(TF_STATUS.NO_ERROR);
                }
                ++depth;
                if (depth > MAX_GRAPH_DEPTH)
                {
                    if (error_str != null)
                    {
                        error_str = "The tf tree is invalid because it contains a loop.";
                    }
                    return(TF_STATUS.LOOKUP_ERROR);
                }
            }
            if (common_parent == 0)
            {
                error_str = "" + frameids_reverse[source_id] + " DOES NOT CONNECT TO " + frameids_reverse[target_id];
                return(TF_STATUS.CONNECTIVITY_ERROR);
            }
            for (int i = 0; i < lct.Count; i++)
            {
                if (lct[i].time != 0)
                {
                    common_time = Math.Min(common_time, lct[i].time);
                }
                if (lct[i].frame_id == common_parent)
                {
                    break;
                }
            }
            if (common_time == uint.MaxValue)
            {
                common_time = 0;
            }
            time = common_time;
            return(TF_STATUS.NO_ERROR);
        }
Пример #4
0
        public bool lookupTransform(string target_frame, string source_frame, Time time, out Transform transform, out string error_string)
        {
            transform    = null;
            error_string = null;

            string mapped_tgt = resolve(tf_prefix, target_frame);
            string mapped_src = resolve(tf_prefix, source_frame);

            if (mapped_tgt == mapped_src)
            {
                transform                = new Transform();
                transform.origin         = new Vector3();
                transform.basis          = new Quaternion();
                transform.child_frame_id = mapped_src;
                transform.frame_id       = mapped_tgt;
                transform.stamp          = ROS.GetTime(DateTime.UtcNow);
                return(true);
            }

            TF_STATUS retval;
            uint      target_id = getFrameIDInternal(mapped_tgt);
            uint      source_id = getFrameIDInternal(mapped_src);

            TransformAccum accum = new TransformAccum();

            retval = walkToTopParent(accum, TimeCache.toLong(time.data), target_id, source_id, out error_string);
            if (retval != TF_STATUS.NO_ERROR)
            {
                error_string = error_string ?? "UNSPECIFIED";
                switch (retval)
                {
                case TF_STATUS.CONNECTIVITY_ERROR:
                    error_string = "NO CONNECTIONSZSZ: " + error_string;
                    break;

                case TF_STATUS.EXTRAPOLATION_ERROR:
                    error_string = "EXTRAPOLATION: " + error_string;
                    break;

                case TF_STATUS.LOOKUP_ERROR:
                    error_string = "LOOKUP: " + error_string;
                    break;

                default:
                    if (accum.result_quat == null || accum.result_vec == null)
                    {
                        error_string = "ACCUM WALK FAIL!";
                    }
                    break;
                }
            }
            if (accum.result_vec != null && accum.result_quat != null)
            {
                transform                = new Transform();
                transform.origin         = accum.result_vec;
                transform.basis          = accum.result_quat;
                transform.child_frame_id = mapped_src;
                transform.frame_id       = mapped_tgt;
                transform.stamp          = new Time(TimeData.FromTicks((long)accum.time));
            }
            return(retval == TF_STATUS.NO_ERROR);
        }