How to use ipyleaflet - 10 common examples

self._add_unit(name, factor, decimals)

    def add_area_unit(self, name, factor, decimals=0):
        self._area_units.append(name)
        self._add_unit(name, factor, decimals)

    def _add_unit(self, name, factor, decimals):
        self._custom_units_dict[name] = {
            'factor': factor,
            'display': name,
            'decimals': decimals
        }
        self._custom_units = dict(**self._custom_units_dict)


class SplitMapControl(Control):
    _view_name = Unicode('LeafletSplitMapControlView').tag(sync=True)
    _model_name = Unicode('LeafletSplitMapControlModel').tag(sync=True)

    left_layer = Union((Instance(Layer), List(Instance(Layer)))).tag(sync=True, **widget_serialization)
    right_layer = Union((Instance(Layer), List(Instance(Layer)))).tag(sync=True, **widget_serialization)

    @default('left_layer')
    def _default_left_layer(self):
        return TileLayer()

    @default('right_layer')
    def _default_right_layer(self):
        return TileLayer()

    def __init__(self, **kwargs):
        super(SplitMapControl, self).__init__(**kwargs)

self._add_unit(name, factor, decimals)

    def _add_unit(self, name, factor, decimals):
        self._custom_units_dict[name] = {
            'factor': factor,
            'display': name,
            'decimals': decimals
        }
        self._custom_units = dict(**self._custom_units_dict)


class SplitMapControl(Control):
    _view_name = Unicode('LeafletSplitMapControlView').tag(sync=True)
    _model_name = Unicode('LeafletSplitMapControlModel').tag(sync=True)

    left_layer = Union((Instance(Layer), List(Instance(Layer)))).tag(sync=True, **widget_serialization)
    right_layer = Union((Instance(Layer), List(Instance(Layer)))).tag(sync=True, **widget_serialization)

    @default('left_layer')
    def _default_left_layer(self):
        return TileLayer()

    @default('right_layer')
    def _default_right_layer(self):
        return TileLayer()

    def __init__(self, **kwargs):
        super(SplitMapControl, self).__init__(**kwargs)
        self.on_msg(self._handle_leaflet_event)

    def _handle_leaflet_event(self, _, content, buffers):
        if content.get('event', '') == 'dividermove':

lonlat = (o["order"] == "lon_lat")

        for key,value in data.items():
            coords = value[o["coords"]]
            a = coords.split(" ")
            points = []
            i = 0
            while True:
                if lonlat:
                    points.append((a[i + 1],a[i]))
                else:
                    points.append((a[i],a[i + 1]))
                i += 2
                if i >= len(a):
                    break
            polygon = maps.Polygon(locations=points)

            borderWidth = self.getOpt("poly_border_width",1)
            polygon.weight = borderWidth

            if borderWidth > 0:
                polygon.stroke = True
                polygon.color = self.getOpt("poly_border_color","black")
            else:
                polygon.stroke = False

            polygon.fill_color = self.getOpt("poly_fill_color","white")
            polygon.fill_opacity = self.getOpt("poly_fill_opacity",.2)

            if "text" in o:
                text = value[o["text"]]
                polygon.popup = widgets.HTML(value=text)

def __init__(self, geo_json, column_names,  **kwargs):
        # self._control = None
        super(VizMapGeoJSONLeaflet, self).__init__(**kwargs)
        self.map = ipyleaflet.Map(center=[40.72866940630964, -73.80228996276857], zoom=10)
        self.control = VizMapGeoJSONLeaflet.Control(self, column_names)
        self.regions_layer = ipyleaflet.LayerGroup()
        # self.index_mapping = {}
        self.output = widgets.Output()
        for i, feature in enumerate(geo_json["features"]):
            if feature["geometry"]["type"] == "Polygon":
                    feature["geometry"]["type"] = "MultiPolygon"
                    feature["geometry"]["coordinates"] = [feature["geometry"]["coordinates"]]
            polygon = ipyleaflet.GeoJSON(data=feature, hover_style={'fillColor': 'red', 'fillOpacity': 0.6})
            self.regions_layer.add_layer(polygon)
            # self.index_mapping[feature['properties'][index_key]] = i
            @self.output.capture()
            # @vaex.jupyter.debounced(DEBOUNCE_SLICE)
            def on_hover(index=i, **properties):
                # index_value = properties[index_key]
                # index = self.index_mapping[index_value]

def _build_ui(self,
                  product_names,
                  time,
                  zoom=None,
                  center=None,
                  height=None,
                  width=None):
        from ipywidgets import widgets as w
        import ipyleaflet as L

        pp = {'zoom': zoom or 1}

        if center is not None:
            pp['center'] = center

        m = L.Map(**pp,
                  scroll_wheel_zoom=True)
        m.add_control(L.FullScreenControl())

        prod_select = w.Dropdown(options=product_names, layout=w.Layout(
            flex='0 1 auto',
            width='10em',
        ))

        date_txt = w.Text(value=time, layout=w.Layout(
            flex='0 1 auto',
            width='6em',
        ))

        info_lbl = w.Label(value='', layout=w.Layout(
            flex='1 0 auto',
            # border='1px solid white',

html_info = HTML(layout=Layout(flex='1 0 20em',
                                   width='20em',
                                   height='3em'))

    def update_info(txt):
        html_info.value = '<pre style="color:grey">' + txt + '</pre>'

    def render_bounds(bounds):
        (lat1, lon1), (lat2, lon2) = bounds
        txt = 'lat: [{:.{n}f}, {:.{n}f}]\nlon: [{:.{n}f}, {:.{n}f}]'.format(
            lat1, lat2, lon1, lon2, n=4)
        update_info(txt)

    if map is None:
        m = Map(**kwargs) if len(kwargs) else Map(zoom=2)
        m.scroll_wheel_zoom = True
        m.layout.height = height
    else:
        m = map
        render_bounds(m.bounds)

    widgets = [
        WidgetControl(widget=btn_done, position='topright'),
        WidgetControl(widget=html_info, position='bottomleft'),
    ]
    for w in widgets:
        m.add_control(w)

    draw = DrawControl()

    draw.circle = {}

def __init__(self,visuals,datasource,**kwargs):
        Chart.__init__(self,visuals,datasource,**kwargs)

        self._map = maps.Map()
        self._lat = None
        self._lon = None
        self._markers = {}
        self._colorbar = None

        self._colors = None
        self._colorRange = None

        self._circles = []
        self._polygons = []

        self._icon = None

getBounds, getZoom, featurePropertiesOutput
from . import maptool, ipytools
import threading
from copy import copy
import traceback
import sys
import ee

ZOOM_SCALES = {
    0: 156543, 1: 78271, 2: 39135, 3: 19567, 4: 9783, 5: 4891, 6: 2445,
    7: 1222, 8: 611, 9: 305, 10: 152, 11: 76, 12: 38, 13: 19, 14: 9, 15: 5,
    16: 2, 17: 1, 18: 0.5, 19: 0.3, 20: 0.15, 21: 0.07, 22: 0.03,
}


class Map(ipyleaflet.Map):
    tab_children_dict = Dict()
    EELayers = Dict()
    def __init__(self, tabs=('Inspector', 'Layers', 'Assets', 'Tasks'),
                 **kwargs):
        # Change defaults
        kwargs.setdefault('center', [0, 0])
        kwargs.setdefault('zoom', 2)
        kwargs.setdefault('scroll_wheel_zoom', True)
        kwargs.setdefault('max_zoom', 22)
        super(Map, self).__init__(**kwargs)
        self.is_shown = False

        # Width and Height
        self.width = kwargs.get('width', None)
        self.height = kwargs.get('height', None)
        self.setDimensions(self.width, self.height)

from copy import copy
import traceback
from .maptools import *
from .widgets import ErrorAccordion
from .utils import *
import re


ZOOM_SCALES = {
    0: 156543, 1: 78271, 2: 39135, 3: 19567, 4: 9783, 5: 4891, 6: 2445,
    7: 1222, 8: 611, 9: 305, 10: 152, 11: 76, 12: 38, 13: 19, 14: 9, 15: 5,
    16: 2, 17: 1, 18: 0.5, 19: 0.3, 20: 0.15, 21: 0.07, 22: 0.03,
}


class Map(ipyleaflet.Map):
    tab_children_dict = Dict()
    EELayers = Dict()

    def __init__(self, tabs=('Inspector', 'Layers'), **kwargs):
        # Change defaults
        kwargs.setdefault('center', [0, 0])
        kwargs.setdefault('zoom', 2)
        kwargs.setdefault('scroll_wheel_zoom', True)
        kwargs.setdefault('max_zoom', 22)
        super(Map, self).__init__(**kwargs)
        self.is_shown = False

        # Width and Height
        self.width = kwargs.get('width', None)
        self.height = kwargs.get('height', None)
        self.setDimensions(self.width, self.height)

features = j['features']
    if limit is not None:
        features = features[0:limit]

    for f in features:
        location = (f['geometry']['coordinates'][1], f['geometry']['coordinates'][0])
        marker = Marker(location = location)
        marker.popup = HTML(str(f['properties']))
        layer_group.add_layer(marker)
        if not center:
            center = location

    if not center:
        center = (0, 0)

    m = Map(
        layers = (basemap_to_tiles(basemaps.OpenStreetMap.Mapnik), ),
        center = center,
        zoom = 8
    )

    m.add_layer(layer_group)
    return m