►
From YouTube: Capacity Analysis: Mapping How Interventions to the Spread of COVID-19 - Kristian Ekenes, Esri
Description
Capacity Analysis: Mapping How Interventions to the Spread of COVID-19 Improve Healthcare Providers’ Ability to Meet Patient Demand
A
Good
morning,
I'd
like
to
welcome
you
out
to
my
talk
capacity,
analysis
mapping,
how
interventions
to
the
spread
of
koban
19
improve
healthcare
providers.
Ability
to
meet
patient
demand.
Sorry
that
was
a
bit
of
a
mouthful,
but
by
way
of
introduction,
my
name
is
Christian
echinus
I'm,
a
product
engineer
at
SV
and
I
work
on
the
ArcGIS
API
for
JavaScript.
Let's
go
ahead
and
dive
right
into
this.
A
If
there's
any
lesson
that
the
pandemic
has
taught
us,
it's
that
geography
matters
and
that
spatial
thinking
matters
more
now
than
ever
before,
and
that
will
be
an
overriding
theme
throughout
this
talk.
Ultimately,
this
came
down
to
one
goal.
We
wanted
to
build
an
application,
a
web
app
that
properly
communicates
how
interventions
to
the
spread
of
kovin
19,
such
as
physical
distancing,
reduce
hospital
stress
for
a
particular
area
of
interest,
but
before
diving
in
I
want
to
take
a
quick
minute
to
describe
the
work
that
every
does
in
the
work
that
I
do.
A
To
put
it
all
into
context.
Ezri
builds
GIS
software,
that's
short
for
geographic
information
systems
and
that's
just
a
fancy
way
of
saying
that
we
build
mapping
software
and
we
build
a
variety
of
spatial
analysis
tools
for
desktop
mobile
and
web
clients.
We
also
provide
dozens
of
api's
for
developers
to
extend
our
software
and
to
build
their
own
customized
applications.
So
this
chart
here
on
this
particular
slide
is,
is
a
little
overly
simplistic.
A
We
do
build
all
of
these
apps,
but
we
expose
a
variety
of
ApS
for
developer
community,
but
I
specifically
work
on
ArcGIS
API
for
JavaScript.
This
is
a
powerful
API
that
allows
us
to
build
web
applications
specifically
for
mapping
and
I'm,
particularly
particularly
involved
in
many
of
the
projects
that
you
see
here
on
the
slide
and
they're
related
to
data
visualization.
A
We
do
everything
from
3d
mapping
to
multivariate
mapping
predominance
and
particularly,
what
I'm
most
interested
in,
which
is
exploratory
mapping,
and
that's
going
to
play
a
heavy
role
in
my
talk
today,
but
I
also
want
to
mention
this
fast
performance
with
WebGL.
We
have
a
WebGL
rendering
engine
which
allows
us
to
to
build
highly
interactive
app.
In
conjunction
with
this
client-side
query
engine
that
we
have
within
the
JavaScript
API
at
ESRI,
so
that
I'll
touch
on
that
a
little
bit
later.
A
But
I
just
want
to
note
that
this
is
all
about
exploring
data,
something
that
some
apps
that
are
built
with
the
JavaScript
API
include
configurable
applications
that
Ezra
openly
provides
to
to
customers,
and
these
include
dashboards
such
as
this
one.
This
is
one
that
you're,
probably
familiar
with
or
may
have
seen
in
the
news.
This
is
Johns
Hopkins,
University's,
coronavirus,
Resource
Center.
They
it's
the
most
up-to-date
tracking
app
of
the
virus
out
there
today,
and
so
they
basically
build
this
using
a
configurable
template
that
we
that's
built
on
top
of
the
JavaScript
API.
A
But
before
going
into
the
hospital
capacity,
question,
I
want
to
give
a
brief
overview
of
just
a
small
portion
of
our
API
is
to
set
up
the
work
that
we
did
there.
The
X
API
for
JavaScript
isn't
about
just
showing
where
things
are
located,
but
it's
more
about
what
is
there,
how
much
of
it
exists
and
doing
that
in
a
meaningful
way
and
there's
many
ways
to
do
that
and
I'm
just
going
to
touch
on
a
couple
of
techniques
and
those
are
size
in
color.
A
So
if
we
look
at
this
particular
map
on
this
slide,
we're
looking
at
the
total
number
of
positive
test
results
by
a
particular
date.
So
this
I
believe
was
was
displayed
for
June
1st
of
this
year
and
the
way
that
we
created
this
visualization
is
using
the
renderer
property
of
our
layer.
The
layer
is
us
counties
and
we
and
we
represent
them
as
icons
or
circles,
those
pink
circles
and
the
centroids
of
the
county,
where
the
data-driven
aspect
comes
into
play
is
with
visual
variables.
A
The
visual
variables
just
simply
allow
us
to
override
a
property
of
the
symbol.
It
could
be
size,
it
could
be
color,
it
could
be
a
rotation
or
even
opacity,
and
we
override
it
based
on
a
data
value.
So
in
this
case
we
specify
a
field.
So
the
number
of
infections
on
June
1st
to
2020
and
then
we'll
indicate
what
the
icon
should
be
based
on
the
value
of
that
of
that
data.
A
So
in
New
York
we
have
a
value
of
over
two
hundred
thousand,
which
would
give
the
size
twenty
pixels,
whereas
other
places
in
the
Midwest
and
West
would
be
much
smaller.
So
we
think
that
this
is
a
very
simple,
intuitive
API
that
allows
you
to
to
create
dynamic
visualizations
that
allow
you
to
understand
what's
happening.
A
You
can
also
look
at
color
such
as
here
we're
using
a
fill
symbol
instead
of
an
icon
and
we're
changing
the
fill
of
the
color
based
on
a
data
value,
and
you
can
see
those
color
stops
down
in
that
blue
highlighted
region
below.
What's
different
here
is
we're
actually
using
what
we
call
Arcade
expressions
or
value
expressions.
A
A
So
in
this
case,
we
want
to
look
at
the
rate
of
infections
per
100,000
people,
and
so
we
use
an
expression
to
do
that,
and
you
can
see
that
there
now,
when
we
talk
about
data
exploration,
there's
a
couple
of
ways
you
can
look
at
it
there's
a
way
of
exploring
data
using
filtering.
That's
just
simply
removing
the
features
that
you
know
that
don't
conform
to
a
particular
expression.
It's
a
very
common
way
of
looking
at
where
things
are
high
or
low,
or
you
can
actually
modify
the
style
or
the
renderer
itself.
A
So
the
color
stops
I
want
to
change.
The
color
stops
to
see
where
the
most
infections
are
occurring
room.
Perhaps
it's
the
highest
rate.
But
when
we
update
the
color
stops,
it's
simply
updating
those
stop
values
or
even
the
colors
themselves,
not
the
data
itself
and
that's
important,
because
when
we
get
into
the
multivariate
or
multi-dimensional
data
exploration,
it
becomes
more
about
modifying
the
data
value
itself.
So
in
that
previous
example
we're
just
changing
the
color
seeing
okay,
these
are
where
the
areas
higher
low,
but
that's
only
based
off
one
field.
A
It's
that
number
of
infections.
Up
to
May
31st
and
what,
if
we
want
to
see
the
number
of
infections
or
the
rate
of
infection
over
time,
that
would
require
a
constant
set
of
stops
here
and
then
updating
this
value
up
here.
So
that's
something
we
can
do
using
a
technique
called
multi-dimensional
data
exploration
and
that's
simply
taking
you
know
a
few
dimensions
such
as
the
location
and
then
the
variable,
and
this
gif
we're
looking
at
temperature
in
the
ocean
and
then
we
can
explore
it
with
another
dimension.
A
It
could
be
time
it
could
be
an
agent
cohort
or
income
brackets
for
demographic
data
or
perhaps
Z,
values
like
depth
and
elevation.
That's
actually
the
third
dimension,
that's
being
used
in
this
particular
application
here,
but
when
it
comes
to
mapping
covin
19,
the
the
most
obvious
case
is
or
dimension
to
use
as
x.
We
want
to
look
at
not
just
what
is
happening,
but
when
is
it
happening?
A
Let's
build
an
app
that
allows
us
to
explore
koba
19
data
through
time,
and
so
that
comes
from
a
number
of
different
questions.
You
might
ask
like
how
many
people
are
currently
sick,
how
many
new
tests,
reports
or
results
were
reported
today
or
how
many
people
have
been
infected
or
who
have
died
to
date.
Those
have
been
the
predominant
questions
that
have
been
asked
and
you've
seen
that,
with
hundreds,
even
thousands
of
mapping
applications
that
show
that
such
as
this
dashboard,
where
you
can
see
how
many
cases
have
been
reported
per
day
by
geography.
A
Ok,
here
I've
opened
up
my
browser
to
show
conceptually
another
way.
You
could
look
at
the
past
data
as
a
time
series
I've
just
taken
the
Johns
Hopkins
data
I've
added
a
time
slider,
which
is
out
of
the
box
widget
and
the
ArcGIS
API
for
JavaScript,
and
when
you
hit
play
you
can
see
how
the
number
of
infections
grows
per
County
in
the
US.
So
it's
no
longer
just
about
a
static
display
of
what's
happening
today.
It's
about
what's
happening
over
time,
so
you
can
interact
with
that.
This
is
not
a
time.
A
Filter
I'm
not
filtering
out
different
counties,
I'm,
actually,
just
updating
that
visualization
and
I'll
show
you
that
in
just
a
bit
you
can
also
use
our
Cade
to
create
more
complex,
visualizations
such
as
doubling
time
so
I
see
the
total
number
of
infections.
But
then
I
can
use
color
to
indicate
how
fast
those
infections
are
growing.
So
I
can
see
that
in
the
Midwest
on
this
particular
date,
May
7th
that
they
were
still
doubling
at
7
days
or
less,
and
you
see
that
in
Chicago
too
right
there.
A
So
you
can
create
some
pretty
cool
applications
using
this
multi-dimensional
approach.
So
if
you
look
at
this
CSV
data
up
to
the
right,
this
is
the
Johns
Hopkins
CSV.
That
I
was
talking
about
just
a
second
ago.
Basically
they
add
a
new
column
every
day,
with
the
total
account
for
the
infections
up
to
that
date.
A
So
it's
up
to
date
and
you
can
work
with
it
seamlessly
so
I
if
I
want
to
map
that
I
just
create
the
render
like
I
did
before
and
I
reference
one
of
those
fields,
so
I'm
referencing,
April,
1st
2020
and
then
I
can
map
it.
In
my,
in
my
view
there
and
if
I
want
to
change
my
visualization
rather
than
copying
all
my
features
and
then
rendering
it
based
on
a
different
field,
I
can
simply
update
that
field.
A
Each
time
the
slider
position
changes
and
that
will
allow
me
to
see
how
it
changes
over
time.
We're
able
to
do
that
because
we
bring
all
that
data
down
to
the
GPU,
and
so
when
the
renderer
updates
were
actually
have
access
to
that
data.
Already
it's
you
know
lookup
table,
so
we
can
just
point
to
that
field.
It's
already
part
of
the
geometry,
so
we
can
update
the
the
style
of
it.
We
don't
have
to
discard
the
geometries
and
re-render
them
like
we
used
to.
This
is
allows
us
for
highly
interactive
applications
all
right
now.
A
Let's
talk
about
the
future,
so
not
just
who's
been
sick
or
how
many
people
have
been
sick
up
to
this
date,
but
we
want
to
look
at.
Are
we
prepared
to
handle
a
novel
coronavirus
and
how
many
people
might
require
admission
to
a
hospital
and
that
all
depends
on
modeling,
authoritative,
modeling
and
forecasting
that,
because
we
can't
obviously
predict
the
future-
and
this
is
a
chart
that
from
the
CDC
that
we're
probably
all
familiar
with
and
that
compares
two
different
curves?
A
It
shows
the
number
of
cases
over
time
if
no
intervention
is
taken
during
a
pandemic
outbreak,
that's
the
purple
one!
If
you
look
at
the
smaller
curve.
That
indicates
the
number
of
cases
over
time.
If
intervention
takes
place-
and
that's
important
for
two
reasons-
one
is
that
it
reduces
the
overall
number
of
cases.
So
we
save
more
people
and
two.
It
helps
our
hospitals
out
because
they
only
have
a
certain
number
of
beds,
a
certain
number
of
ventilators
to
help
treat
people
for
a
disease
like
this,
and
so
by
intervening
and
flattening
the
curve.
A
We
can
help
them
out,
so
they
can
treat
an
appropriate
number
of
people.
So,
but
looking
at
this
chart,
there's
no
numbers
on
it.
It's
all
conceptual,
so
we
need
models
with
real
numbers
to
help
us
truly
understand
which
interventions
will
work
and
what
needs
to
happen
in
order
to
help
us
in
this
scenario,
and
so
various
things
are
proposed,
such
as
social
or
physical
distancing
wearing
of
masks
shelter-in-place
guidelines,
but
that
also
prompts
people
to
ask
well
how
much
does
that
actually
help
and
when
can
I
get
back
to
normal?
A
Does
the
phased
approach
to
reopening
actually
work,
and
how
much
does
that
improve
versus
reopening
everything
now,
and
so
what
we
do
is
we
can
run
various
outputs
of
models
as
what-if
scenarios.
This
allows
us
to
understand
which
policies
will
work.
That'll,
allow
us
to
properly
allocate
Hospital
resources
to
areas
that
are
in
more
need
and
to
know
where
test
facilities
should
be
located.
Ultimately,
an
application
like
this
that
I'll
show
in
at
just
a
second
will
allow
us
to
transparently
communicate
results
to
the
public
and
to
the
people
who
are
making
these
decisions.
A
Now,
when
we
talk
about
forecasting
using
models,
there's
two
Authority,
authoritative
models
that
we,
as
we
have
looked
at
as
helping
us
in
this
effort.
There's
the
chyme
model,
which
was
developed
by
Penn
Medicine
and
the
CDC's
Cove
innate
search
model.
They
both
look
at
similar
parameters
such
as
the
number
of
cases
in
an
area,
the
number
of
hospitalizations,
the
total
number
of
hospital
resources
and
susceptible
populations.
A
The
differences
are
that
the
chyme
model
looks
at
social
distancing
as
a
parameter,
so
you
can
indicate
the
percentage
of
the
population
that
complies
with
it
and
how
that
affects
the
number
of
hospitalizations
as
well,
and
then
the
Curt,
the
Cova
nineteen
surge
model,
looks
at
a
staged
intervention
approach
and
how
well
that
actually
will
help
reduce
the
number
of
hospitalizations
in
our
particular
applications.
We
want
to
look
at
three
variables.
A
So
you
can
see
how
well
the
curve
flattens
for
the
overall
data
set
and
also
for
a
particular
geography,
so
I'm
going
to
open
up
this
application
here
in
my
web
browser
here,
I've
opened
the
kind
of
a
default
view
of
of
this
capacity,
analysis,
app
and
and
now
I'm.
Comparing
the
two
two
different
outputs
of
the
chyme
model,
the
view
on
the
Left
shows
what
happens
of
29%
of
the
population
social
distances.
The
view
on
the
right
indicates
what
happens
when
50%
of
the
population
social
distances.
A
This
is
a
really
simple
app
when
it
comes
down
to
it.
There's
three
attributes
that
the
user
has
control
over.
They
can
look
at
the
number
of
hospitalizations
number
of
expected.
Icu
pays
patients
or
ventilators
used,
and
then
they
have
this
time
slider
down
here
at
the
bottom,
which
allows
them
to
animate
through
time
to
see
what
they
can
expect
will
happen
based
on
you
know
these
different
parameters.
So
if
we
look
at
May
31st,
we
can
actually
see
that
29%
social
distancing
people
are
much
worse
off
than
if
50%
social
distance.
A
Our
hospitals
will
be
only
up
to
27%
capacity.
Now
you'll
note
that
that's
not
necessarily
true
across
the
board.
That's
the
benefit
of
using
maps.
We
actually
look
at
our
map
legend.
This
will
help
describe
our
methodology
for
the
visualization,
the
ayat
we
actually
use
to
visual
variables,
there's
the
color
variable
that
indicates
the
the
capacity
so
at
the
hospital
stress
if
you're
under
capacity,
the
worth
of
counties,
hospitals
are
under
capacity,
they'll
be
rendered
with
a
small
icon
and
they'll
be
gray,
or
maybe
a
orangish
peach
ish
color.
A
If
people
more
people
comply
to
this
order
or
two
this
recommendation,
we
looked
at
other
ways
of
visualizing
it
like
displaying
both
layers
in
the
same
view
or
maybe
calculating
a
difference
between
the
two,
but
they
don't
effectively
communicate
it
like
this
does,
and
this
allows
us
to
also
associate
them
with
this
chart
below.
So,
if
I
click
on
a
feature
such
as
here,
you
can
see
the
chart
update
specifically
for
that
county
now.
What
went
into
building
this
application?
A
So
the
outputs
of
that
model
that
or
both
of
those
models
that
I
described,
do
not
follow
the
same
format
that
I
showed
with
the
the
johns-hopkins
data.
The
the
johns-hopkins
data
was
outputting,
a
new
counts
with
a
new
field
every
single
day.
That
was
not
practical
for
this
particular
case,
because
we
have
three
attributes
that
we're
looking
at
the
hospital
beds,
ICU
beds,
ventilators
and
if
we
created
three
new
fields
per
day,
we'd
have
a
huge
table
that
would
be
hard
to
manage
and
we
actually
run
into
technical
limitations
with
our
feature
services.
A
Once
you
hit
a
certain
number,
so
we
decided
to
basically
generate
these
numbers
and
then
provide
them
in
a
single
field
as
pipe
separated
values.
So
when
the
user
selects
an
attribute
such
as
hospitalizations,
they
can
then
move
the
slider
to
a
particular
position
and
then
using
the
same
technique
that
you
saw
before
with
parsing
of
the
arcade
attribute,
we
can
actually
use
our
code
to
parse
that
value
out
and
then
map
it
in
both
views.
So
this
is
actually
happening
two
times
in
the
same
app
with
each
slider
change
as
the
slider
changes.
A
A
The
color
is
what's
indicating
that
percent
capacity
that
you
saw
in
the
app
itself
and
then
the
size
indicates
that
number
of
patients
over
capacity
that
a
hospital
will
be
yet
that
has
to
be
calculated
with
an
arcade
expression
because
we're
just
looking
at
raw
counts
in
the
action
data
set,
and
so
the
those
functions
were
generating.
The
arcade
basically
will
create
these
expressions
that
you
see
below
and
the
important
bits
are
highlighted
there
in
yellow.
So
we
look
at
the
total
number
of
hospitalized
people,
that's
how
we
parse
it
out
in
arcade.
A
It
looks
similar
to
what
you
might
do
in
JavaScript.
Obviously
these
are
custom
functions
that
we've
developed,
but
we
get
the
number
of
hospitalizations
based
on
this
field,
and
then
we
just
grab
the
the
count
for
a
particular
day
indicated
by
the
slider,
and
then
we
do
a
simple
normalization
and
and
in
percentage
calculation
and
then
with
the
overages
exact
same
line
of
code
here,
and
then
we
just
calculate
the
difference
between
hospitalized
versus
capacity.
If
you're
under
capacity
you're
great.
A
If
you're
over
capacity,
then
things
that's
when
things
become
a
problem
and
we
need
to
visualize
it
appropriately.
In
conclusion,
the
goal
was
to
put
make
an
application
to
put
into
the
hands
of
the
experts,
so
we
converted
this
into
a
configurable,
app
template
that
allows
experts
and
their
development
development
team
to
download
the
application
and
then
run
the
models
themselves,
and
then
they
can
deploy
it
on
their
own
terms.
So
it's
not
us.
As
are
you
saying
this
is
what's
going
to
happen,
or
this
is
what
we
predict
will
happen.
A
We
built
the
software
we
deploy
it
and
we
allow
the
experts
to
take
over
and
communicate
their
own
results.
We
wanted
this
to
be
interactive.
We
wanted
it
to
be
clear,
understandable
and
personable
and
easy
to
use,
as
you
know,
there's
only
two
there's
two
controls
and
its
side
by
side.
It's
easy
for
people
to
understand
that
one
method
will
may
substantially
reduce
the
number
of
hospitalizations
versus
another.
So
with
that
I'd
like
to
thank
you
for
joining
me
for
this
talk
again
I'm
Cristian
echinus.