將從點XY創建的2D路徑劃分成相等的塊Java

Question

我有一個點A，B，C，D，E ... N的數組，當連接成一條路徑時。

如何我可以把這個路徑等於塊，並獲得每塊XY的位置？

編輯：由於用戶Hedja建議我已經創建函數來處理這個問題，但我無法檢測出塊被分裂的兩個子路徑

public ArrayList<PointF> getPositions(ArrayList<PointF> mInput,float mChunkSize){ 
    ArrayList<PointF> mResult = new ArrayList<PointF>(); 
    float mModulo = 0f; 
    for (int i = 0;i<mInput.size()-1;i++){ 
     //distance to next 
     float mDistanceAB = MyGameMath.distance(mInput.get(i).x, mInput.get(i).y,mInput.get(i+1).x,mInput.get(i+1).y); 
     //how many parts will fit 
     float mCountParts = (float) (mDistanceAB/mChunkSize); //how much parts will fit 
     //if distance is greater than chunk size 
     if (Math.abs(mDistanceAB)>=mChunkSize) { 
      Log.i("Chunk","Index "+(i)+" -> "+(i+1)+" = "+mCountParts+", rest="+mModulo); 
      float dx = mInput.get(i+1).x-mInput.get(i).x; 
      float dy = mInput.get(i+1).y-mInput.get(i).y; 
      float ux = dx/mDistanceAB; 
      float uy = dy/mDistanceAB; 
      for (int y=0;y<=mCountParts;y++){ 
       //for every part 
       float nx = mInput.get(i).x+ux*mChunkSize*y; 
       float ny = mInput.get(i).y+uy*mChunkSize*y; 
            //Log.i("Chunk","at:"+nx+","+ny); 
       mResult.add(new PointF(nx, ny)); 
      } 
     } 
     mModulo = mDistanceAB%mChunkSize; //how much left from previous subpath 
    } 
    return mResult; 
} 

Answer 1

所以我假設你有一些類似的地方Point是形勢屬性爲x和y的對象。

Point[] points = new Points[]{ //Your Points } 
List<Point> chunkedPoints = new ArrayList<Point>(); 

我還假設「等塊」是指每條路徑的距離。

首先你通過數組迭代，因爲你將不再需要在最後一個點後計算「下一點」，你可以在最後：

for(int i = 0; i < points.length-1; i++) { //Skip the last element 
    //chunking here 
} 
chunkedPoints.add(points[points.length-1]); //Add the last element 

你將它添加需要找到單位矢量，也就是你前往下一個點的方向。所以，首先你需要從一個點到下一個得到x和y的區別：

double dx = point[i].x - point[i+1].x; 
double dy = point[i].y - point[i+1].y; 

然後從該點到下一個（簡單的畢達哥拉斯）的距離： 雙距離= Math.sqrt（DX * DX + DY * DY）;

的單位向量現在可以計算

double ux = dx/distance; 
double uy = dy/distance; 

所以，現在你知道去哪裏旅行，你需要指定你想多遠，沿着它的旅行，我會打電話給這個CHUNK_SIZE。

double nx = point[i].x + ux*CHUNK_SIZE; 
double ny = point[i].y + uy*CHUNK_SIZE; 

nx和ny是你的新點的座標。但是，您需要檢查您是否通過了下一個要點，以便您可以停止。你的問題沒有指定你做什麼，當你到達一個子路徑的結束行駛無塊的大小，所以我會認爲你只是停留在這，所以代碼變成：

double nx = point[i].x; 
double ny = point[i].y; 
for(
    //This part can be tidier 
    int count = 0; 
    count < CHUNK_SIZE && nx+ux != points[i+1].x && ny+uy != points[i+1].y; 
    count++ 
) { 
    nx += ux; 
    ny += uy; 
} 
Point newPoint = new Point(nx, ny); 

現在，你有你的新點，你可以從那裏開始，瞄準與之前相同的點，或者如果它與下一點相同，則從此之後的點開始。所以你的循環現在像

chunkedPoints.add(points[0]); 
for(int i = 0; i < points.length-1; i++) { //Skip the last element 
    Point newPoint; 
    do { 
     //chunking 
     newPoint = new Point(nx, ny); 
     chunkedPoints.add(newPoint); 
    } while(!newPoint.equals(points[i+1])); 
} 
chunkedPoints.add(points[points.length-1]); //Add the last element 

希望有所幫助。

我還沒有測試過這個，但是我在過去做了一些非常相似的事情，所以它應該可以工作。

編輯：好吧，我已經看到你的編輯，並誠實地不知道你的問題是什麼問。抱歉。