The Republic of Pocket Park
The Republic of Pocket Park
Jiacheng Zhou
Master of Urban Planning
Jihae Park
Master of Architecture
ABSTRACT
Intersections attract people by providing benefits such as chance to socialize with others or revitalize to bored pathway. If a huge park, like the Central Park, would be divided into smaller parks, so that it makes more intersections alongside the pocket parks, it would be more attractive as well as accessible.
KEYWORDS
Jane Jacobs, Central Park, pocket parks, social interactions, intersections
Introduction
Great street intersection
While traffic engineers consider that interactions in between grids as a problem to overcome, Jane Jacobs sought to create more of them. In her classic book of 1961, The Death and Life of Great American Cities, Jacobs advised that shorter blocks are better blocks.
With shorter blocks come more intersections, and the corner, the pedestrian corollary of the intersection, creates a valuable point of human interaction. The corner, in her view, is where neighbors bump into each other or stop to chat, ultimately leading to social cohesion. The shorter blocks diagrammed here indeed produce more corners per unit of square measure, but they also create more paths.
These diagrams get to the heart of the way we move across the grid. To Jacobs, the long 800-foot blocks of Manhattan’s West Side deterred street life, sidewalk interactions, and the interpersonal city she was fighting to preserve.[1]
According to Jane Jacobs, more intersections mean more interactions between citizens. A park is a place for people to relax, meet and even gain social networks. Compared with one entire central park, decentralized parks, or pocket parks, more academically, which are the same amount of area from central park itself and decomposed across the city into smaller parks will cover more street intersections within Manhattan, attract more people who are living and working here to interact with each other accordingly. In this paper, we will verify whether this is true or not by visualizing the simulation result in Processing based on street geo-located data.
Pocket Park
What is a pocket park? A pocket park is a small outdoor space, usually no more than ¼ of an acre, usually only a few house lots in size or smaller, most often located in an urban area surrounded by commercial buildings or houses on small lots with few places for people to gather, relax, or to enjoy the outdoors. They are also called vest pocket parks, a term first used in the 1960’s[2].
What are the benefits of pocket parks? According to the definition above, pocket parks tend to be closely tied into the neighborhoods they serve instead of service an entire city. A research team from the University of Pennsylvania’s Perelman School of Medicine has found that distressed neighborhoods where vacant lots have been converted into small parks and community green spaces are associated with reduced crime when compared to neighborhoods with unimproved vacant lots.
Generally, successful “pocket parks” have four key qualities: they are accessible; allow people to engage in activities; are comfortable spaces and have a good image; and finally, are sociable places: one where people meet each other and take people to when they come to visit[3].
Methodology
The agent-based model (ABM) is used to explore this concept. ABM is a class of computational models for simulating the actions and interactions of autonomous agents (either individual or collective entities such as organizations or groups) with a view to assessing their effects on the system as a whole.
The agents are the intersections (population) and decomposed parks and the setting environment is the borough of Manhattan.
Firstly, how do we genrate those small pocket parks? To simplify the problem, we assume that each pocket park is rectangle, and the slope of the wide of each rectangle is nearly the same to that of the wide of Central Park.
To draw a rectangle, we need to know at least one corner point. Based on the coordination of a corner point, it is easy to calculate the other three corner points based on the table of trigonometric function.
Suppose the position of point P1(x, y) has been given, then that of P2, P3, P4 will be calculated using x and y. Fig.6 gives out the result. However, this result looks different if you use an ordinary coordinate system. The reason is that Processing has a unique coordinate system.
Now, the question comes to that how can we generate a random corner point always within Manhattan, which is actually an irregular polygon? Based on the LION Single Line Street Base Map[4], the geospatial information (longitude and latitude) of each street intersections are obtained in ArcMap and is preserved as csv file. In Processing, two vacant lists are created to preserve the longitude and latitude data separately. In order to get each group of points randomly, for-loop algorithm and the ‘random package’ are used to attain data randomly.
Then, it is time to set up a relationship between population and rectangles as our aim is to enhance social interactions among communities by creating those rectangles (pocket parks).
We assume that people are only willing to visit the park(s) not far away from them after decomposing the central park to smaller ones. We define those who (will) come to and gain social networks in parks as ‘attracted people’. Distance from the geometric center of each rectangle to each street node, the cross of each center street line is calculated. If the distance is smaller than 50, then there generates one ‘attractive person’ in that park.
We calculate the total number of attractive people in every pocket park. Finally, comparing the total population between pocket parks and the central park. It is known that each day central park[5] attracts 110,000 visitors every day. To be equal, the area of total pocket parks is the same as that of the central park. For example, in Processing, if we decompose the central park into 220 pieces, whose area is 6*10 for each, then we find out all the close pocket parks that are located within 50 units and thus we obtain the total population of ‘attracted people’. Through our project, we simulate and change the spatial distribution of pocket parks to explore the change of the number of attracted people by altering the areas of pocket parks that spread through the Manhattan. We realize this function via creating different lists that are used to assign geolocation of street intersections.
Result
As a result, as you can see through the table based on the Python simulation, as the size of the park is smaller, the population will be larger. This is because when the park is divided into the smaller size and spread out through Manhattan, it would make more intersections around the pocket parks. The increased intersections would vitalize paths by giving more diversity for the passengers and parks have more accessibility as well.
Conclusion
Good parks should be placed somewhere with dense crossroads cause it brings more people and higher vitality. We have simulated the process of decomposing the Central park into a bunch of small parks which will be randomly distributed in NYC. Then we visualized the population change based on the density of the intersections around each parks.
Constraints
When considering the definition of attractive, we simply focus on the simulation of the population. Many other criteria such as the economic situation, supplement of infrastructures and facilities, innovation index and so on are not taken into consideration. What’ more, the algorithm of the simulation still needs optimizing.
References
[1] Blake, A. (2013). Pocket parks. Accessed on, 27.
[2] Jacobs, J. The Death and Life of Great American Cities. (1961). Random House. New York.
[3] National Recreation and Park Association. (2014). Creating Mini-Parks for Increased Physical Activity. Retrieved from https://www.nrpa.org/contentassets/f768428a39aa4035ae55b2aaff372617/pocket-parks.pdf
[4] New York City Department of City Planning. (2018). LION Single Line Street Base Map [shapefile]. Retrieved from https://www1.nyc.gov/site/planning/data-maps/open-data/dwn-lion.page.
[5] Whitney North Seymour (Ed.). (1969). Small urban spaces: the philosophy, design, sociology, and politics of vest-pocket parks and other small urban open spaces. New York University Press.
[1] Jacobs, J. (1961). The Death and Life of Great American Cities. Random House, New York.
[2] National Recreation and Park Association. (2014). Creating Mini-Parks for Increased Physical Activity.
[3] National Recreation and Park Association. (2014). Creating Mini-Parks for Increased Physical Activity.
[4] New York City Department of City Planning. (2018). LION Single Line Street Base Map [shapefile]. Retrieved from https://www1.nyc.gov/site/planning/data-maps/open-data/dwn-lion.page.
import spatialpixel.mapping.slippymapper as slippymapper
import csv
import random
import mathdef setup():
size(500, 1000)
global nyc, size1_color, size2_color, size3_color, num
font_value = 0
size1_color = 225
size2_color = 225
size3_color = 225
nyc = slippymapper.SlippyMapper(
40.7528, -73.980, 12, 'carto-dark', 500, 1000)
nyc.render()
noStroke()
# toner-backgroundglobal upperleftX, upperleftY, upperrightX, upperrightY, lowerleftX, lowerleftY, lowerrightX, lowerrightY
upperleftX = nyc.lonToX(-73.958114)
upperleftY = nyc.latToY(40.800590)
upperrightX = nyc.lonToX(-73.949216)
upperrightY = nyc.latToY(40.796857)
lowerleftX = nyc.lonToX(-73.973123)
lowerleftY = nyc.latToY(40.764408)
lowerrightX = nyc.lonToX(-73.981705)
lowerrightY = nyc.latToY(40.767997)global lat, lon
lat = []
lon = []
# open 'Lat'
with open('node.csv', 'r') as r:
reader = csv.reader(r)
lat = [row[3] for row in reader]
lat = lat[1:]
lat = list(map(float, lat))
print(lat[1])# open "Lon"
with open('node.csv', 'r') as r:
reader = csv.reader(r)
lon = [row[4] for row in reader]
lon = lon[1:]
lon = list(map(float, lon))
# print(lon[1])global sec_lat, sec_lon
sec_lat = []
sec_lon = []
# open intersection lat
with open('MN_St500.csv', 'r') as mn:
reader = csv.reader(mn)
sec_lat = [row[2] for row in reader]
sec_lat = sec_lat[1:]
sec_lat = list(map(float, sec_lat))
# print(sec_lat[1])# open intersection lon
with open('MN_St500.csv', 'r') as mn:
reader = csv.reader(mn)
sec_lon = [row[3] for row in reader]
sec_lon = sec_lon[1:]
sec_lon = list(map(float, sec_lon))
# print(sec_lon[1])global recX, recY
# print(nyc.lonToX(lat[1]))global stheta, ctheta, i, lisp1, lisp2, lisp3, lisp4, lisp5, lisp6
stheta = 0.88
ctheta = 0.475
lisp1 = []
lisp2 = []
lisp3 = []
lisp4 = []
lisp5 = []
lisp6 = []for j in range(10000):
i = random.randrange(0, 10000, 2)
lisp1.append(sec_lat[i])
lisp2.append(sec_lon[i])
print(lisp1[1], lisp2[1])for j in range(10000):
i = random.randrange(0, 10000, 2)
lisp3.append(sec_lat[i])
lisp4.append(sec_lon[i])for j in range(10000):
i = random.randrange(0, 10000, 2)
lisp5.append(sec_lat[i])
lisp6.append(sec_lon[i])def draw():
background(0)
nyc.draw()global w, h, choose1, choose2, choose3, a
choose1 = (70 < mouseX and mouseX < 82) and(30 < mouseY and mouseY < 60)
choose2 = (90 < mouseX and mouseX < 110) and(30 < mouseY and mouseY < 41)
choose3 = (120 < mouseX and mouseX < 132) and(30 < mouseY and mouseY < 42)
if choose1 == False and choose2 == False and choose3 == False:
a = 255
fill(0, 225, 155)
quad(upperleftX, upperleftY, upperrightX, upperrightY,
lowerleftX, lowerleftY, lowerrightX, lowerrightY)
count = 0
num = 0
total_count=110000
while num<10:
count=count+2
num=num+1#draw original bar
fill(255, 0, 0,count*0.8)
rect(0, 750, total_count*0.001, 10)
f = createFont("Helvetica", 30, True)
textFont(f,15)
fill('#EAEAEA')
text(total_count,total_count*0.001,760)
else:
a = 0# draw intersection node
for i in range(9100):
ptX = nyc.lonToX(lon[i])
ptY = nyc.latToY(lat[i])
noStroke()
fill(255, 0, 50)
ellipse(ptX, ptY, 1, 1)# draw size symbols
f = createFont("Arial", 50, True)
textFont(f, 20)
fill(255)
text("Size", 20, 50)
fill(0, size1_color, 155)
rect(10 + 60, 30, 12, 20)
fill(0, size2_color, 155)
rect(30 + 65
, 30, 12, 6)
fill(0, size3_color, 155)
rect(60 + 60, 30, 12, 11)# draw pocket parkif choose1 == True:
w = 6
h = 10
num = 0count = 0
total_count = 0
while num < 66:
RecX = nyc.lonToX(lisp2[num]) # upperLeftX
RecY = nyc.latToY(lisp1[num]) # upperLeftY
noStroke()
fill(0, 255, 155)
lowerLeftRecX = RecX + h * ctheta
lowerLeftRecY = RecY - h * sthetalowerRightRecX = RecX + w * stheta
lowerRightRecY = RecY + w * cthetaupperRightRecX = RecX + w * stheta + h * ctheta
upperRightRecY = RecY + w * ctheta - h * sthetax0 = (RecX + lowerRightRecX) / 2
y0 = (RecY + lowerRightRecY) / 2for i in range(9100):
ptX = nyc.lonToX(lon[i])
ptY = nyc.latToY(lat[i])
# print ptX, ptY
distance = math.sqrt(
(abs(x0 - ptX)) * (abs(x0 - ptX)) + (abs(y0 - ptY)) * abs(y0 - ptY))
# print distance
if distance < 50:
count += 1
i += 1
fill(255, 0, 0,count*0.0023)
rect(total_count*0.0001, 750, count * 0.0001, 10)
total_count = total_count + count
num += 1fill(0, 255, 155)
quad(RecX, RecY, lowerLeftRecX, lowerLeftRecY, upperRightRecX,
upperRightRecY, lowerRightRecX, lowerRightRecY)
f = createFont("Helvetica", 30, True)
textFont(f,15)
fill('#EAEAEA')
text(total_count,total_count*0.0001+count*0.0001,760)elif choose2 == True:
w = 6
h = 3
num = 0
count = 0
total_count = 0
while num < 220:
RecX = nyc.lonToX(lisp4[num]) # upperLeftX
RecY = nyc.latToY(lisp3[num]) # upperLeftY
noStroke()
fill(0, 255, 155)
lowerLeftRecX = RecX + h * ctheta
lowerLeftRecY = RecY - h * sthetalowerRightRecX = RecX + w * stheta
lowerRightRecY = RecY + w * cthetaupperRightRecX = RecX + w * stheta + h * ctheta
upperRightRecY = RecY + w * ctheta - h * sthetax0 = (RecX + lowerRightRecX) / 2
y0 = (RecY + lowerRightRecY) / 2#quad(RecX,RecY,lowerLeftRecX, lowerLeftRecY, upperRightRecX, upperRightRecY,lowerRightRecX, lowerRightRecY)
for i in range(9100):
ptX = nyc.lonToX(lon[i])
ptY = nyc.latToY(lat[i])
# print ptX, ptY
distance = math.sqrt(
(abs(x0 - ptX)) * (abs(x0 - ptX)) + (abs(y0 - ptY)) * abs(y0 - ptY))
if distance < 15:
count += 1
i += 1
fill(255, 0, 0,count*0.0049)
rect(total_count * 0.0001, 750, count * 0.0001, 10)
total_count = total_count + count
num += 1
a = 0fill(0, 255, 155)
quad(RecX, RecY, lowerLeftRecX, lowerLeftRecY, upperRightRecX,
upperRightRecY, lowerRightRecX, lowerRightRecY)
f = createFont("Helvetica", 30, True)
textFont(f,15)
fill('#EAEAEA')
text(total_count,total_count*0.0001+count*0.0001,760)elif choose3 == True:
w = 6
h = 5.5
num = 0
count = 0
total_count = 0
while num < 120:
RecX = nyc.lonToX(lisp6[num]) # upperLeftX
RecY = nyc.latToY(lisp5[num]) # upperLeftY
noStroke()
fill(0, 255, 155)
lowerLeftRecX = RecX + h * ctheta
lowerLeftRecY = RecY - h * sthetalowerRightRecX = RecX + w * stheta
lowerRightRecY = RecY + w * cthetaupperRightRecX = RecX + w * stheta + h * ctheta
upperRightRecY = RecY + w * ctheta - h * sthetax0 = (RecX + lowerRightRecX) / 2
y0 = (RecY + lowerRightRecY) / 2for i in range(9100):
ptX = nyc.lonToX(lon[i])
ptY = nyc.latToY(lat[i])
# print ptX, ptY
distance = math.sqrt(
(abs(x0 - ptX)) * (abs(x0 - ptX)) + (abs(y0 - ptY)) * abs(y0 - ptY))
# print distance
if distance < 27.5:
count += 1
i += 1fill(255, 0, 0,count*0.0038)
rect(total_count * 0.0001, 750, count * 0.0001, 10)
total_count = total_count + count
num += 1
a = 0fill(0, 255, 155)
quad(RecX, RecY, lowerLeftRecX, lowerLeftRecY, upperRightRecX,
upperRightRecY, lowerRightRecX, lowerRightRecY)f = createFont("Helvetica", 30, True)
textFont(f,15)
fill('#EAEAEA')
text(total_count,total_count*0.0001+count*0.0001,760)# choose the size
def mouseMoved():
choose1 = (70 < mouseX and mouseX < 82) and(30 < mouseY and mouseY < 51)
choose2 = (90 < mouseX and mouseX < 110) and(30 < mouseY and mouseY < 41)
choose3 = (120 < mouseX and mouseX < 132) and(30 < mouseY and mouseY < 42)
global size1_color, size2_color, size3_color
if choose1 == True:
if size1_color == 225:
size1_color = 100
size2_color = 255
size3_color = 255
else:
size1_color = 225
elif choose2 == True:
if size2_color == 225:
size2_color = 100
size1_color = 255
size3_color = 255
else:
size2_color = 225
elif choose3==True:
if size3_color == 225:
size3_color = 100
size2_color = 255
size1_color = 255
else:
size3_color = 225
else:
size1_color = 255
size2_color = 255
size3_color = 255
