Google Maps Android API：根据GroundOverlay的PNG已知的像素绘制多边形

Question

I'm adding a PNG file as an own floorplan on top of Google Maps with the Google Maps Android API with the following code:

GroundOverlayOptions groundOverlayOptions = new GroundOverlayOptions();
BitmapDescriptor bitmapDescriptor = BitmapDescriptorFactory.fromAsset("building-d.png");
groundOverlayOptions.image(bitmapDescriptor);
groundOverlayOptions.anchor(0, 1);

LatLng buildingSW = new LatLng(47.014815, 8.305098);
LatLng buildingNE = new LatLng(47.015148, 8.305440);
LatLng buildingNW = new LatLng(47.015168, 8.305144);
LatLng buildingSE = new LatLng(47.014792, 8.305385);

Location swLoc = locationFromLatLng(buildingSW);
Location seLoc = locationFromLatLng(buildingSE);
Location nwLoc = locationFromLatLng(buildingNW);
Location neLoc = locationFromLatLng(buildingNE);

float angle = swLoc.bearingTo(nwLoc);
groundOverlayOptions.bearing(angle);

float width = swLoc.distanceTo(seLoc);
groundOverlayOptions.position(buildingSW, width);

mMap.addGroundOverlay(groundOverlayOptions);

Now I know that in the PNG there is a room at pixel coordinates 422/301, 708/301, 422/10 and 708/10 (those are the corners). I'd like to draw a polygon over the GroundOverlay covering that room. How should I do that? Do I need to convert my pixel-coordinates to LatLng and if so, how?

And by the way: Do I really have to use PNGs for GroundOverlay s and is there no other supported vector-format like eps, pdf, ...?

Answer 1

You should work in this way: Your indoor map positions should be relative to a specific point (BOTTOM-LEFT is 0,0 let's say), then all the other positions will be relative to that point in meters, so you will endup in values under 100meters usually.

Having this you have to "move, rotate and scale" the indoor map with respect to the world. Just take a map on a desktop which is not LAT/LNG and find the coordinates for the same indoor points you have (usually we get real and indoor position for bottom-left and top-right positions) so you can find where it should be in the world. Take a look also at the scaling factor (depending on the latitude, the map must be scaled) https://en.wikipedia.org/wiki/Mercator_projection#Scale_factor

We calculate that value by doing something like 1/cos(latitudeINradians)

public static double getScalingFactor(double latitude) {
        return 1 / (Math.cos(Math.toRadians(latitude)));
    }

Let me know if you can find a way, otherwise i will search and try to strip our code

Answer 2

Having seen your comment to the other answer, let me complete with some code:

Having set the "origin" in latlng 47.014816, 8.305098, you have to convert those coordinates to mercator and you can do something similar to the below:

public boolean initializeByTwoCouplesOfCooordsAndScale(double[] coordAreal, double[] coordBreal, double[] coordAvirtual, double[] coordBvirtual, double scalingFactor) {
    if (coordAreal[0] == coordBreal[0] && coordAvirtual[1] == coordBvirtual[1] && coordAreal[1] == coordBreal[1] && coordAvirtual[0] == coordBvirtual[0]) {
        System.err.println("Coordinates must not be the same!");
        return false;
    }
    // aPoint is considered the "origin" point (0,0)
    aPoint = coordAreal;
    bPoint = coordAvirtual;
    // now calculate the angle of the Real world coordinate for the points
    double deltaRy = coordBreal[1] - coordAreal[1];
    double deltaRx = coordBreal[0] - coordAreal[0];
    double aR = Math.atan2(deltaRy, deltaRx);
    // Now calculate the angle of the virtual world coordinates
    double deltaVy = coordBvirtual[1] - coordAvirtual[1];
    double deltaVx = coordBvirtual[0] - coordAvirtual[0];
    double aV = Math.atan2(deltaVy, deltaVx);
    // Set the transformation angle as the difference between the real and the virtual angles.
    mPhi= (aR - aV);
    // Set the scaling factor as the provided one
    mScale = (scalingFactor);//scaling factor is in function below
    // Calculate the scaling factor error correction using the distances of the two systems.
    return true;
}

public static double getScalingFactor(double latitude) { return 1 / (Math.cos(Math.toRadians(latitude))); }

So you can call the method:

initializeByTwoCouplesOfCooordsAndScale(new double[]{MERCATOR_LNG,MERCATOR_LAT},//real coordinates for point A REMEMBER: LNG,LAT = x,y!
new double[]{0d,0d}, //Virual coordinates for point A
new double[]{MERCATOR_POINT_B_LNG, MERCATOR_POINT_B_LAT},//real point B
new double[]{X_METERS,Y_METERS},//coordinates in meters of point B in virtual map
getScalingFactor(47.014816));

then you can transform with this function:

public double[] transform(double[] coord) {
        double[] transCoord = new double[2];
    double xscaled = (coord[0] - bPoint[0]) * mScale; // XXX bPoint is the position of origin point in the "VIRTUAL" world. [0] is the x coordinate
    double yscaled =  (coord[1] - bPoint[1]) * mScale;

    transCoord[0] = (xscaled * Math.cos(mPhi)) - (yscaled * Math.sin(mPhi)) + aPoint[0]; //aPoint is the point with real coordinates of origin!
    transCoord[1] = (xscaled * Math.sin(mPhi)) + (yscaled * Math.cos(mPhi)) + aPoint[1];
    return transCoord;
}

you can find online a way to convert latlng to mercator, it just a bunch of math ;)