Determine if point is within bounding box

Question

How would you determine if a given point is within the bounding box?

My point is 48.847172 , 2.386597.

Boundingbox:

    "48.7998602295",
    "48.8198640442",
    "2.46138595581",
    "2.48138619423"

Answer 1

Shortest and easiest way to check whether point within the visible bounds (or any bounds in general, just use the LngLatBounds.contains() method):

return map.getBounds().contains(new mapboxgl.LngLat(LNG, LAT))

Answer 2

Based on kumetix solution, I have written the same function with is perfectly working with React Native Maps

Typescript code, you can remove the types in order to make it work with javascript as well

export function isPointInBoundaries(p: LatLng, bl: LatLng, tr: LatLng) {
  const isLongInRange = () => {
    if (tr.longitude < bl.longitude) return p.longitude >= bl.longitude || p.longitude <= tr.longitude;
    else return p.longitude >= bl.longitude && p.longitude <= tr.longitude;
  };

  return p.latitude >= bl.latitude && p.latitude <= tr.latitude && isLongInRange();
}

Which can be used like:

const p: LatLng = {longitude: 0, latitude: 0};
const mapBoundaries = mapRef.current.getMapBoundaries();
const condition = isPointInBoundaries(p, mapBoundaries.southWest, mapBoundaries.northEast)

Answer 3

This is the simplest way in my opinion.

function pointInBB(px,py,pz,bx,by,bz) {
    return px<bx&&py<by&&pz<bz
}

Answer 4

This answer is identical to kumetix's answer above; however, for the life of me, I didn't understand what was happening in there since it was condensed quite a bit. Here is the same answer with detailed explanation. Also please note that the answer is in Kotlin as opposed to JavaScript as the original post requested but it is sufficiently readable so that converting to your language shouldn't be too bad.

First define Coordinate2D and BoundingBox classes:

data class Coordinate2D (val latitude: Double, val longitude: Double)

data class BoundingBox (val north: Double, val east: Double, val south: Double, val west: Double)

Here is the function that determines whether a point is in an arbitrary bounding box

fun isPointInBoundingBox(point: Coordinate2D, boundingBox: BoundingBox): Boolean {
    //given the bounding box is an imaginary rectangle in a coordinate system
    //bounding box has 4 sides - northLine, eastLine, southLine and westLine
    //initially assume the point is not in our bounding box of interest as such:
    var isPointEastOfWestLine = false
    var isPointWestOfEastLine = false
    var isPointSouthOfNorthLine = false
    var isPointNorthOfSouthLine = false

    if (boundingBox.east < boundingBox.west) {
        //if west coordinate has a bigger value than the east, 
        //the bounding box must be crossing the dateline
        //in other words, longitude 180 is inside the box
        //let's see what's happening with the point
        if (point.longitude >= boundingBox.west) {
            //imagine a bounding box where westernmost longitude is +170 and easternmost longitude is -170
            //if the point in question has a latitude of +171 as in the case expressed in the if
            //statement, then we can conclude that point lies east of the west line
            isPointEastOfWestLine = true

            //we can also infer that the point must lie west of east line because the point's longitude is positive
            //therefore, the point's position must be to the west of the easternmost longitude of the bounding box
            isPointWestOfEastLine = true
        }

        if (point.longitude <= boundingBox.east) {
            //imagine a bounding box where westernmost longitude is +170 and easternmost longitude is -170
            //if the point in question has a latitude of -171 as in the case expressed in the if
            //statement, then we can conclude that point lies west of the east line
            isPointWestOfEastLine = true

            //we can also infer that the point must lie east of the west line because the point's longitude is negative
            //therefore, the point's position must be to the east of the westernmost longitude of the bounding box
            isPointEastOfWestLine = true
        }
    } else {
        //in the else case, bounding box does not cross the dateline, so comparisons are more straightforward
        //longitudes range from -180 to +180; therefore, western side of a bounding box will always
        //have lower value than eastern side
        if (point.longitude >= boundingBox.west) {
            //in this case, point's longitude has a higher value than the west side of the bounding box
            //we can conclude that point lies to the east of the west line of the bounding box
            isPointEastOfWestLine = true
        }
        if (point.longitude <= boundingBox.east) {
            //in this case, point's longitude has a lower value than the east side of the bounding box
            //we can conclude that point lies to the east of the west line of the bounding box
            isPointWestOfEastLine = true
        }
    }

    //comparing latitudes are little bit easier. latitude values range from -90 to +90 where
    //-90 is the southern pole and +90 is the northern pole. The more north you go, higher the values.
    if (point.latitude >= boundingBox.south) {
        //point's latitude is higher, therefore, point must lie to the north of the south line
        isPointNorthOfSouthLine = true
    }

    if (point.latitude <= boundingBox.north) {
        //point's latitude is higher, therefore, point must lie to the north of the south line
        isPointSouthOfNorthLine = true
    }

    return isPointEastOfWestLine &&
            isPointWestOfEastLine &&
            isPointNorthOfSouthLine &&
            isPointSouthOfNorthLine
}

Answer 5

This should be faster.

function doesPointCollide(p,box) {
    return !(p.x < box.left || p.x > box.right || p.y > box.bottom || p.y < box.top)
}

If the point is outside any of the dimensions we know that it's not in the bounding box, else it is in the bounding box, so we can ignore negated cases more quickly.

Answer 6

Use this function for c plus plus to check if a point exits inside a rectangle

struct Box{

Vec2 corner1;
Vec2 corner2;
Vec2 corner3;
Vec2 corner4;

};

bool boxContainsPoint(Vec2 point, Box box){

//Calculate distances from corner to corner
float abL = box.corner1.getDistance(box.corner2);////////////////////
float bcL = box.corner2.getDistance(box.corner3);////////////////////
float cdL = box.corner3.getDistance(box.corner4);////////////////////
float daL = box.corner4.getDistance(box.corner1);////////////////////

//Calculate corner touch distance//////////////////////////////////
float apL = box.corner1.getDistance(point);/////////////////////////
float bpL = box.corner2.getDistance(point);/////////////////////////
float cpL = box.corner3.getDistance(point);/////////////////////////
float dpL = box.corner4.getDistance(point);/////////////////////////

//Here we calculate the touch area
//Heron's Formula
///////////////////////////////////////////////////////////////////
float area1 = (abL + apL + bpL) / 2;///////////////////////////////
float area2 = (bcL + bpL + cpL) / 2;///////////////////////////////
float area3 = (cdL + cpL + dpL) / 2;///////////////////////////////
float area4 = (daL + dpL + apL) / 2;///////////////////////////////
float a1 = sqrtf(area1 * (area1 - abL)*(area1 - apL)*(area1 - bpL));
float a2 = sqrtf(area2 * (area2 - bcL)*(area2 - bpL)*(area2 - cpL));
float a3 = sqrtf(area3 * (area3 - cdL)*(area3 - cpL)*(area3 - dpL));
float a4 = sqrtf(area4 * (area4 - daL)*(area4 - dpL)*(area4 - apL));

//Calculate the rectangle area
float A = roundf(abL*bcL);

//Check to see if the point contains the polygon rect
if(A ==roundf(a1 + a2 + a3 + a4)) return true;
return false;

}

Answer 7

If you are using leaflet, you can create a new LatLngBounds and use its contains() operation:

var bounds = new L.LatLngBounds(
 new L.LatLng(gc.bbox['_northEast'].lat, gc.bbox['_northEast'].lng),
 new L.LatLng(gc.bbox['_southWest'].lat, gc.bbox['_southWest'].lng));

return bounds.contains(new L.LatLng(pos.latitude, pos.longitude))

Answer 8

This solution also takes in consideration a case in which the UI sends a box which crosses longitude 180/-180 (maps views on low zoom level where you can see the whole world, allow infinite cyclic horizontal scrolling, so it is possible for example that a box's bottomLeft.lng=170 while topRight.lng=-170(=190) and by that including a range of 20 degrees.

def inBoundingBox(bl/*bottom left*/: Coordinates, tr/*top right*/: Coordinates, p: Coordinates): Boolean = {
    // in case longitude 180 is inside the box
    val isLongInRange =
      if (tr.long < bl.long) {
        p.long >= bl.long || p.long <= tr.long
      } else
        p.long >= bl.long && p.long <= tr.long

    p.lat >= bl.lat  &&  p.lat <= tr.lat  &&  isLongInRange
}

Answer 9

Do just as usual:

if( bb.ix <= p.x && p.x <= bb.ax && bb.iy <= p.y && p.y <= bb.ay ) {
    // Point is in bounding box
}

bb is the bounding box, (ix,iy) are its top-left coordinates, and (ax,ay) its bottom-right coordinates. p is the point and (x,y) its coordinates.

Answer 10

There are quite nice utility methods for CGRect and CGPoint (assuming you don't mind fact that they are using CGFloat for storing coordinates - and looking at your values, you don't :-) ).

You can do it like that:

// Create bounding box
CGRect area = CGRectMake(x, y, width, height);

// Define point
CGPoint point = CGPointMake(pX, pY);

/Check
BOOL isInside = CGRectContainsPoint(area, point);