顯示FloorPlan並獲得IndoorAtlas的位置

Question

有沒有關於如何使用IndoorAtlas SDK的資源？

我對如何顯示floorPlan和獲取當前位置感到困惑。

請幫助我。

Answer 1

這裏是非常大致有：

1）初始化IndoorAtlas例如：

IndoorAtlas ia = IndoorAtlasFactory.createIndoorAtlas(context, listener, apiKey, apiSecret); 

2）獲取平面圖的實例：

FutureResult<FloorPlan> result = ia.fetchFloorPlan(floorPlanId); 
result.setCallback(new ResultCallback<FloorPlan>() { 
      @Override 
      public void onResult(final FloorPlan result) { 
       mFloorPlan = result; 
       loadFloorPlanImage(result); 
      } 
      // handle error conditions too 
} 

3）獲得的實際圖像：

void loadFloorPlanImage(FloorPlan floorPlan) { 
    BitmapFactory.Options options = createBitmapOptions(floorPlan); 
    FutureResult<Bitmap> result = ia.fetchFloorPlanImage(floorPlan, options); 
    result.setCallback(new ResultCallback<Bitmap>() { 
      @Override 
      public void onResult(final Bitmap result) { 
       // now you have floor plan bitmap, do something with it 
       updateImageViewInUiThread(result); 
      } 
      // handle error conditions too 
    } 
} 

4）啓動定位：在平面圖

ia.startPositioning(venueId, floorId, floorPlanId); 

5）顯示的位置：

public void onServiceUpdate(ServiceState state) { 

    // get position on original floor plan image 
    int i = state.getImagePoint().getI(); 
    int j = state.getImagePoint().getJ(); 

    // take into account how your floor plan image has been scaled 
    // and draw position 
    PointF scaledPoint = new PointF(); 
    Util.calculateScaledPoint((int) floorPlan.dimensions[0], (int) floorPlan.dimensions[1], i, j, mImageView, scaledPoint); 

    drawNewPositionInUiThread(scaledPoint.x, scaledPoint.y); 

} 

當然，你可以開始先定位，然後獲取圖像。你也可以在本地緩存圖片，但就像說的那樣，這大致如何。

Util.java：

public class Utils { 


    /** 
    * Calculates scaling factor for an image with original dimensions of 
    * {@code originalWidth x originalHeight} being displayed with {@code imageView}. 
    * 
    * The assumption with this example code is that a) layout has been already performed for 
    * {@code imageView} and that {@link android.widget.ImageView.ScaleType#CENTER_INSIDE} is used. 
    * 
    * @param originalWidth height of the original bitmap to be displayed using {@code imageView} 
    * @param originalHeight width of the original bitmap to be displayed using {@code imageView} 
    */ 
    public static float calculateScaleFactor(int originalWidth, int originalHeight, 
              ImageView imageView) { 

     if (imageView.getScaleType() != ImageView.ScaleType.CENTER_INSIDE) { 
      throw new IllegalArgumentException("only scale type of CENTER_INSIDE supported, was: " 
        + imageView.getScaleType()); 
     } 

     final int availableX = imageView.getWidth() 
       - (imageView.getPaddingLeft() + imageView.getPaddingRight()); 
     final int availableY = imageView.getHeight() 
       - (imageView.getPaddingTop() + imageView.getPaddingBottom()); 

     if (originalWidth > availableX || originalHeight > availableY) { 
      // original image would not fit without scaling 
      return originalWidth > availableX 
        ? availableX/(float) originalWidth 
        : availableY/(float) originalHeight; 
     } else { 
      return 1f; // no scaling required 
     } 

    } 


    /** 
    * Calculates point where to draw coordinates {@code x} and {@code y} in a bitmap that's 
    * original dimensions were {@code originalWidth x originalHeight} and may now be scaled down 
    * as it's been displayed with {@code imageView}. 
    * 
    * @param originalWidth width of the original bitmap before any scaling 
    * @param originalHeight height of the original bitmap before any scaling 
    * @param x    x-coordinate on original bitmap 
    * @param y    y-coordinate on original bitmap 
    * @param imageView  view that will be used to display bitmap 
    * @param point   point where result value is to be stored 
    * @see #calculateScaleFactor(int, int, ImageView) 
    */ 
    public static void calculateScaledPoint(int originalWidth, int originalHeight, 
              int x, int y, 
              ImageView imageView, 
              PointF point) { 


     final float scale = calculateScaleFactor(originalWidth, originalHeight, imageView); 
     final float scaledWidth = originalWidth * scale; 
     final float scaledHeight = originalHeight * scale; 

     // when image inside view is smaller than the view itself and image is centered (assumption) 
     // there will be some empty space around the image (here offset) 
     final float offsetX = Math.max(0, (imageView.getWidth() - scaledWidth)/2); 
     final float offsetY = Math.max(0, (imageView.getHeight() - scaledHeight)/2); 

     point.x = offsetX + (x * scale); 
     point.y = offsetY + (y * scale); 


    } 


}