Question

假设我有一个aobservable，它发出2D点，表示某些路线的转折点

 public static double[][] points = new double[][]{
        {0, 0},
        {0,  10},
        {1,  10},
        {1,  0},
        {0, 0}
    };

    public static Observable<double[]> routePoints() {
        return Observable
            .from(points);
    }

这意味着机器人从原点(0,0)开始，然后转到矩形的左下角，然后是右下角，然后返回，最后回到原点。

假设现在我想要一个可观察物，它可以像机器人以恒定速度移动那样点，就像每秒1个单位一样。

因此，第一个运营商收到(0,0)并按原样重新发送。

然后它会收到(0, 10)并看到距此点的距离是10个单位，到达该点应该花费10秒。所以，新的observable应该发出

(0, 1)
(0, 2)
(0, 3)
(0, 4)
(0, 5)
(0, 6)
(0, 7)
(0, 8)
(0, 9)
(0, 10)

每秒一对，直到达到并重新传输最后一个接收点。然后操作员应该采取下一个点并对其进行相同操作。

如何使用ReactiveX完成此操作？

我怀疑我们应该实施＆＃34; bakpressure＆＃34;这里是为了减慢源的可观察性，直到随后的时间重新发出一次？

更新

我编写了下面的代码并且它有效。它使用两个flatMap s。一个是提供额外的点，并且每个点都附有时间戳（以秒为单位），另一个flatMap引入适合时间戳的延迟。

代码有效，但看起来很复杂。问题仍然存在：ReactiveX库是否包含用于处理这类事情的现成工具：

import rx.Observable;
import rx.functions.Action1;
import rx.functions.Func1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

public class EmitByTime {

   public static double speed = 1;

   public static double[][] points = new double[][]{
      {0, 0},
      {0,  10},
      {1,  10},
      {1,  0},
      {0, 0}
   };

   public static Observable<double[]> routePoints() {
      return Observable
         .from(points);
   }

   public static Observable<double[]> routeFeeder() {

      return routePoints()
         .flatMap(new Func1<double[], Observable<double[]>>() {

            double[] previous = null;

            @Override
            public Observable<double[]> call(double[] doubles) {
               if( previous == null) {
                  previous = new double[] {doubles[0], doubles[1], 0};
                  return Observable.just(previous);
               }
               else {
                  double dx = doubles[0] - previous[0];
                  double dy = doubles[1] - previous[1];
                  double dist = Math.sqrt( dx*dx + dy*dy );
                  dx /= dist;
                  dy /= dist;
                  double vx = dx * speed;
                  double vy = dy * speed;
                  double period = dist / speed;
                  double end = previous[2] + period;



                  double start = Math.ceil(previous[2] + 1);
                  ArrayList<double[]> sequence = new ArrayList<>();
                  for(double t = start; t < end; t+=1) {
                     double tt = (t - previous[2]);
                     double x = previous[0] + tt * vx;
                     double y = previous[1] + tt * vy;
                     sequence.add(new double[] {x, y, t});
                  }

                  previous = new double[] {doubles[0], doubles[1], end};
                  sequence.add(previous);

                  return Observable.from(sequence);
               }
            }
         })
         .flatMap(new Func1<double[], Observable<double[]>>() {

            long origin = System.currentTimeMillis();

            @Override
            public Observable<double[]> call(double[] doubles) {

               long now = System.currentTimeMillis();
               long due = Math.round(doubles[2]*1000) + origin;

               if( due <= now ) {
                  return Observable.just(doubles);
               }
               else {
                  return Observable.just(doubles).delay(due-now, TimeUnit.MILLISECONDS);
               }
            }
         })
         ;



   }

   public static void main(String[] args) throws InterruptedException {


      routeFeeder().subscribe(new Action1<double[]>() {
         @Override
         public void call(double[] doubles) {
            System.out.println(Arrays.toString(doubles));
         }
      });

      Thread.sleep(20000);
   }
}

Answer 1

这感觉主要像寻路问题。

我可能有一种方法可以通过它们全部转换路径中的路标集（这是路径查找位）。

类似的东西：

public Observable<Point> calculateRoute(Observable<Point> waypoints);

其中航点是您在上面提到的“转折点”;

然后你可以zip Observable.interval一个Observable个流，其中public Observable<Point> emitRoutePerSecond(Observable<Point> wayPoints) { return Observable.interval(1, TimeUnit.SECONDS) .zipWith(calculateRoute(wayPoints), (i, point) -> point); }个路由每秒会发出一次路由。

所以也许是这样的：

superagent

如何在正确（实际）时间内传递可观察的元素？

1 个答案: