get_elevation="capacity_mw",
get_position=["longitude", "latitude"],
elevation_scale=100,
pickable=True,
auto_highlight=True,
radius=20000,
get_fill_color="color",
),
]
r = pydeck.Deck(
views=[view],
initial_view_state=view_state,
layers=layers,
# Note that this must be set for the globe to be opaque
parameters={"cull": True},
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
json.loads(r.to_json()),
id="deck-gl",
style={"background-color": "black"},
tooltip={"text": "{name}, {primary_fuel} plant, {country}"},
))
if __name__ == "__main__":
app.run_server(debug=True)
getS2Token="token",
get_fill_color="[value * 255, (1 - value) * 255, (1 - value) * 128]",
get_elevation="value",
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=45)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip={"text": "{token} value: {value}"},
mapboxKey=mapbox_api_token,
))
if __name__ == "__main__":
app.run_server(debug=True)
target = [df.x.mean(), df.y.mean(), df.z.mean()]
point_cloud_layer = pydeck.Layer(
"PointCloudLayer",
data=DATA_URL,
get_position=["x", "y", "z"],
get_color=["r", "g", "b"],
get_normal=[0, 0, 15],
auto_highlight=True,
pickable=True,
point_size=3,
)
view_state = pydeck.ViewState(
target=target, controller=True, rotation_x=15, rotation_orbit=30, zoom=5.3
)
view = pydeck.View(type="OrbitView", controller=True)
r = pydeck.Deck(point_cloud_layer, initial_view_state=view_state, views=[view])
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(), id="deck-gl", style={"background-color": "#add8e6"})
)
if __name__ == "__main__":
app.run_server(debug=True)
cell_size_pixels=50,
color_range=[
[0, 25, 0, 25],
[0, 85, 0, 85],
[0, 127, 0, 127],
[0, 170, 0, 170],
[0, 190, 0, 190],
[0, 255, 0, 255],
],
get_position="COORDINATES",
get_weight="SPACES",
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=0)
# Render
r = pdk.Deck(layers=[layer], initial_view_state=view_state)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(), id="deck-gl", mapboxKey=mapbox_api_token))
if __name__ == "__main__":
app.run_server(debug=True)
world = gpd.read_file(gpd.datasets.get_path("naturalearth_lowres"))
centroids = gpd.GeoDataFrame()
centroids["geometry"] = world.geometry.centroid
centroids["name"] = world.name
layers = [
pdk.Layer(
"GeoJsonLayer",
data=world,
get_fill_color=[0, 0, 0],
),
pdk.Layer(
"TextLayer",
data=centroids,
get_position="geometry.coordinates",
get_size=16,
get_color=[255, 255, 255],
get_text="name",
),
]
r = pdk.Deck(layers, map_provider=None)
app = dash.Dash(__name__)
app.layout = html.Div(dash_deck.DeckGL(r.to_json(), id="deck-gl"))
if __name__ == "__main__":
app.run_server(debug=True)
}
r = pdk.Deck(arc_layer, initial_view_state=view_state, mapbox_key=mapbox_api_token)
app = dash.Dash(__name__)
disablecontext = html.Div(
[
html.H3("Context menu disabled (disableContext=True)"),
html.Div(
dash_deck.DeckGL(
r.to_json(),
id="disable_context",
tooltip=TOOLTIP_TEXT,
mapboxKey=r.mapbox_key,
disableContext=True,
),
style={"position": "relative", "height": "400px"},
),
],
style={
"width": "48%",
"position": "relative",
"float": "left",
"border": "1px solid black",
},
)
get_polygon="-",
get_fill_color=[0, 0, 0, 20],
)
geojson = pydeck.Layer(
"GeoJsonLayer",
DATA_URL,
opacity=0.8,
stroked=False,
filled=True,
extruded=True,
wireframe=True,
get_elevation="properties.valuePerSqm / 20",
get_fill_color="[255, 255, properties.growth * 255]",
get_line_color=[255, 255, 255],
)
r = pydeck.Deck(
layers=[polygon, geojson],
initial_view_state=INITIAL_VIEW_STATE,
mapbox_key=mapbox_api_token,
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(), id="deck-gl", mapboxKey=r.mapbox_key))
if __name__ == "__main__":
app.run_server(debug=True)
]),
dbc.FormGroup([
dbc.Label("Lidar View Mode"),
dbc.Select(
id="view-mode",
value="map",
options=[{
"label": unsnake(x),
"value": x
} for x in ["first_person", "orbit", "map"]],
),
]),
]
deck_card = dbc.Card(
dash_deck.DeckGL(id="deck-pointcloud",
tooltip={"html": "<b>Label:</b> {name}"}),
body=True,
style={"height": "calc(95vh - 215px)"},
)
app.layout = dbc.Container(
[
Header("Dash Lyft Perception", app),
html.Br(),
dbc.Card(dbc.Row([dbc.Col(c)
for c in controls], form=True), body=True),
html.Br(),
dbc.Row([
dbc.Col(dbc.Card(dcc.Graph(id="graph-camera"), body=True), md=5),
dbc.Col(deck_card, md=7),
]),
"HeatmapLayer",
data=poultry_df,
opacity=0.9,
get_position=["lng", "lat"],
threshold=0.75,
aggregation='"MEAN"',
get_weight="weight",
pickable=True,
)
r = pdk.Deck(
layers=[cattle, poultry],
initial_view_state=view,
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip={
"text":
"Concentration of cattle in blue, concentration of poultry in orange"
},
mapboxKey=mapbox_api_token,
))
if __name__ == "__main__":
app.run_server(debug=True)
radius_max_pixels=100,
line_width_min_pixels=1,
get_position="coordinates",
get_radius="exits_radius",
get_fill_color=[255, 140, 0],
get_line_color=[0, 0, 0],
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=10,
bearing=0,
pitch=0)
# Render
r = pdk.Deck(layers=[layer], initial_view_state=view_state)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip={"text": "{name}\n{address}"},
mapboxKey=mapbox_api_token,
))
if __name__ == "__main__":
app.run_server(debug=True)
)
view_state = pdk.ViewState(
latitude=37.7576171,
longitude=-122.5776844,
bearing=45,
pitch=50,
zoom=8,
)
TOOLTIP_TEXT = {
"html":
"{S000} jobs <br /> Home of commuter in red; work location in green"
}
r = pdk.Deck(
arc_layer,
initial_view_state=view_state,
mapbox_key=mapbox_api_token,
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(),
id="deck-gl",
tooltip=TOOLTIP_TEXT,
mapboxKey=r.mapbox_key))
if __name__ == "__main__":
app.run_server(debug=True)
get_target_color=[0, 128, 200],
auto_highlight=True,
)
# Set the viewport location
view_state = pdk.ViewState(latitude=50,
longitude=-40,
zoom=1,
bearing=0,
pitch=0)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
)
r.picking_radius = 10
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
mapboxKey=mapbox_api_token,
tooltip={"text": "{from_name} to {to_name}"},
))
if __name__ == "__main__":
app.run_server(debug=True)
} for period in periods_str
] # dict of periods_str to use on the Dash Component
# MAP
# -- You'll need a API Token to display the map, visit MAPBOX to create an account ...
# -- Inputting mapbox's api token
mapbx_api = password(text='MAPBOX API TOKEN',
title='MAPBOX API TOKEN',
mask='*')
# -- Creating the Map through mx_map which is a function from another py.file
mx = mx_map(mx_trade)
# -- Dash_Deck is needed here to insert the map in our Dash App's Layout
deck_component = dash_deck.DeckGL(mx.to_json(),
id="deck-gl",
mapboxKey=mapbx_api)
# Preparing the Visualizations' Attributes
# -- Get colors from: https://hihayk.github.io/scale/#128/128/0/99/-360/360/100/100/1D9A6C/29/154/108/black
colors = '''#FF00FF #FF00FF #FF00FF #FF00C5 #FF008B #FF0051 #FF0019 #FF0000 #FF0000 #FF0000 #FF0000 #FF3000 #FF6600 #FF9B00 #FFCF00 #FFFF00 #FFFF00 #FFFF00 #FFFF00
#DBFF00 #A9FF00 #79FF00 #4AFF00 #1CFF00 #00FF00 #00FF00 #00FF00 #00FF21 #00FF4E #00FF7A #00FFA4 #00FFCE #00FFF6 #00FFFF #00FFFF #00E3FF #00BBFF #0094FF #006EFF
#004AFF #0026FF #0004FF #0000FF #1F00FF #4300FF #6500FF #8600FF #A600FF #C500FF #E301FF #FF03FF #E306FF #C70AFF #AC0FFF #9014FF #7519FF #591EFF #3E23FF #2828FF
#2D31FF #3351FF #3871FF #3D91FF #42B0FF #47CEFF #4CECFF #51FFFF #56FFFF #5BFFF9 #60FFE0 #65FFC8 #6AFFB1 #6FFF9B #74FF86 #79FF79 #7EFF7E #83FF83 #95FF88 #AEFF8D
#C6FF92 #DCFF98 #F1FF9D #FFFFA2 #FFFFA7 #FFFFAC #FFFFB1 #FFF1B6 #FFE4BB #FFD9C0 #FFD0C5 #FFCACA #FFCFCF #FFD4D4 #FFD9D9 #FFDEE1 #FFE3EC #FFE8F5 #FFEDFB #FFF2FF
#FFF7FF #FFFCFF'''
colors = list(set(colors.split())) # create a list of the colors to employ
# Initiating DASH App
# -- BS refers to CSS stylesheet that we're going to use to facilitate the design process of our App's Layout
app = dash.Dash(__name__)
server = app.server
app.layout = html.Div([
html.Div(
style={
"width": "64%",
"height": "95vh",
"display": "inline-block",
"position": "relative",
},
children=[
dash_deck.DeckGL(
r.to_json(),
id="deck",
tooltip=True,
enableEvents=True,
mapboxKey=r.mapbox_key,
)
],
),
html.Div(
style={
"width": "34%",
"float": "right",
"display": "inline-block"
},
children=dcc.Tabs(id="tabs", children=tabs),
),
])
ELEVATION_DECODER = {"rScaler": 256, "gScaler": 1, "bScaler": 1 / 256, "offset": -32768}
SURFACE_IMAGE = '"https://api.mapbox.com/v4/mapbox.satellite/{{z}}/{{x}}/{{y}}@2x.png?access_token={}"'.format(
MAPBOX_API_KEY
)
terrain_layer = pdk.Layer(
"TerrainLayer",
data=None,
elevation_decoder=ELEVATION_DECODER,
texture=SURFACE_IMAGE,
elevation_data=TERRAIN_IMAGE,
)
view_state = pdk.ViewState(
latitude=46.24, longitude=-122.18, zoom=11.5, bearing=140, pitch=60
)
r = pdk.Deck(terrain_layer, initial_view_state=view_state)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(), id="deck-gl", mapboxKey=MAPBOX_API_KEY)
)
if __name__ == "__main__":
app.run_server(debug=True)
"GridLayer",
df,
pickable=True,
extruded=True,
cell_size=200,
elevation_scale=4,
get_position="COORDINATES",
)
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=45)
# Render
r = pdk.Deck(layers=[layer], initial_view_state=view_state)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip={"text": "{position}\nCount: {count}"},
mapboxKey=mapbox_api_token,
))
if __name__ == "__main__":
app.run_server(debug=True)
filled=True,
extruded=False,
get_hexagons="hexIds",
get_fill_color="[255, (1 - mean / 500) * 255, 0]",
get_line_color=[255, 255, 255],
line_width_min_pixels=2,
)
# Set the viewport location
view_state = pdk.ViewState(latitude=37.7749295,
longitude=-122.4194155,
zoom=11,
bearing=0,
pitch=30)
# Render
r = pdk.Deck(layers=[layer], initial_view_state=view_state)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip={"text": "Density: {mean}"},
mapboxKey=mapbox_api_token,
))
if __name__ == "__main__":
app.run_server(debug=True)
)
nodes = pd.read_csv(NODES_URL)
colors = pydeck.data_utils.assign_random_colors(nodes["group"])
# Divide by 255 to normalize the colors
# Specify positions and colors as columns of lists
nodes["color"] = nodes.apply(
lambda row: [c / 255 if False else c for c in colors.get(row["group"])], axis=1
)
nodes["position"] = nodes.apply(lambda row: [row["x"], row["y"], row["z"]], axis=1)
# Remove all unused columns
del nodes["x"]
del nodes["y"]
del nodes["z"]
del nodes["group"]
r = make_renderer(nodes, use_binary_transport=False)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(), id="deck-gl", style={"background-color": "charcoal"})
)
if __name__ == "__main__":
app.run_server(debug=True)
"initialViewState": {
"longitude": -122.45,
"latitude": 37.8,
"zoom": 12
},
"layers": [
{
"@@type": "ScatterplotLayer",
"data": [{
"position": [-122.45, 37.8]
}],
"getFillColor": [255, 0, 0, 255],
"getRadius": 1000,
},
{
"@@type": "TextLayer",
"data": [{
"position": [-122.45, 37.8],
"text": "Hello World"
}],
},
],
}
app = dash.Dash(__name__)
app.layout = html.Div(dash_deck.DeckGL(data, id="deck-gl"))
if __name__ == "__main__":
app.run_server(debug=True)
view_state = pdk.ViewState(
longitude=-1.415,
latitude=52.2323,
zoom=6,
min_zoom=5,
max_zoom=15,
pitch=40.5,
bearing=-27.36,
)
map_view = pdk.View("MapView", width="75%", height="600px", controller=True)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
mapbox_key=mapbox_api_token,
views=[map_view],
)
app = dash.Dash(__name__)
app.layout = html.Div(
dash_deck.DeckGL(r.to_json(),
id="deck-gl",
tooltip=True,
mapboxKey=r.mapbox_key))
if __name__ == "__main__":
app.run_server(debug=True)
# Render
r = pdk.Deck(
layers=[layer],
initial_view_state=view_state,
mapbox_key=mapbox_api_token,
)
app = dash.Dash(__name__)
app.layout = html.Div([
dash_deck.DeckGL(
r.to_json(),
id="deck-gl",
tooltip=True,
mapboxKey=r.mapbox_key,
style={
"width": "55vw",
"height": "75vh"
},
),
# Random Red Rectangle float on the right side
html.Div(
style={
"width": "40vw",
"height": "75vh",
"background-color": "red",
"float": "right",
}),
])
if __name__ == "__main__":
