code: def geom_bin2d(
      mapping=None,
      *,
      data=None,
      stat=None,
      position=None,
      show_legend=None,
      sampling=None,
      tooltips=None,
      bins=None,
      binwidth=None,
      drop=None,
      color_by=None,
      fill_by=None,
      **other_args,
  ):
      """
      Divides the plane into a grid and color the bins by the count of cases in them.
  
      Parameters
      ----------
      mapping : `FeatureSpec`
          Set of aesthetic mappings created by `aes()` function.
          Aesthetic mappings describe the way that variables in the data are
          mapped to plot "aesthetics".
      data : dict or Pandas or Polars `DataFrame`
          The data to be displayed in this layer. If None, the default, the data
          is inherited from the plot data as specified in the call to ggplot.
      stat : str, default='bin2d'
          The statistical transformation to use on the data for this layer, as a string.
      position : str or `FeatureSpec`, default='identity'
          Position adjustment, either as a string ('identity', 'stack', 'dodge', ...),
          or the result of a call to a position adjustment function.
      show_legend : bool, default=True
          False - do not show legend for this layer.
      sampling : `FeatureSpec`
          Result of the call to the `sampling_xxx()` function.
          To prevent any sampling for this layer pass value "none" (string "none").
      tooltips : `layer_tooltips`
          Result of the call to the `layer_tooltips()` function.
          Specify appearance, style and content.
      bins : list of int, default=[30, 30]
          Number of bins in both directions, vertical and horizontal. Overridden by `binwidth`.
      binwidth : list of float
          The width of the bins in both directions, vertical and horizontal.
          Override `bins`. The default is to use bin widths that cover the entire range of the data.
      drop : bool, default=True
          Specify whether to remove all bins with 0 counts.
      color_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='color'
          Define the color aesthetic for the geometry.
      fill_by : {'fill', 'color', 'paint_a', 'paint_b', 'paint_c'}, default='fill'
          Define the fill aesthetic for the geometry.
      other_args
          Other arguments passed on to the layer.
          These are often aesthetics settings used to set an aesthetic to a fixed value,
          like color='red', fill='blue', size=3 or shape=21.
          They may also be parameters to the paired geom/stat.
  
      Returns
      -------
      `LayerSpec`
          Geom object specification.
  
      Notes
      -----
      `geom_bin2d()` applies rectangular grid to the plane then counts observation
      in each cell of the grid (bin). Uses `geom_tile()` to display counts as a tile fill-color.
  
      Computed variables:
  
      - ..count.. : number of points with coordinates in the same bin.
  
      `geom_bin2d()` understands the following aesthetics mappings:
  
      - x : x-axis value.
      - y : y-axis value.
      - alpha : transparency level of a layer. Accept values between 0 and 1.
      - color (colour) : color of the geometry lines. String in the following formats: RGB/RGBA (e.g. "rgb(0, 0, 255)"); HEX (e.g. "#0000FF"); color name (e.g. "red"); role name ("pen", "paper" or "brush").
      - fill : fill color. String in the following formats: RGB/RGBA (e.g. "rgb(0, 0, 255)"); HEX (e.g. "#0000FF"); color name (e.g. "red"); role name ("pen", "paper" or "brush").
      - size : line width, default=0 (i.e. tiles outline initially is not visible).
      - weight : used by 'bin' stat to compute weighted sum instead of simple count.
  
      Examples
      --------
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 8
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          mean = np.zeros(2)
          cov = np.eye(2)
          x, y = np.random.multivariate_normal(mean, cov, 1000).T
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + geom_bin2d()
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 9-14
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          n = 5000
          x = np.random.uniform(-2, 2, size=n)
          y = np.random.normal(scale=.5, size=n)
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_bin2d(aes(fill='..density..'), binwidth=[.25, .24], \\
                         tooltips=layer_tooltips().format('@x', '.2f')
                                 .format('@y', '.2f').line('(@x, @y)')
                                 .line('count|@..count..')
                                 .format('@..density..', '.3f')
                                 .line('density|@..density..')) + \\
              scale_fill_gradient(low='black', high='red')
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 10-11
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          mean = np.zeros(2)
          cov = [[1, .5],
                 [.5, 1]]
          x, y = np.random.multivariate_normal(mean, cov, 500).T
          ggplot({'x': x, 'y': y}, aes(x='x', y='y')) + \\
              geom_bin2d(aes(alpha='..count..'), bins=[20, 20], \\
                         fill='darkgreen') + \\
              geom_point(size=1.5, shape=21, color='white', \\
                         fill='darkgreen') + \\
              ggsize(600, 450)
  
      |
  
      .. jupyter-execute::
          :linenos:
          :emphasize-lines: 7-8
  
          import numpy as np
          from lets_plot import *
          LetsPlot.setup_html()
          np.random.seed(42)
          x, y = np.random.multivariate_normal(mean=[-98, 39], cov=[[100, 0], [0, 10]], size=100).T
          ggplot() + geom_livemap() + \\
              geom_bin2d(aes(x, y, fill='..density..'), \\
                         bins=[10, 5], alpha=.5, show_legend=False)
  
      """
      return _geom(
          "bin2d",
          mapping=mapping,
          data=data,
          stat=stat,
          position=position,
          show_legend=show_legend,
          sampling=sampling,
          tooltips=tooltips,
          bins=bins,
          binwidth=binwidth,
          drop=drop,
          color_by=color_by,
          fill_by=fill_by,
          **other_args,
      )
  
imports: from lets_plot.geo_data_internals.utils import is_geocoder
  from .core import FeatureSpec, LayerSpec
  from .util import as_annotated_data, is_geo_data_frame, geo_data_frame_to_crs, get_geo_data_frame_meta
label_desc: Use image node_id 8 for calling a global function with example usage: geom_bin2d(mapping) and returns: _geom