Python/지도를 사용할 수 있는 Folium/1. User guide

아래 번역본은 지도 샘플을 포함하고 있지 않으므로 각 주제별 링크를 따라 참조하면 이해가 더 쉽다.

 

https://python-visualization.github.io/folium/latest/user_guide.html

User guide

The user guide covers different parts of basic usage of Folium. Each page focuses on a single topic and outlines how it is implemented in Folium, with reproducible examples.

If you don’t know anything about Folium, start with the Getting started.

Advanced topics can be found in the Advanced Guide and further specification in the API Reference.

사용자 가이드는 Folium의 기본 사용법에 대한 다양한 부분을 다루고 있다. 각 페이지는 단일 주제에 초점을 맞추고 재현 가능한 예를 통해 Folium에서 구현되는 방법을 간략하게 설명한다.

Folium에 대해 아무것도 모른다면 Getting started부터 시작하라.

고급 주제는 Advanced Guide에서 찾을 수 있으며 자세한 사양은 API Reference에서 확인할 수 있다.

Map

https://python-visualization.github.io/folium/latest/user_guide/map.html

Scale

Show a scale on the bottom of the map.

지도 하단에 축척을 표시한다.

folium.Map(
    location=(-38.625, -12.875),
    control_scale=True,
)

Zoom control

The map shows zoom buttons by default, but you can disable them.

지도에는 기본적으로 확대/축소 버튼이 표시되지만 비활성화할 수 있다.

folium.Map(
    location=(-38.625, -12.875),
    zoom_control=False,
)

Limits

You can set limits, so the map won’t scroll outside those limits.

제한을 설정할 수 있으므로 지도가 해당 제한을 벗어나 스크롤되지 않는다.

import folium

min_lon, max_lon = -45, -35
min_lat, max_lat = -25, -15

m = folium.Map(
    max_bounds=True,
    location=[-20, -40],
    zoom_start=6,
    min_lat=min_lat,
    max_lat=max_lat,
    min_lon=min_lon,
    max_lon=max_lon,
)

folium.CircleMarker([max_lat, min_lon], tooltip="Upper Left Corner").add_to(m)
folium.CircleMarker([min_lat, min_lon], tooltip="Lower Left Corner").add_to(m)
folium.CircleMarker([min_lat, max_lon], tooltip="Lower Right Corner").add_to(m)
folium.CircleMarker([max_lat, max_lon], tooltip="Upper Right Corner").add_to(m)

m

UI elements

LayerControl

https://python-visualization.github.io/folium/latest/user_guide/ui_elements/layer_control.html

Add a control to the map to show or hide layers.

레이어를 표시하거나 숨기려면 지도에 컨트롤을 추가한다.

m = folium.Map(tiles=None)

folium.TileLayer("OpenStreetMap").add_to(m)
folium.TileLayer(show=False).add_to(m)

folium.LayerControl().add_to(m)

m

Common layer arguments

Every layer element in Folium has a couple common arguments:

• name: how the layer will be named in the layer control.
• overlay: True if the layer is an overlay, False if the layer is a base layer.
• base layer: only one of them can be active at a time. Mostly used for tile layers.
• overlay: multiple can be active at the same time. Used for anything else than tile layers.
• control: Whether the layer can be controlled in the layer control.
• show: Whether the layer will be shown when opening the map.

Folium의 모든 레이어 요소에는 몇 가지 공통 인수가 있다.

• name: 레이어 컨트롤에서 레이어 이름을 지정하는 방법이다.
• overlay: 레이어가 오버레이이면 True이고, 기본 레이어이면 False이다.
• base layer: 한 번에 하나만 활성화될 수 있다. 주로 타일 레이어에 사용된다.
• overlay: 여러 개가 동시에 활성화될 수 있다. 타일 ​​레이어 이외의 용도로 사용된다.
• control: 레이어 컨트롤에서 레이어를 제어할 수 있는지 여부이다.
• show: 지도를 열 때 레이어를 표시할지 여부이다.

Next we’ll give some examples using a FeatureGroup.

다음으로 FeatureGroup을 사용하는 몇 가지 예를 살펴본다.

Remove from control

m = folium.Map()

fg = folium.FeatureGroup(name="Icon collection", control=False).add_to(m)
folium.Marker(location=(0, 0)).add_to(fg)

folium.LayerControl().add_to(m)

m

Show manually

m = folium.Map()

fg = folium.FeatureGroup(name="Icon collection", show=False).add_to(m)
folium.Marker(location=(0, 0)).add_to(fg)

folium.LayerControl().add_to(m)

m

Popups

https://python-visualization.github.io/folium/latest/user_guide/ui_elements/popups.html

Simple popups

You can define your popup at the feature creation, but you can also overwrite them afterwards:

기능 생성 시 팝업을 정의할 수 있지만 나중에 덮어쓸 수도 있다.

import folium


m = folium.Map([45, 0], zoom_start=4)

folium.Marker([45, -30], popup="inline implicit popup").add_to(m)

folium.CircleMarker(
    location=[45, -10],
    radius=25,
    fill=True,
    popup=folium.Popup("inline explicit Popup"),
).add_to(m)

ls = folium.PolyLine(
    locations=[[43, 7], [43, 13], [47, 13], [47, 7], [43, 7]], color="red"
)

ls.add_child(folium.Popup("outline Popup on Polyline"))
ls.add_to(m)

gj = folium.GeoJson(
    data={"type": "Polygon", "coordinates": [[[27, 43], [33, 43], [33, 47], [27, 47]]]}
)

gj.add_child(folium.Popup("outline Popup on GeoJSON"))
gj.add_to(m)

m

m = folium.Map([45, 0], zoom_start=2)

folium.Marker(
    location=[45, -10],
    popup=folium.Popup("Let's try quotes", parse_html=True, max_width=100),
).add_to(m)

folium.Marker(
    location=[45, -30],
    popup=folium.Popup(u"Ça c'est chouette", parse_html=True, max_width="100%"),
).add_to(m)

m

HTML in popup

import branca

m = folium.Map([43, -100], zoom_start=4)

html = """
    <h1> This is a big popup</h1><br>
    With a few lines of code...
    <p>
    <code>
        from numpy import *<br>
        exp(-2*pi)
    </code>
    </p>
    """

folium.Marker([30, -100], popup=html).add_to(m)

m

Iframe in popup

You can also put any HTML code inside a Popup, thaks to the IFrame object.

IFrame 개체 덕분에 팝업 안에 HTML 코드를 넣을 수도 있다.

m = folium.Map([43, -100], zoom_start=4)

html = """
    <h1> This popup is an Iframe</h1><br>
    With a few lines of code...
    <p>
    <code>
        from numpy import *<br>
        exp(-2*pi)
    </code>
    </p>
    """

iframe = branca.element.IFrame(html=html, width=500, height=300)
popup = folium.Popup(iframe, max_width=500)

folium.Marker([30, -100], popup=popup).add_to(m)

m

import pandas as pd

df = pd.DataFrame(
    data=[["apple", "oranges"], ["other", "stuff"]], columns=["cats", "dogs"]
)

m = folium.Map([43, -100], zoom_start=4)

html = df.to_html(
    classes="table table-striped table-hover table-condensed table-responsive"
)

popup = folium.Popup(html)

folium.Marker([30, -100], popup=popup).add_to(m)

m

Note that you can put another Figure into an IFrame ; this should let you do strange things…

IFrame에 다른 Figure를 넣을 수 있다. 이렇게 하면 이상한 일을 할 수 있을 것이다…

# Let's create a Figure, with a map inside.
f = branca.element.Figure()
folium.Map([-25, 150], zoom_start=3).add_to(f)

# Let's put the figure into an IFrame.
iframe = branca.element.IFrame(width=500, height=300)
f.add_to(iframe)

# Let's put the IFrame in a Popup
popup = folium.Popup(iframe, max_width=2650)

# Let's create another map.
m = folium.Map([43, -100], zoom_start=4)

# Let's put the Popup on a marker, in the second map.
folium.Marker([30, -100], popup=popup).add_to(m)

# We get a map in a Popup. Not really useful, but powerful.
m

Vega chart in popup

Vega is a way to describe charts. You can embed a Vega chart in a popup using the Vega class.

Vega는 차트를 설명하는 방법이다. Vega 클래스를 사용하여 팝업에 Vega 차트를 포함할 수 있다.

import json

import numpy as np
import vincent

multi_iter2 = {
    "x": np.random.uniform(size=(100,)),
    "y": np.random.uniform(size=(100,)),
}
scatter = vincent.Scatter(multi_iter2, iter_idx="x", height=100, width=200)
data = json.loads(scatter.to_json())

m = folium.Map([0, 0], zoom_start=1)
marker = folium.Marker([0, 0]).add_to(m)
popup = folium.Popup("Hello").add_to(marker)
folium.Vega(data, width="100%", height="100%").add_to(popup)

m

Vega-Lite chart in popup

Vega-lite is a higher-level version of Vega. Folium supports it as well in the VegaLite class.

Vega-lite는 Vega의 상위 버전이다. Folium은 VegaLite 클래스에서도 이를 지원한다.

from altair import Chart

import vega_datasets

# load built-in dataset as a pandas DataFrame
cars = vega_datasets.data.cars()

scatter = (
    Chart(cars)
    .mark_circle()
    .encode(
        x="Horsepower",
        y="Miles_per_Gallon",
        color="Origin",
    )
)

vega_lite = folium.VegaLite(
    scatter,
    width="100%",
    height="100%",
)

m = folium.Map(location=[-27.5717, -48.6256])

marker = folium.Marker([-27.57, -48.62])

popup = folium.Popup()

vega_lite.add_to(popup)
popup.add_to(marker)

marker.add_to(m)

m

Lazy loading

If whatever you are showing in the popup is slow or heavy to load and you have many popups, you may not want to render the popup contents immediately. There’s an argument to prevent loading until the popup is opened.

팝업에 표시되는 항목이 느리거나 로드하기에 무거워서 팝업이 많은 경우 팝업 콘텐츠를 즉시 렌더링하고 싶지 않을 수 있다. 팝업이 열릴 때까지 로딩을 방지하는 인수가 있다.

m = folium.Map([43, -100], zoom_start=4)

html = "{a resource that is heavy to load, such as an image}"

folium.Marker([30, -100], popup=html, lazy=True).add_to(m)

m

Icons

https://python-visualization.github.io/folium/latest/user_guide/ui_elements/icons.html

Rotate icons

m = folium.Map(location=[41, -71], zoom_start=4)

kw = {"prefix": "fa", "color": "green", "icon": "arrow-up"}

angle = 180
icon = folium.Icon(angle=angle, **kw)
folium.Marker(location=[41, -72], icon=icon, tooltip=str(angle)).add_to(m)

angle = 45
icon = folium.Icon(angle=angle, **kw)
folium.Marker(location=[41, -75], icon=icon, tooltip=str(angle)).add_to(m)

angle = 90
icon = folium.Icon(angle=angle, **kw)
folium.Marker([41, -78], icon=icon, tooltip=str(angle)).add_to(m)

m

Custom icon

m = folium.Map(location=[45.3288, -121.6625], zoom_start=12)

url = "https://leafletjs.com/examples/custom-icons/{}".format
icon_image = url("leaf-red.png")
shadow_image = url("leaf-shadow.png")

icon = folium.CustomIcon(
    icon_image,
    icon_size=(38, 95),
    icon_anchor=(22, 94),
    shadow_image=shadow_image,
    shadow_size=(50, 64),
    shadow_anchor=(4, 62),
    popup_anchor=(-3, -76),
)

folium.Marker(
    location=[45.3288, -121.6625], icon=icon, popup="Mt. Hood Meadows"
).add_to(m)

m

Raster layers

Tiles

https://python-visualization.github.io/folium/latest/user_guide/raster_layers/tiles.html

Built-in tilesets

import folium


lon, lat = -38.625, -12.875

zoom_start = 8
folium.Map(location=[lat, lon], tiles="OpenStreetMap", zoom_start=zoom_start)

folium.Map(location=[lat, lon], tiles="Cartodb Positron", zoom_start=zoom_start)

folium.Map(location=[lat, lon], tiles="Cartodb dark_matter", zoom_start=zoom_start)

Custom tiles

attr = (
    '© OpenStreetMap '
    'contributors, © CartoDB'
)
tiles = "https://{s}.basemaps.cartocdn.com/light_nolabels/{z}/{x}/{y}.png"

folium.Map(location=[lat, lon], tiles=tiles, attr=attr, zoom_start=zoom_start)

Other tilesets

For a list of many more tile providers go to https://leaflet-extras.github.io/leaflet-providers/preview/.

You can also use the xyzservices package: geopandas/xyzservices.

더 많은 타일 공급자 목록을 보려면 https://leaflet-extras.github.io/leaflet-providers/preview/ 로 이동하라.

xyzservices 패키지(geopandas/xyzservices)를 사용할 수도 있다.

ImageOverlay

https://python-visualization.github.io/folium/latest/user_guide/raster_layers/image_overlay.html

It may happen that you want to draw an image on you map. Here are example on how to do that.

지도에 이미지를 그리고 싶은 경우가 발생할 수 있다. 이를 수행하는 방법에 대한 예는 다음과 같다.

Using an image from disk

If you have a static image file on your disk, you can simply draw it on the map.

디스크에 정적 이미지 파일이 있는 경우 지도에 간단히 그릴 수 있다.

import os
import folium

m = folium.Map([37, 0], zoom_start=1)
merc = os.path.join("data", "Mercator_projection_SW.png")


if not os.path.isfile(merc):
    print(f"Could not find {merc}")
else:
    img = folium.raster_layers.ImageOverlay(
        name="Mercator projection SW",
        image=merc,
        bounds=[[-82, -180], [82, 180]],
        opacity=0.6,
        interactive=True,
        cross_origin=False,
        zindex=1,
    )

    folium.Popup("I am an image").add_to(img)

    img.add_to(m)
    folium.LayerControl().add_to(m)

m

A few remarks:

Note that your image has to be in Mercator projection format.

The image we’ve used is based on https://en.wikipedia.org/wiki/File:Mercator_projection_SW.jpg ; that you can find in wikipedia’s article on Mercator Projection (https://en.wikipedia.org/wiki/Mercator_projection).

몇 가지 참고사항:

이미지는 메르카토르 투영 형식이어야 한다.

우리가 사용한 이미지는 https://en.wikipedia.org/wiki/File:Mercator_projection_SW.jpg 를 기반으로 한다. 메르카토르 투영에 관한 위키피디아 기사(https://en.wikipedia.org/wiki/Mercator_projection)에서 찾을 수 있다.

You can also provide simply URL. In this case, the image will not be embedded in folium’s output.

간단히 URL을 제공할 수도 있다. 이 경우 이미지는 Folium의 출력에 포함되지 않는다.

m = folium.Map([37, 0], zoom_start=1)

folium.raster_layers.ImageOverlay(
    image="https://upload.wikimedia.org/wikipedia/commons/f/f4/Mercator_projection_SW.jpg",
    name="I am a jpeg",
    bounds=[[-82, -180], [82, 180]],
    opacity=1,
    interactive=False,
    cross_origin=False,
    zindex=1,
    alt="Wikipedia File:Mercator projection SW.jpg",
).add_to(m)

folium.LayerControl().add_to(m)

m

This works exactly the same way if you want to put a JPG instead of a PNG.

PNG 대신 JPG를 넣으려는 경우에도 이는 정확히 동일한 방식으로 작동한다.

Creating an image with numpy

Now you may wish to create your own image, based on another python computation. For this, you’ll need to have numpy installed on your machine.

Let’s create an image to draw a rectangle in the bounds [[0, -60], [60, 60]].

이제 다른 Python 계산을 기반으로 자신만의 이미지를 생성할 수 있다. 이를 위해서는 컴퓨터에 numpy가 설치되어 있어야 한다.

[[0, -60], [60, 60]] 범위에 직사각형을 그리는 이미지를 만들어 본다.

import numpy as np

image = np.zeros((61, 61))
image[0, :] = 1.0
image[60, :] = 1.0
image[:, 0] = 1.0
image[:, 60] = 1.0

We can draw it on the map in using:

다음을 사용하여 지도에 그릴 수 있다.

m = folium.Map([37, 0], zoom_start=2)

folium.raster_layers.ImageOverlay(
    image=image,
    bounds=[[0, -60], [60, 60]],
    colormap=lambda x: (1, 0, 0, x),
).add_to(m)

m

Note that you need to provide a colormap of the form lambda x: (R,G,B,A) where R,G,B,A are floats between 0 and 1.

Now, let’s try to add a line at latitude 45°, and add a polyline to verify it’s well rendered. We’ll need to specify origin='lower to inform folium that the first lines of the array are to be plotted at the bottom of the image (see numpy.imshow, it’s the same principle).

lambda x: (R,G,B,A) 형식의 컬러맵을 제공해야 한다. 여기서 R,G,B,A는 0과 1 사이의 부동 소수점이다.

이제 위도 45°에 선을 추가하고 폴리선을 추가하여 잘 렌더링되었는지 확인해 본다. 배열의 첫 번째 라인이 이미지 하단에 표시된다는 것을 folium에 알리기 위해 Origin='lower를 지정해야 한다(numpy.imshow를 참조하라. 동일한 원리이다).

import numpy as np

image = np.zeros((61, 1))

image[45, :] = 1.0


m = folium.Map([37, 0], zoom_start=3)

folium.raster_layers.ImageOverlay(
    image=image,
    bounds=[[0, -60], [60, 60]],
    colormap=lambda x: (1, 0, 0, x),
    origin="lower",
).add_to(m)

folium.PolyLine([[45, -60], [45, 60]]).add_to(m)

m

But even with origin='lower', the red line is not at the good latitude. This is due to Mercator projection used in Leaflet (and most other map systems).

You can read wikipedia’s article on Mercator Projection (https://en.wikipedia.org/wiki/Mercator_projection), or simply let folium do the job, in precising that you want the mercator stuff to be handled.

그러나 origin='lower'인 경우에도 빨간색 선은 좋은 위도에 있지 않다. 이는 Leaflet(및 대부분의 다른 지도 시스템)에서 사용되는 Mercator 투영 때문이다.

Mercator Projection에 대한 Wikipedia의 기사(https://en.wikipedia.org/wiki/Mercator_projection)를 읽거나 단순히 Folium이 작업을 수행하도록 하여 메르카토르 항목을 처리하도록 할 수 있다.

m = folium.Map([37, 0], zoom_start=3)

folium.PolyLine([[45, -60], [45, 60]]).add_to(m)

folium.raster_layers.ImageOverlay(
    image=image,
    bounds=[[0, -60], [60, 60]],
    origin="lower",
    colormap=lambda x: (1, 0, 0, x),
    mercator_project=True,
).add_to(m)

m

This time, the lines are properly positioned (at the precision of the array).

이번에는 선이 (배열의 정밀도로) 올바르게 배치되었다.

VideoOverlay

https://python-visualization.github.io/folium/latest/user_guide/raster_layers/video_overlay.html

import folium

m = folium.Map(location=[22.5, -115], zoom_start=4)

video = folium.raster_layers.VideoOverlay(
    video_url="https://www.mapbox.com/bites/00188/patricia_nasa.webm",
    bounds=[[32, -130], [13, -100]],
    opacity=0.65,
    attr="Video from patricia_nasa",
    autoplay=True,
    loop=False,
)

video.add_to(m)

m

WmsTileLayer

https://python-visualization.github.io/folium/latest/user_guide/raster_layers/wms_tile_layer.html

m = folium.Map(location=[41, -70], zoom_start=5, tiles="cartodb positron")

folium.WmsTileLayer(
    url="https://mesonet.agron.iastate.edu/cgi-bin/wms/nexrad/n0r.cgi",
    name="test",
    fmt="image/png",
    layers="nexrad-n0r-900913",
    attr=u"Weather data © 2012 IEM Nexrad",
    transparent=True,
    overlay=True,
    control=True,
).add_to(m)

folium.LayerControl().add_to(m)

m

Vector layers

https://python-visualization.github.io/folium/latest/user_guide/vector_layers/circle_and_circle_marker.html

Circle and CircleMarker

CircleMarker has a radius specified in pixels, while Circle is specified in meters. That means a CircleMarker will not change size on your screen when you zoom, while Circle will have a fixed position on the map.

CircleMarker의 반경은 픽셀 단위로 지정되고 Circle은 미터 단위로 지정된다. 즉, CircleMarker는 확대/축소할 때 화면의 크기가 변경되지 않지만 Circle은 지도에서 고정된 위치를 갖는다.

import folium

m = folium.Map(location=[-27.5717, -48.6256], zoom_start=9)

radius = 50
folium.CircleMarker(
    location=[-27.55, -48.8],
    radius=radius,
    color="cornflowerblue",
    stroke=False,
    fill=True,
    fill_opacity=0.6,
    opacity=1,
    popup="{} pixels".format(radius),
    tooltip="I am in pixels",
).add_to(m)

radius = 25
folium.CircleMarker(
    location=[-27.35, -48.8],
    radius=radius,
    color="black",
    weight=3,
    fill=False,
    fill_opacity=0.6,
    opacity=1,
).add_to(m)

radius = 10000
folium.Circle(
    location=[-27.551667, -48.478889],
    radius=radius,
    color="black",
    weight=1,
    fill_opacity=0.6,
    opacity=1,
    fill_color="green",
    fill=False,  # gets overridden by fill_color
    popup="{} meters".format(radius),
    tooltip="I am in meters",
).add_to(m)

m

PolyLine

https://python-visualization.github.io/folium/latest/user_guide/vector_layers/polyline.html

# Coordinates are 15 points on the great circle from Boston to San Francisco.
coordinates = [
    [42.3581, -71.0636],
    [42.82995815, -74.78991444],
    [43.17929819, -78.56603306],
    [43.40320216, -82.37774519],
    [43.49975489, -86.20965845],
    [43.46811941, -90.04569087],
    [43.30857071, -93.86961818],
    [43.02248456, -97.66563267],
    [42.61228259, -101.41886832],
    [42.08133868, -105.11585198],
    [41.4338549, -108.74485069],
    [40.67471747, -112.29609954],
    [39.8093434, -115.76190821],
    [38.84352776, -119.13665678],
    [37.7833, -122.4167],
]

# Create the map and add the line
m = folium.Map(location=[41.9, -97.3], zoom_start=4)

folium.PolyLine(
    locations=coordinates,
    color="#FF0000",
    weight=5,
    tooltip="From Boston to San Francisco",
).add_to(m)

m

Smoothing

PolyLine objects in Leaflet are smoothed by default. This removes points from the line, putting less load on the browser when drawing. The level of smoothing can be set with the smooth_factor argument.

Leaflet의 PolyLine 개체는 기본적으로 다듬어진다. 이렇게 하면 선에서 점이 제거되어 그릴 때 브라우저에 걸리는 부하가 줄어든다. 평활화 수준은 smooth_factor 인수로 설정할 수 있다.

m = folium.Map(location=[41.9, -97.3], zoom_start=4)

folium.PolyLine(
    smooth_factor=50,
    locations=coordinates,
    color="grey",
    tooltip="Too much smoothing?",
    weight=5,
).add_to(m)

m

Crossing the date line

Take notice how lines behave when they cross the date line.

날짜 표시선을 지날 때 선이 어떻게 움직이는지 살펴보라.

lon = lat = 0
zoom_start = 1

m = folium.Map(location=[lat, lon], zoom_start=zoom_start)

kw = {"opacity": 1.0, "weight": 6}
folium.PolyLine(
    locations=[(2, 179), (2, -179)],
    tooltip="Wrong",
    color="red",
    line_cap="round",
    **kw,
).add_to(m)

folium.PolyLine(
    locations=[(-2, 179), (-2, 181)],
    tooltip="Correct",
    line_cap="butt",
    color="blue",
    **kw,
).add_to(m)

folium.PolyLine(
    locations=[(-6, -179), (-6, 179)],
    line_cap="square",
    color="green",
    tooltip="Correct",
    **kw,
).add_to(m)

folium.PolyLine(
    locations=[(12, -179), (12, 190)],
    color="orange",
    tooltip="Artifact?",
    **kw,
).add_to(m)

m

Multi-PolyLine

You can create multiple polylines by passing multiple sets of coordinates to a single PolyLine object.

여러 좌표 집합을 단일 PolyLine 개체에 전달하여 여러 폴리라인을 만들 수 있다.

lat = +38.89399
lon = -77.03659
zoom_start = 17

m = folium.Map(location=[lat, lon], zoom_start=zoom_start)

kw = {"color": "red", "fill": True, "radius": 20}

folium.CircleMarker([38.89415, -77.03738], **kw).add_to(m)
folium.CircleMarker([38.89415, -77.03578], **kw).add_to(m)

locations = [
    [
        (38.893596444352134, -77.03814983367920),
        (38.893379333722040, -77.03792452812195),
    ],
    [
        (38.893379333722040, -77.03792452812195),
        (38.893162222428310, -77.03761339187622),
    ],
    [
        (38.893162222428310, -77.03761339187622),
        (38.893028615148424, -77.03731298446655),
    ],
    [
        (38.893028615148424, -77.03731298446655),
        (38.892920059048464, -77.03691601753235),
    ],
    [
        (38.892920059048464, -77.03691601753235),
        (38.892903358095296, -77.03637957572937),
    ],
    [
        (38.892903358095296, -77.03637957572937),
        (38.893011914220770, -77.03592896461487),
    ],
    [
        (38.893011914220770, -77.03592896461487),
        (38.893162222428310, -77.03549981117249),
    ],
    [
        (38.893162222428310, -77.03549981117249),
        (38.893404384982480, -77.03514575958252),
    ],
    [
        (38.893404384982480, -77.03514575958252),
        (38.893596444352134, -77.03496336936950),
    ],
]

folium.PolyLine(
    locations=locations,
    color="orange",
    weight=8,
    opacity=1,
    smooth_factor=0,
).add_to(m)

m

Rectangle

https://python-visualization.github.io/folium/latest/user_guide/vector_layers/rectangle.html

m = folium.Map(location=[35.685, 139.76], zoom_start=15)

kw = {
    "color": "blue",
    "line_cap": "round",
    "fill": True,
    "fill_color": "red",
    "weight": 5,
    "popup": "Tokyo, Japan",
    "tooltip": "Click me!",
}

folium.Rectangle(
    bounds=[[35.681, 139.766], [35.691, 139.776]],
    line_join="round",
    dash_array="5, 5",
    **kw,
).add_to(m)

dx = 0.012
folium.Rectangle(
    bounds=[[35.681, 139.766 - dx], [35.691, 139.776 - dx]],
    line_join="mitter",
    dash_array="5, 10",
    **kw,
).add_to(m)

folium.Rectangle(
    bounds=[[35.681, 139.766 - 2 * dx], [35.691, 139.7762 - 2 * dx]],
    line_join="bevel",
    dash_array="15, 10, 5, 10, 15",
    **kw,
).add_to(m)

m

Polygon

https://python-visualization.github.io/folium/latest/user_guide/vector_layers/polygon.html

m = folium.Map(location=[35.67, 139.78], zoom_start=13)

locations = [
    [35.6762, 139.7795],
    [35.6718, 139.7831],
    [35.6767, 139.7868],
    [35.6795, 139.7824],
    [35.6787, 139.7791],
]

folium.Polygon(
    locations=locations,
    color="blue",
    weight=6,
    fill_color="red",
    fill_opacity=0.5,
    fill=True,
    popup="Tokyo, Japan",
    tooltip="Click me!",
).add_to(m)

m

locations = [
    [
        [7.577794326946673, 8.998503901433935],
        [7.577851434795945, 8.998572430673164],
        [7.577988491475764, 8.998652380403087],
        [7.578105560723088, 8.998426807051544],
        [7.577891409660878, 8.998289750371725],
        [7.577794326946673, 8.998503901433935],
    ],
    [
        [7.578139824893071, 8.999291979141560],
        [7.578359687549607, 8.999414759083890],
        [7.578456769364435, 8.999266281014116],
        [7.578471046101925, 8.999197181604700],
        [7.578247331649095, 8.999094883721964],
        [7.578139824893071, 8.99929197914156],
    ],
    [
        [7.577851730672876, 8.997811268775080],
        [7.578012579816743, 8.997460464828633],
        [7.577798113991832, 8.997311104523930],
        [7.577667902951418, 8.997663440915119],
        [7.577851730672876, 8.997811268775080],
    ],
    [
        [7.578562417221803, 8.999551816663029],
        [7.578688052511666, 8.999654609172921],
        [7.578813688700849, 8.999443313458185],
        [7.578670920426703, 8.999369073523950],
        [7.578562417221803, 8.999551816663029],
    ],
    [
        [7.577865711533433, 8.998252059784761],
        [7.577989601239152, 8.998002756022402],
        [7.577648754586391, 8.997784460884190],
        [7.577545911714481, 8.998069316645683],
        [7.577865711533433, 8.998252059784761],
    ],
]

m = folium.Map(location=[7.577798113991832, 8.997311104523930], zoom_start=16)

folium.Polygon(
    locations=locations,
    smooth_factor=2,
    color="crimson",
    no_clip=True,
    tooltip="Hi there!",
).add_to(m)

m

ColorLine

https://python-visualization.github.io/folium/latest/user_guide/vector_layers/colorline.html

import numpy as np

x = np.linspace(0, 2 * np.pi, 300)

lats = 20 * np.cos(x)
lons = 20 * np.sin(x)
colors = np.sin(5 * x)

import folium

m = folium.Map([0, 0], zoom_start=3)

color_line = folium.ColorLine(
    positions=list(zip(lats, lons)),
    colors=colors,
    colormap=["y", "orange", "r"],
    weight=10,
).add_to(m)

m

GeoJSON and choropleth

Using GeoJson

https://python-visualization.github.io/folium/latest/user_guide/geojson/geojson.html

Loading data

Let us load a GeoJSON file representing the US states.

미국 주를 나타내는 GeoJSON 파일을 로드해 본다.

import requests

geo_json_data = requests.get(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_states.json"
).json()

It is a classical GeoJSON FeatureCollection (see https://en.wikipedia.org/wiki/GeoJSON) of the form :

이는 다음 형식의 고전적인 GeoJSON FeatureCollection(https://en.wikipedia.org/wiki/GeoJSON 참조)이다.

{
    "type": "FeatureCollection",
    "features": [
        {
            "properties": {"name": "Alabama"},
            "id": "AL",
            "type": "Feature",
            "geometry": {
                "type": "Polygon",
                "coordinates": [[[-87.359296, 35.00118], ...]]
                }
            },
        {
            "properties": {"name": "Alaska"},
            "id": "AK",
            "type": "Feature",
            "geometry": {
                "type": "MultiPolygon",
                "coordinates": [[[[-131.602021, 55.117982], ... ]]]
                }
            },
        ...
        ]
    }

A first way of drawing it on a map, is simply to use folium.GeoJson :

지도에 지도를 그리는 첫 번째 방법은 간단히 folium.GeoJson을 사용하는 것이다.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(geo_json_data).add_to(m)

m

Note that you can avoid loading the file on yourself, by providing a (local) file path or a url.

(로컬) 파일 경로나 URL을 제공하면 파일을 직접 로드하지 않아도 된다.

m = folium.Map([43, -100], zoom_start=4)

url = "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_states.json"

folium.GeoJson(url).add_to(m)

m

You can pass a geopandas object.

geopandas 객체를 전달할 수 있다.

import geopandas

gdf = geopandas.read_file(url)

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    gdf,
).add_to(m)

m

Click on zoom

You can enable an option that if you click on a part of the geometry the map will zoom in to that.

Try it on the map below:

지오메트리의 일부를 클릭하면 지도가 해당 부분을 확대하는 옵션을 활성화할 수 있다.

아래 지도에서 시도해 보라.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(geo_json_data, zoom_on_click=True).add_to(m)

m

Styling

Now this is cool and simple, but we may be willing to choose the style of the data.

You can provide a function of the form lambda feature: {} that sets the style of each feature.

For possible options, see:

• For Point and MultiPoint, see https://leafletjs.com/reference.html#marker
• For other features, see https://leafletjs.com/reference.html#path and https://leafletjs.com/reference.html#polyline

이것은 멋지고 간단하지만 데이터 스타일을 기꺼이 선택할 수도 있다.

각 기능의 스타일을 설정하는 람다 기능인 {} 형식의 함수를 제공할 수 있다.

가능한 옵션은 다음을 참조하라.

• Point 및 MultiPoint의 경우 https://leafletjs.com/reference.html#marker 를 참조하라.
• 다른 기능은 https://leafletjs.com/reference.html#path 및 https://leafletjs.com/reference.html#polyline 을 참조하라.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    geo_json_data,
    style_function=lambda feature: {
        "fillColor": "#ffff00",
        "color": "black",
        "weight": 2,
        "dashArray": "5, 5",
    },
).add_to(m)

m

What’s cool in providing a function, is that you can specify a style depending on the feature. For example, if you want to visualize in green all states whose name contains the letter ‘E’, just do:

기능을 제공할 때 좋은 점은 기능에 따라 스타일을 지정할 수 있다는 점이다. 예를 들어 이름에 문자 'E'가 포함된 모든 주를 녹색으로 시각화하려면 다음을 수행하라.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    geo_json_data,
    style_function=lambda feature: {
        "fillColor": "green"
        if "e" in feature["properties"]["name"].lower()
        else "#ffff00",
        "color": "black",
        "weight": 2,
        "dashArray": "5, 5",
    },
).add_to(m)

m

Wow, this looks almost like a choropleth. To do one, we just need to compute a color for each state.

Let’s imagine we want to draw a choropleth of unemployment in the US.

First, we may load the data:

와, 이건 거의 등치처럼 보인다. 이를 위해서는 각 상태에 대한 색상을 계산하면 된다.

미국에서 실업률이 엄청나게 높다고 가정해 본다.

먼저 데이터를 로드할 수 있다.

import pandas

unemployment = pandas.read_csv(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_unemployment_oct_2012.csv"
)

unemployment.head(5)
State	Unemployment
0	AL	7.1
1	AK	6.8
2	AZ	8.1
3	AR	7.2
4	CA	10.1

Now we need to create a function that maps one value to a RGB color (of the form #RRGGBB). For this, we’ll use colormap tools from folium.colormap.

이제 하나의 값을 RGB 색상(#RRGGBB 형식)에 매핑하는 함수를 만들어야 한다. 이를 위해 folium.colormap의 색상맵 도구를 사용한다.

from branca.colormap import linear

colormap = linear.YlGn_09.scale(
    unemployment.Unemployment.min(), unemployment.Unemployment.max()
)

print(colormap(5.0))

colormap
#d8f0a3ff
3.2
4.4
5.6
6.8
7.9
9.1
10.3

We need also to convert the table into a dictionary, in order to map a feature to it’s unemployment value.

또한 실업률 값에 특성을 매핑하려면 테이블을 사전으로 변환해야 한다.

unemployment_dict = unemployment.set_index("State")["Unemployment"]

unemployment_dict["AL"]
7.1

Now we can do the choropleth.

이제 등치도(choropleth)를 수행할 수 있다.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    geo_json_data,
    name="unemployment",
    style_function=lambda feature: {
        "fillColor": colormap(unemployment_dict[feature["id"]]),
        "color": "black",
        "weight": 1,
        "dashArray": "5, 5",
        "fillOpacity": 0.9,
    },
).add_to(m)

folium.LayerControl().add_to(m)

m

Of course, if you can create and/or use a dictionary providing directly the good color. Thus, the finishing seems faster:

물론, 좋은 색상을 직접 제공하는 dictionary를 생성 및/또는 사용할 수 있다면 말이다. 따라서 마무리가 더 빨라 보인다.

color_dict = {key: colormap(unemployment_dict[key]) for key in unemployment_dict.keys()}

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    geo_json_data,
    style_function=lambda feature: {
        "fillColor": color_dict[feature["id"]],
        "color": "black",
        "weight": 1,
        "dashArray": "5, 5",
        "fillOpacity": 0.9,
    },
).add_to(m)

Note that adding a color legend may be a good idea.

색상 범례를 추가하는 것이 좋다.

colormap.caption = "Unemployment color scale"
colormap.add_to(m)

m

Caveat

When using style_function in a loop you may encounter Python’s ‘Late Binding Closure’ gotcha! See https://docs.python-guide.org/writing/gotchas/#late-binding-closures for more info. There are a few ways around it from using a GeoPandas object instead, to “hacking” your style_function to force early closure, like:

루프에서 style_function을 사용할 때 Python의 'Late Binding Closure' 문제가 발생할 수 있다! 자세한 내용은 https://docs.python-guide.org/writing/gotchas/#late-bind-closures 를 참조하라. 대신 GeoPandas 객체를 사용하는 것부터 style_function을 "해킹"하여 조기 종료를 강제하는 방법까지 몇 가지 방법이 있다.

for geom, my_style in zip(geoms, my_styles):
    style = my_style
    style_function = lambda x, style=style: style
    folium.GeoJson(
        data=geom,
        style_function=style_function,
    ).add_to(m)

Highlight function

The GeoJson class provides a highlight_function argument, which works similarly to style_function, but applies on mouse events. In the following example the fill color will change when you hover your mouse over a feature.

GeoJson 클래스는 style_function과 유사하게 작동하지만 마우스 이벤트에 적용되는 하이라이트_함수 인수를 제공한다. 다음 예에서는 지형지물 위로 마우스를 가져가면 채우기 색상이 변경된다.

m = folium.Map([43, -100], zoom_start=4)

folium.GeoJson(
    geo_json_data,
    highlight_function=lambda feature: {
        "fillColor": (
            "green" if "e" in feature["properties"]["name"].lower() else "#ffff00"
        ),
    },
).add_to(m)

m

Keep highlighted while popup is open

The GeoJson class provides a popup_keep_highlighted boolean argument. Whenever a GeoJson layer is associated with a popup and a highlight function is defined, this argument allows you to decide if the highlighting should remain active while the popup is open.

GeoJson 클래스는 popup_keep_highlighted 부울 인수를 제공한다. GeoJson 레이어가 팝업과 연결되고 강조 기능이 정의될 때마다 이 인수를 사용하면 팝업이 열려 있는 동안 강조 표시를 활성 상태로 유지할지 결정할 수 있다.

m = folium.Map([43, -100], zoom_start=4)

popup = folium.GeoJsonPopup(fields=["name"])

folium.GeoJson(
    geo_json_data,
    highlight_function=lambda feature: {
        "fillColor": (
            "green" if "e" in feature["properties"]["name"].lower() else "#ffff00"
        ),
    },
    popup=popup,
    popup_keep_highlighted=True,
).add_to(m)

m

Using Choropleth

https://python-visualization.github.io/folium/latest/user_guide/geojson/choropleth.html

Now if you want to get faster, you can use the Choropleth class. Have a look at it’s docstring, it has several styling options.

Just like the GeoJson class you can provide it a filename, a dict, or a geopandas object.

이제 속도를 높이고 싶다면 Choropleth 클래스를 사용할 수 있다. 독스트링을 살펴보라. 여러 가지 스타일 옵션이 있다.

GeoJson 클래스와 마찬가지로 파일 이름, 사전 또는 geopandas 객체를 제공할 수 있다.

import requests

m = folium.Map([43, -100], zoom_start=4)

us_states = requests.get(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_states.json"
).json()

folium.Choropleth(
    geo_data=us_states,
    fill_opacity=0.3,
    line_weight=2,
).add_to(m)

m

Then, in playing with keyword arguments, you can get a choropleth in a few lines:

그런 다음 키워드 인수를 사용하여 몇 줄로 등치(choropleth)를 얻을 수 있다.

import pandas

state_data = pandas.read_csv(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_unemployment_oct_2012.csv"
)

m = folium.Map([43, -100], zoom_start=4)

folium.Choropleth(
    geo_data=us_states,
    data=state_data,
    columns=["State", "Unemployment"],
    key_on="feature.id",
).add_to(m)

m

You can force the color scale to a given number of bins (or directly list the bins you would like), by providing the bins argument.

bins 인수를 제공하여 색상 스케일을 주어진 수의 bin으로 강제할 수 있다(또는 원하는 bin을 직접 나열).

m = folium.Map([43, -100], zoom_start=4)

folium.Choropleth(
    geo_data=us_states,
    data=state_data,
    columns=["State", "Unemployment"],
    key_on="feature.id",
    fill_color="YlGn",
    bins=[3, 4, 9, 11],
).add_to(m)

m

You can also enable the highlight function, to enable highlight functionality when you hover over each area.

하이라이트 기능을 활성화하여 각 영역 위로 마우스를 가져갈 때 하이라이트 기능을 활성화할 수도 있다.

m = folium.Map(location=[48, -102], zoom_start=3)
folium.Choropleth(
    geo_data=us_states,
    data=state_data,
    columns=["State", "Unemployment"],
    key_on="feature.id",
    fill_color="YlGn",
    fill_opacity=0.7,
    line_opacity=0.2,
    legend_name="Unemployment Rate (%)",
    highlight=True,
).add_to(m)

m

You can customize the way missing and nan values are displayed on your map using the two parameters nan_fill_color and nan_fill_opacity.

두 매개변수 nan_fill_color 및 nan_fill_opacity를 사용하여 누락된 값과 nan 값이 지도에 표시되는 방식을 사용자 정의할 수 있다.

m = folium.Map([43, -100], zoom_start=4)

messed_up_data = state_data.drop(0)
messed_up_data.loc[4, "Unemployment"] = float("nan")

folium.Choropleth(
    geo_data=us_states,
    data=messed_up_data,
    columns=["State", "Unemployment"],
    nan_fill_color="purple",
    nan_fill_opacity=0.4,
    key_on="feature.id",
    fill_color="YlGn",
).add_to(m)

m

Internally Choropleth uses the GeoJson or TopoJson class, depending on your settings, and the StepColormap class. Both objects are attributes of your Choropleth object called geojson and color_scale. You can make changes to them, but for regular things you won’t have to. For example setting a name for in the layer controls or disabling showing the layer on opening the map is possible in Choropleth itself.

내부적으로 Choropleth는 설정에 따라 GeoJson 또는 TopoJson 클래스와 StepColormap 클래스를 사용한다. 두 객체 모두 geojson 및 color_scale이라는 Choropleth 객체의 속성이다. 이를 변경할 수 있지만 일반적인 사항의 경우에는 변경할 필요가 없다. 예를 들어 레이어 컨트롤에 이름을 설정하거나 지도를 열 때 레이어 표시를 비활성화하는 것은 등치 자체에서 가능하다.

m = folium.Map([43, -100], zoom_start=4)

choropleth = folium.Choropleth(
    geo_data=us_states,
    data=state_data,
    columns=["State", "Unemployment"],
    key_on="feature.id",
    fill_color="YlGn",
    name="Unemployment",
    show=False,
).add_to(m)

# The underlying GeoJson and StepColormap objects are reachable
print(type(choropleth.geojson))
print(type(choropleth.color_scale))

folium.LayerControl(collapsed=False).add_to(m)

m
<class 'folium.features.GeoJson'>
<class 'branca.colormap.StepColormap'>

GeoJSON point features with markers

https://python-visualization.github.io/folium/latest/user_guide/geojson/geojson_marker.html

import geopandas

gdf = geopandas.read_file(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/subway_stations.geojson"
)

gdf.head()
name	url	line	objectid	notes	geometry
0	Astor Pl	http://web.mta.info/nyct/service/	4-6-6 Express	1	4 nights, 6-all times, 6 Express-weekdays AM s...	POINT (-73.99107 40.73005)
1	Canal St	http://web.mta.info/nyct/service/	4-6-6 Express	2	4 nights, 6-all times, 6 Express-weekdays AM s...	POINT (-74.00019 40.71880)
2	50th St	http://web.mta.info/nyct/service/	1-2	3	1-all times, 2-nights	POINT (-73.98385 40.76173)
3	Bergen St	http://web.mta.info/nyct/service/	2-3-4	4	4-nights, 3-all other times, 2-all times	POINT (-73.97500 40.68086)
4	Pennsylvania Ave	http://web.mta.info/nyct/service/	3-4	5	4-nights, 3-all other times	POINT (-73.89489 40.66471)

gdf['href'] = '' + gdf.url + ""
gdf['service_level'] = gdf.notes.str.split(', ').apply(lambda x: len([v for v in x if "all" in v]))
gdf['lines_served'] = gdf.line.str.split('-').apply(lambda x: len(x))

service_levels = gdf.service_level.unique().tolist()
service_levels
[1, 2, 3, 0]

colors = ["orange", "yellow", "green", "blue"]

Use a Circle as a Marker

m = folium.Map(location=[40.75, -73.95], zoom_start=13)

folium.GeoJson(
    gdf,
    name="Subway Stations",
    marker=folium.Circle(radius=4, fill_color="orange", fill_opacity=0.4, color="black", weight=1),
    tooltip=folium.GeoJsonTooltip(fields=["name", "line", "notes"]),
    popup=folium.GeoJsonPopup(fields=["name", "line", "href", "notes"]),
    style_function=lambda x: {
        "fillColor": colors[x['properties']['service_level']],
        "radius": (x['properties']['lines_served'])*30,
    },
    highlight_function=lambda x: {"fillOpacity": 0.8},
    zoom_on_click=True,
).add_to(m)

m

Or use a DivIcon

m = folium.Map(location=[40.75, -73.95], zoom_start=13)


def style_function(feature):
    props = feature.get('properties')
    markup = f"""
        

            {props.get('name')}
        
        
    """
    return {"html": markup}


folium.GeoJson(
    gdf,
    name="Subway Stations",
    marker=folium.Marker(icon=folium.DivIcon()),
    tooltip=folium.GeoJsonTooltip(fields=["name", "line", "notes"]),
    popup=folium.GeoJsonPopup(fields=["name", "line", "href", "notes"]),
    style_function=style_function,
    zoom_on_click=True,
).add_to(m)

m

Use a Marker

m = folium.Map(location=[40.75, -73.95], zoom_start=13)

marker_colors = ["red", "orange", "green", "blue"]

folium.GeoJson(
    gdf,
    name="Subway Stations",
    zoom_on_click=True,
    marker=folium.Marker(icon=folium.Icon(icon='star')),
    tooltip=folium.GeoJsonTooltip(fields=["name", "line", "notes"]),
    popup=folium.GeoJsonPopup(fields=["name", "line", "href", "notes"]),
    style_function=lambda x: {
        'markerColor': marker_colors[x['properties']['service_level']],
    },
).add_to(m)

m

GeoJSON popup and tooltip

https://python-visualization.github.io/folium/latest/user_guide/geojson/geojson_popup_and_tooltip.html

import pandas as pd

income = pd.read_csv(
    "https://raw.githubusercontent.com/pri-data/50-states/master/data/income-counties-states-national.csv",
    dtype={"fips": str},
)
income["income-2015"] = pd.to_numeric(income["income-2015"], errors="coerce")
income.head()
fips	county	state	income-2015	income-1989a	income-1989b	change
0	00000	US	US	55775.0	28906	53367.28102	4.316843
1	01000	Alabama	AL	44833.0	22202	40990.11877	8.571546
2	01001	Autauga County	AL	56580.0	26898	49660.04030	12.230399
3	01003	Baldwin County	AL	52387.0	24043	44389.03818	15.267074
4	01005	Barbour County	AL	31433.0	18673	34474.75398	-9.676945

import geopandas
import requests

data = requests.get(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/us_states.json"
).json()
states = geopandas.GeoDataFrame.from_features(data, crs="EPSG:4326")

states.head()
geometry	name
0	POLYGON ((-87.35930 35.00118, -85.60667 34.984...	Alabama
1	MULTIPOLYGON (((-131.60202 55.11798, -131.5691...	Alaska
2	POLYGON ((-109.04250 37.00026, -109.04798 31.3...	Arizona
3	POLYGON ((-94.47384 36.50186, -90.15254 36.496...	Arkansas
4	POLYGON ((-123.23326 42.00619, -122.37885 42.0...	California

import io
import requests

response = requests.get(
    "https://gist.githubusercontent.com/tvpmb/4734703/raw/"
    "b54d03154c339ed3047c66fefcece4727dfc931a/US%2520State%2520List"
)
abbrs = pd.read_json(io.StringIO(response.text))

abbrs.head(3)
name	alpha-2
0	Alabama	AL
1	Alaska	AK
2	Arizona	AZ

statesmerge = states.merge(abbrs, how="left", left_on="name", right_on="name")
statesmerge["geometry"] = statesmerge.geometry.simplify(0.05)

statesmerge.head()
geometry	name	alpha-2
0	POLYGON ((-88.20274 34.99570, -85.60667 34.984...	Alabama	AL
1	MULTIPOLYGON (((-131.64584 55.03583, -131.5691...	Alaska	AK
2	POLYGON ((-109.04250 37.00026, -109.04798 31.3...	Arizona	AZ
3	POLYGON ((-94.61624 36.50186, -90.15254 36.496...	Arkansas	AR
4	POLYGON ((-124.21363 42.00071, -120.00186 41.9...	California	CA

income.groupby("state")["income-2015"].median().head()
state
AK    62561.5
AL    38721.5
AR    37890.0
AZ    43810.0
CA    53341.0
Name: income-2015, dtype: float64

statesmerge["medianincome"] = statesmerge.merge(
    income.groupby("state")["income-2015"].median(),
    how="left",
    left_on="alpha-2",
    right_on="state",
)["income-2015"]
statesmerge["change"] = statesmerge.merge(
    income.groupby("state")["change"].median(),
    how="left",
    left_on="alpha-2",
    right_on="state",
)["change"]

statesmerge.head()
geometry	name	alpha-2	medianincome	change
0	POLYGON ((-88.20274 34.99570, -85.60667 34.984...	Alabama	AL	38721.5	2.779114
1	MULTIPOLYGON (((-131.64584 55.03583, -131.5691...	Alaska	AK	62561.5	14.758367
2	POLYGON ((-109.04250 37.00026, -109.04798 31.3...	Arizona	AZ	43810.0	NaN
3	POLYGON ((-94.61624 36.50186, -90.15254 36.496...	Arkansas	AR	37890.0	10.897394
4	POLYGON ((-124.21363 42.00071, -120.00186 41.9...	California	CA	53341.0	6.716596

statesmerge["medianincome"].quantile(0.25)
43969.375

import branca


colormap = branca.colormap.LinearColormap(
    vmin=statesmerge["change"].quantile(0.0),
    vmax=statesmerge["change"].quantile(1),
    colors=["red", "orange", "lightblue", "green", "darkgreen"],
    caption="State Level Median County Household Income (%)",
)

m = folium.Map(location=[35.3, -97.6], zoom_start=4)

popup = folium.GeoJsonPopup(
    fields=["name", "change"],
    aliases=["State", "% Change"],
    localize=True,
    labels=True,
    style="background-color: yellow;",
)

tooltip = folium.GeoJsonTooltip(
    fields=["name", "medianincome", "change"],
    aliases=["State:", "2015 Median Income(USD):", "Median % Change:"],
    localize=True,
    sticky=False,
    labels=True,
    style="""
        background-color: #F0EFEF;
        border: 2px solid black;
        border-radius: 3px;
        box-shadow: 3px;
    """,
    max_width=800,
)


g = folium.GeoJson(
    statesmerge,
    style_function=lambda x: {
        "fillColor": colormap(x["properties"]["change"])
        if x["properties"]["change"] is not None
        else "transparent",
        "color": "black",
        "fillOpacity": 0.4,
    },
    tooltip=tooltip,
    popup=popup,
).add_to(m)

colormap.add_to(m)

m

Using GeoPandas.GeoDataFrame in folium

https://python-visualization.github.io/folium/latest/user_guide/geojson/geopandas_and_geo_interface.html

GeoPandas is a project to add support for geographic data to pandas objects. (See geopandas/geopandas)

It provides (among other cool things) a GeoDataFrame object that represents a Feature collection. When you have one, you may be willing to use it on a folium map. Here’s the simplest way to do so.

In this example, we’ll use the same file as GeoPandas demo ; it’s containing the boroughs of New York City.

GeoPandas는 팬더 개체에 지리 데이터에 대한 지원을 추가하는 프로젝트이다. (geopandas/geopandas 참조)

이는 기능 컬렉션을 나타내는 GeoDataFrame 객체를 제공한다. 하나가 있으면 Folium 지도에 기꺼이 사용할 수 있다. 가장 간단한 방법은 다음과 같다.

이 예에서는 GeoPandas 데모와 동일한 파일을 사용한다. 그것은 뉴욕시의 자치구를 포함하고 있다.

import geopandas

boros = geopandas.read_file(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/new_york_boroughs.zip"
)

boros
BoroCode	BoroName	Shape_Leng	Shape_Area	geometry
0	5	Staten Island	330454.175933	1.623847e+09	MULTIPOLYGON (((970217.022 145643.332, 970227....
1	3	Brooklyn	741227.337073	1.937810e+09	MULTIPOLYGON (((1021176.479 151374.797, 102100...
2	4	Queens	896875.396449	3.045079e+09	MULTIPOLYGON (((1029606.077 156073.814, 102957...
3	1	Manhattan	358400.912836	6.364308e+08	MULTIPOLYGON (((981219.056 188655.316, 980940....
4	2	Bronx	464475.145651	1.186822e+09	MULTIPOLYGON (((1012821.806 229228.265, 101278...

To create a map with these features, simply put them in a GeoJson:

이러한 기능이 포함된 지도를 만들려면 해당 기능을 GeoJson에 넣으면 된다.

m = folium.Map([40.7, -74], zoom_start=10, tiles="cartodbpositron")

folium.GeoJson(boros).add_to(m)

m

Quite easy.

꽤 쉽다.

Adding style

Well, you can also take advantage of your GeoDataFrame structure to set the style of the data. For this, just create a column style containing each feature’s style in a dictionary.

GeoDataFrame 구조를 활용하여 데이터 스타일을 설정할 수도 있다. 이를 위해 사전에 각 지형지물의 스타일을 포함하는 열 스타일을 생성하면 된다.

boros["style"] = [
    {"fillColor": "#ff0000", "weight": 2, "color": "black"},
    {"fillColor": "#00ff00", "weight": 2, "color": "black"},
    {"fillColor": "#0000ff", "weight": 2, "color": "black"},
    {"fillColor": "#ffff00", "weight": 2, "color": "black"},
    {"fillColor": "#00ffff", "weight": 2, "color": "black"},
]

boros
BoroCode	BoroName	Shape_Leng	Shape_Area	geometry	style
0	5	Staten Island	330454.175933	1.623847e+09	MULTIPOLYGON (((970217.022 145643.332, 970227....	{'fillColor': '#ff0000', 'weight': 2, 'color':...
1	3	Brooklyn	741227.337073	1.937810e+09	MULTIPOLYGON (((1021176.479 151374.797, 102100...	{'fillColor': '#00ff00', 'weight': 2, 'color':...
2	4	Queens	896875.396449	3.045079e+09	MULTIPOLYGON (((1029606.077 156073.814, 102957...	{'fillColor': '#0000ff', 'weight': 2, 'color':...
3	1	Manhattan	358400.912836	6.364308e+08	MULTIPOLYGON (((981219.056 188655.316, 980940....	{'fillColor': '#ffff00', 'weight': 2, 'color':...
4	2	Bronx	464475.145651	1.186822e+09	MULTIPOLYGON (((1012821.806 229228.265, 101278...	{'fillColor': '#00ffff', 'weight': 2, 'color':...

m = folium.Map([40.7, -74], zoom_start=10, tiles="cartodbpositron")

folium.GeoJson(boros).add_to(m)

m

Use any object with __geo_interface__

Folium should work with any object that implements the __geo_interface__ but be aware that sometimes you may need to convert your data to epsg='4326' before sending it to folium.

Folium은 __geo_interface__를 구현하는 모든 개체와 작동해야 하지만 때로는 데이터를 Folium으로 보내기 전에 데이터를 epsg='4326'으로 변환해야 할 수도 있다는 점에 유의하라.

import fiona
import shapely

url = "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/route_farol.gpx"
with fiona.open(url, "r", layer="tracks") as records:
    tracks = [shapely.geometry.shape(record["geometry"]) for record in records]

track = tracks[0]

m = folium.Map(tiles="cartodbpositron")
folium.GeoJson(track).add_to(m)

m.fit_bounds(m.get_bounds())

m

Smoothing

https://python-visualization.github.io/folium/latest/user_guide/geojson/smoothing.html

The level of smoothing of the geometry can be determined by passing smooth_factor as an argument when initialising GeoJson, TopoJson and Choropleth objects. There are no upper or lower bounds to the smoothing level; Leaflet’s default is 1.

GeoJson, TopoJson 및 Choropleth 개체를 초기화할 때 smooth_factor를 인수로 전달하여 기하 도형의 평활화 수준을 결정할 수 있다. 스무딩 수준에는 상한이나 하한이 없다. Leaflet 기본값은 1이다.

import requests

m = folium.Map(location=[-59.1759, -11.6016], tiles="cartodbpositron", zoom_start=2)

topo = requests.get(
    "https://raw.githubusercontent.com/python-visualization/folium-example-data/main/antarctic_ice_shelf_topo.json"
).json()

folium.TopoJson(
    data=topo,
    object_path="objects.antarctic_ice_shelf",
    name="default_smoothing",
    smooth_factor=1,
    style_function=lambda x: {"color": "#004c00", "opacity": "0.7"},
).add_to(m)


folium.TopoJson(
    data=topo,
    object_path="objects.antarctic_ice_shelf",
    name="heavier smoothing",
    smooth_factor=10,
    style_function=lambda x: {"color": "#1d3060", "opacity": "0.7"},
).add_to(m)

folium.LayerControl().add_to(m)

m

Features

FitOverlays

https://python-visualization.github.io/folium/latest/user_guide/features/fit_overlays.html

When you add this class to your map, the map will pan and zoom to fit the enabled overlays.

By default, the map won’t necessarily show all elements that were added. You may have to pan or zoom out to find them.

If we add the FitOverlays class, it will automatically pan and zoom to show the enabled overlays. In this example we show only the first marker by default. If you enable the second marker, the view changes to include it.

이 클래스를 지도에 추가하면 활성화된 오버레이에 맞게 지도가 이동 및 확대/축소된다.

기본적으로 지도에는 추가된 모든 요소가 반드시 표시되는 것은 아니다. 찾으려면 이동하거나 축소해야 할 수도 있다.

FitOverlays 클래스를 추가하면 활성화된 오버레이를 표시하기 위해 자동으로 이동 및 확대/축소된다. 이 예에서는 기본적으로 첫 번째 마커만 표시된다. 두 번째 마커를 활성화하면 이를 포함하도록 뷰가 변경된다.

m = folium.Map((52, 0), tiles='cartodbpositron', zoom_start=8)

fg1 = folium.FeatureGroup().add_to(m)
folium.Marker((52, 5)).add_to(fg1)

fg2 = folium.FeatureGroup(show=False).add_to(m)
folium.Marker((52, 5.1)).add_to(fg2)

folium.FitOverlays().add_to(m)

folium.LayerControl().add_to(m)

m

FitOverlays has a couple options:

• padding adds pixels around the bounds.
• max_zoom can be used to prevent zooming in too far.
• fly enables a smoother, longer animation, so you can see how the view changes.
• fit_on_map_load can be used to disable the fitting that happens when the map loads.

FitOverlays에는 다음과 같은 몇 가지 옵션이 있다.

• 패딩은 경계 주위에 픽셀을 추가한다.
• max_zoom을 사용하면 너무 멀리 확대되는 것을 방지할 수 있다.
• fly를 사용하면 더 부드럽고 긴 애니메이션이 가능하므로 뷰가 어떻게 변하는지 확인할 수 있다.
• fit_on_map_load를 사용하면 지도가 로드될 때 발생하는 피팅을 비활성화할 수 있다.

Note that padding and max_zoom can achieve the same effect.

padding과 max_zoom은 동일한 효과를 얻을 수 있다.

Click-related classes

https://python-visualization.github.io/folium/latest/user_guide/features/click_related_classes.html

ClickForMarker

ClickForMarker lets you create markers on each click.

ClickForMarker를 사용하면 클릭할 때마다 마커를 만들 수 있다.

folium.Map().add_child(
    folium.ClickForMarker()
)

Click on the map to see the effects

You can customize the popup by providing a string, an IFrame object or an Html object. You can include the latitude and longitude of the marker by using ${lat} and ${lng}.

효과를 보려면 지도를 클릭하라.

문자열, IFrame 객체 또는 Html 객체를 제공하여 팝업을 사용자 정의할 수 있다. ${lat} 및 ${lng}를 사용하여 마커의 위도와 경도를 포함할 수 있다.

folium.Map().add_child(
    folium.ClickForMarker("Lat: ${lat}
Lon: ${lng}")
)

Click on the map to see the effects

효과를 보려면 지도를 클릭하라.

LatLngPopup

LatLngPopup lets you create a simple popup at each click.

LatLngPopup을 사용하면 클릭할 때마다 간단한 팝업을 만들 수 있다.

folium.Map().add_child(
    folium.LatLngPopup()
)

Click on the map to see the effects

효과를 보려면 지도를 클릭하라.

ClickForLatLng

ClickForLatLng lets you copy coordinates to your browser clipboard.

ClickForLatLng를 사용하면 좌표를 브라우저 클립보드에 복사할 수 있다.

folium.Map().add_child(
    folium.ClickForLatLng(format_str='"[" + lat + "," + lng + "]"', alert=True)
)

Click on the map to see the effects

If you want to collect back the information in python, you may (install and) import the clipboard library:

효과를 보려면 지도를 클릭하라.

Python으로 정보를 다시 수집하려면 클립보드 라이브러리를 설치하고 가져올 수 있다.

>>> import clipboard
>>> clipboard.paste()
[-43.580391,-123.824467]

Plugins

https://python-visualization.github.io/folium/latest/user_guide/plugins.html

Plugin	Description
Ant Path	A flux animation (like walking of ants) along a polyline.
Boat Marker	A boat marker using HTML canvas for displaying yachts and sailboats with heading and optional wind information.
Beautify Icon	Lightweight plugin that adds colorful iconic markers without image and gives full control of style to end user (i.e. Unlimited colors and CSS styling).
Draw	Enables drawing features like polylines, polygons, rectangles, circles and markers through a very nice user-friendly interface with icons and hints.
Dual Map	Synchronized view of two maps in the same window.
FeatureGroup Subgroup	Create Feature Groups that add their child layers into a parent group.
Float Image	Add a floating image in the HTML canvas on top of the map.
Fullscreen	A fullscreen button control for modern browsers, using HTML Fullscreen API.
Geocoder	A clean and extensible control for both geocoding and reverse geocoding using different geocoding providers.
Grouped Layer Control	Create layer control with support for grouping overlays together.
Heatmap	A tiny, simple and fast heatmap plugin.
Heatmap with Time	Create a time-aware heatmap.
Locate Control	Geolocate a user over an encrypted connection.
Marker Cluster	Beautiful, sophisticated, high performance marker clustering solution with smooth animations.
Measure Control	Coordinate, linear, and area measure control.
Mini Map	A small minimap showing the map at a different scale to aid navigation.
Mouse Position	A control that displays geographic coordinates of the mouse pointer, as it is moved over the map.
Pattern	Add support for pattern fills on Paths.
Polygon Encoded	Draw a polygon directly from an encoded string.
Polyline Encoded	Draw a polyline directly from an encoded string.
Polyline Offset	Shift relative pixel offset, without actually changing the actual latitude longitude values.
Polyline Textpath	Write text along polylines.
Realtime	Put realtime data (like live tracking, GPS information) on a map.
Scroll Zoom Toggler	Enable/Disable zooming via a button.
Search	A control for search Markers/Features location by custom property in LayerGroup/GeoJSON.
Semi Circle	Add a marker in the shape of a semicircle, similar to the Circle class.
Side by Side Layers	A control to add a split screen to compare two map overlays.
Tag Filter Button	Creates a Tag Filter Button to filter elements based on different criteria.
Terminator	Overlay day and night regions on a map.
Timeline	Create a timeline with a time slider for geojson data with start and end times.
Timeslider Choropleth	Create a choropleth with a timeslider for timestamped data.
Timestamped GeoJSON	Add GeoJSON data with timestamps to a map.
TreeLayerControl	Add a control for a tree of layers with checkboxes for visibility control.
Vector Tiles using VectorGridProtobuf	Display gridded vector data (GeoJSON or TopoJSON sliced with geojson-vt, or protobuf vector tiles).
WMS Time Dimension	Create a time-aware WmsTileLayer.

플러그인	설명
Ant Path	폴리라인을 따라 움직이는 유동 애니메이션(개미의 걷기와 같은)이다.
Boat Marker	방향 및 선택적 바람 정보와 함께 요트 및 범선을 표시하기 위해 HTML 캔버스를 사용하는 보트 마커이다.
Beautify Icon	이미지 없이 다채로운 아이콘 마커를 추가하고 최종 사용자에게 스타일에 대한 완전한 제어권을 제공하는 경량 플러그인(예: 무제한 색상 및 CSS 스타일)
Draw	아이콘과 힌트가 포함된 매우 훌륭하고 사용자 친화적인 인터페이스를 통해 폴리라인, 폴리곤, 직사각형, 원, 마커 등의 그리기 기능을 활성화한다.
Dual Map	동일한 창에서 두 지도의 동기화된 보기이다.
FeatureGroup Subgroup	하위 레이어를 상위 그룹에 추가하는 기능 그룹을 생성한다.
Float Image	지도 상단의 HTML 캔버스에 부동 이미지를 추가한다.
Fullscreen	HTML 전체 화면 API를 사용하는 최신 브라우저용 전체 화면 버튼 컨트롤이다.
Geocoder	다양한 지오코딩 공급자를 사용하여 지오코딩과 역지오코딩을 모두 명확하고 확장 가능한 제어한다.
Grouped Layer Control	오버레이 그룹화를 지원하는 레이어 컨트롤을 만든다.
Heatmap	작고 간단하며 빠른 히트맵 플러그인이다.
Heatmap with Time	시간 인식 히트맵을 만든다.
Locate Control	암호화된 연결을 통해 사용자의 위치를 ​​파악한다.
Marker Cluster	부드러운 애니메이션을 갖춘 아름답고 정교한 고성능 마커 클러스터링 솔루션이다.
Measure Control	좌표, 선형 및 면적 측정 제어.
Mini Map	탐색을 돕기 위해 다양한 축척으로 지도를 표시하는 작은 미니맵이다.
Mouse Position	지도 위에서 마우스 포인터를 이동할 때 마우스 포인터의 지리적 좌표를 표시하는 컨트롤이다.
Pattern	경로에 패턴 채우기 지원을 추가한다.
Polygon Encoded	인코딩된 문자열에서 직접 다각형을 그린다.
Polyline Encoded	인코딩된 문자열에서 직접 폴리라인을 그린다.
Polyline Offset	실제 위도 경도 값을 실제로 변경하지 않고 상대 픽셀 오프셋을 이동한다.
Polyline Textpath	폴리라인을 따라 텍스트를 작성한다.
Realtime	지도에 실시간 데이터(예: 실시간 추적, GPS 정보)를 추가한다.
Scroll Zoom Toggler	버튼을 통해 확대/축소를 활성화/비활성화한다.
Search	LayerGroup/GeoJSON의 사용자 정의 속성으로 검색 마커/특징 위치를 제어한다.
Semi Circle	Circle 클래스와 유사하게 반원 모양의 마커를 추가한다.
Side by Side Layers	두 개의 지도 오버레이를 비교하기 위해 분할 화면을 추가하는 컨트롤이다.
Tag Filter Button	다양한 기준에 따라 요소를 필터링하는 태그 필터 버튼을 만든다.
Terminator	지도에 낮과 밤 지역을 오버레이한다.
Timeline	시작 및 종료 시간이 포함된 geojson 데이터에 대한 시간 슬라이더가 있는 타임라인을 만든다.
Timeslider Choropleth	타임스탬프가 지정된 데이터에 대해 타임슬라이더를 사용하여 등치(choropleth)를 만든다.
Timestamped GeoJSON	타임스탬프가 포함된 GeoJSON 데이터를 지도에 추가한다.
TreeLayerControl	가시성 제어를 위한 확인란을 사용하여 레이어 트리에 대한 제어를 추가한다.
Vector Tiles using VectorGridProtobuf	그리드 벡터 데이터를 표시한다(geojson-vt 또는 protobuf 벡터 타일로 슬라이스된 GeoJSON 또는 TopoJSON).
WMS Time Dimension	시간 인식 WmsTileLayer를 만든다.