Determine if the feature overlay is on for the provided zoom level at the location

@param zoom   zoom level
@param latLng lat lon location
@return true if on
@since 1.2.6
540816
public boolean isOnAtCurrentZoom(double zoom, LatLng latLng) {

        Point point = new Point(latLng.longitude, latLng.latitude);
        TileGrid tileGrid = TileBoundingBoxUtils.getTileGridFromWGS84(point, (int) zoom);

        boolean on = boundedOverlay.hasTile((int) tileGrid.getMinX(), (int) tileGrid.getMinY(), (int) zoom);
        return on;
    }
766379
public static boolean contains(LatLong[] latLongs, LatLong latLong) {
        boolean result = false;
        for (int i = 0, j = latLongs.length - 1; i < latLongs.length; j = i++) {
            if ((latLongs[i].latitude > latLong.latitude) != (latLongs[j].latitude > latLong.latitude)
                    && (latLong.longitude < (latLongs[j].longitude - latLongs[i].longitude) * (latLong.latitude - latLongs[i].latitude)
                    / (latLongs[j].latitude - latLongs[i].latitude) + latLongs[i].longitude)) {
                result = !result;
            }
        }
        return result;
    }
585156
def is_dynamic_overlay(dmap):
    
    if not isinstance(dmap, DynamicMap):
        return False
    elif dmap.callback._is_overlay:
        return True
    else:
        return any(is_dynamic_overlay(dm) for dm in dmap.callback.inputs)
58007
public void setZoomSliderVisible(boolean zoomSliderVisible)
    {
        boolean old = this.isZoomSliderVisible();
        this.zoomSliderVisible = zoomSliderVisible;
        zoomSlider.setVisible(zoomSliderVisible);
        firePropertyChange("zoomSliderVisible", old, this.isZoomSliderVisible());
    }
1192443
public boolean isFeatureEnabled(com.ibm.websphere.servlet.container.WebContainer.Feature feature) {
        return this.features.contains(feature);
    }
384512
@Override
    public void setCenter(LatLong latLong) {
        synchronized (this) {
            setCenterInternal(latLong.latitude, latLong.longitude);
        }
        notifyObservers();
    }
227099
public void singleClickAt(double lat, double lon) {
            final Coordinate coordinate = new Coordinate(lat, lon);
            if (logger.isTraceEnabled()) {
                logger.trace("JS reports single click at {}", coordinate);
            }
            fireEvent(new MapViewEvent(MapViewEvent.MAP_CLICKED, coordinate));
        }
1187412
public void getFeature(int lat, int lon) {
    info("*** GetFeature: lat={0} lon={1}", lat, lon);

    Point request = Point.newBuilder().setLatitude(lat).setLongitude(lon).build();

    Feature feature;
    try {
      feature = blockingStub.getFeature(request);
      if (testHelper != null) {
        testHelper.onMessage(feature);
      }
    } catch (StatusRuntimeException e) {
      warning("RPC failed: {0}", e.getStatus());
      if (testHelper != null) {
        testHelper.onRpcError(e);
      }
      return;
    }
    if (RouteGuideUtil.exists(feature)) {
      info("Found feature called \"{0}\" at {1}, {2}",
          feature.getName(),
          RouteGuideUtil.getLatitude(feature.getLocation()),
          RouteGuideUtil.getLongitude(feature.getLocation()));
    } else {
      info("Found no feature at {0}, {1}",
          RouteGuideUtil.getLatitude(feature.getLocation()),
          RouteGuideUtil.getLongitude(feature.getLocation()));
    }
  }
1108031
public boolean isNearTo(Location location, double distance) {
        if (this.is2DLocation() && location.is2DLocation()) {
            return this.isNearTo(location.getLocation2D(), distance);
        } else if (this.is3DLocation() && location.is3DLocation()) {
            return this.isNearTo(location.getLocation3D(), distance);
        } else {
            return false;
        }
    }
618181
function(value) {
		var any = false;

		if (value.uzoom != undefined) {
			this.elUZoom.value = value.uzoom;
			any = true;
		} else if (value.nzoom != undefined) {
			this.elUZoom.value = this.apid.f_zoom.to_universal(value.uzoom);
			any = true;
		}

		if (value.lat != undefined) {
			this.elLat.value = value.lat;
			any = true;
		}

		if (value.lon != undefined) {
			this.elLon.value = value.lon;
			any = true;
		}

		if (any) {
			this.apid.onposition();
		}
	}
1133047
def cmd_terrain_check(self, args):
        ''''''
        if len(args) >= 2:
            latlon = (float(args[0]), float(args[1]))
        else:
            try:
                latlon = self.module('map').click_position
            except Exception:
                print("No map available")
                return
            if latlon is None:
                print("No map click position available")
                return
        self.check_lat = int(latlon[0]*1e7)
        self.check_lon = int(latlon[1]*1e7)
        self.master.mav.terrain_check_send(self.check_lat, self.check_lon)
590671
@Override
    public int compareTo(LatLong latLong) {
        if (this.latitude > latLong.latitude || this.longitude > latLong.longitude) {
            return 1;
        } else if (this.latitude < latLong.latitude
                || this.longitude < latLong.longitude) {
            return -1;
        }
        return 0;
    }
1124392
public boolean isCloseTo(GeoPoint point, double tolerance, MapView mapView) {
        return getCloseTo(point, tolerance, mapView) != null;
    }
846807
public final void setLocation(final double LAT, final double LON) {
        this.lon = LON; // X
        this.lat = LAT; // Y
        this.LOCATION.setLocation(LON, LAT);
        this.LOCATION_XY.setLocation(toXY(LAT, LON));
        adjustDirection();
    }
962095
public boolean inMap(Location location)
    {
        for (String map : schedule.getMap())
        {
            if (station.inMap(map, location))
            {
                return true;
            }
        }
        return false;
    }
766576
public static boolean supports(final Feature f, final int lv) {
    final EnumSet<Feature> set =  map.get(lv);
    return set != null && set.contains(f);
  }
303326
public void setZoom(int zoom)
    {
        zoomChanging = true;
        mainMap.setZoom(zoom);
        miniMap.setZoom(mainMap.getZoom() + 4);
        if (sliderReversed)
        {
            zoomSlider.setValue(zoomSlider.getMaximum() - zoom);
        }
        else
        {
            zoomSlider.setValue(zoom);
        }
        zoomChanging = false;
    }