이것저것 기록

Aman Kyoto

anweh — Tue, 17 Jan 2023 14:05:42 +0900

0123456

Location: Japan, 〒603-8458 Kyoto, Kita Ward, Okitayamawashiminecho, １ 1 Okitayama Washimine-Cho １

Architecture: Kerry Hill Architects

[python/GIS] QGIS 없이 파이썬만 사용해 최단거리 구하기 (OSMnx, geopandas)

anweh — Mon, 16 Jan 2023 14:35:04 +0900

오늘은 단순 직선 거리가 아닌, 도로 네트워크 상 두 지점 간 최단거리를 계산하는 코드를 포스팅 하려 한다.

README를 포함한 샘플 데이터는 깃헙을 참조하길!

https://github.com/henewsuh/osm_shortestPath

GitHub - henewsuh/osm_shortestPath: Calculate the distance to the nearest subway station using OSMnx library

Calculate the distance to the nearest subway station using OSMnx library - GitHub - henewsuh/osm_shortestPath: Calculate the distance to the nearest subway station using OSMnx library

github.com

0. 코드 설명에 앞서...

- 이 코드는 QGIS 없이 파이썬 만으로 최단거리를 계산하기 위한 코드이다.

- OSMnx라는 라이브러리를 사용했기 때문에, 도로 네트워크(출발점)와 지하철역(도착점) 관련 데이터를 Open Street Map 상에서 모두 해결하면 코드가 한결 간편해진다. 즉, 샘플 데이터가 아니라 그냥 Open Street Map 데이터를 가져다 쓴다면 코드가 간단해진다는 거다. 정확히 어디가 간단해지는 지는 이후 코드 설명에서 덧붙이기로 ㅇㅇ

- 이 코드는 사용자가 특정 출발점과 도착점 관련 데이터를 바탕으로 최단거리를 계산하려 할때 필요한 코드일 것이다.

1. 실행 환경 정보 (주요 라이브러리만)

python == 3.8.15
shapely == 2.0.0
pyproj == 3.4.1
networkx == 3.0
numpy == 1.24.1
pandas == 1.5.2
GDAL == 3.6.2
geopandas == 0.12.2
Fiona == 1.8.22
osmnx == 1.3.0

geopandas 설치시엔 의존 패키지 버전 충돌이 일어나지 않게 꼭 '순서대로' 다운 받길 바란다...

gpd는 설치 과정이.. 매우 귀찮고 까다로움.... 그치만 필수 라이브러리라 다운 받는 수밖에..ㅎ

2. 코드 설명

2-1. Import Libraries and Load Data

import os 
import geopandas as gpd 
import osmnx as ox 
import networkx as nx
from shapely.geometry import Point
import numpy as np
from tqdm import tqdm 
import matplotlib.pyplot as plt


''' Load Data '''
root = os.getcwd()
data_path = os.path.join(root, 'data')
subway = gpd.read_file(os.path.join(data_path,'Gangnam-gu_subway.shp'))
segment = gpd.read_file(os.path.join(data_path,'Gangnam-gu_streets.shp'))
centroid = segment['geometry'].centroid
print(subway.crs)
print(segment.crs)
print(centroid.crs)

'Load Data'의 내용에서 알 수 있듯이, 이 코드의 최단경로 출발점은 "segment" -- 강남구 도로 세그먼트의 중심점이다. 도착점은 "subway" -- 강남구에 속하는 지하철역이다.

출발점과 도착점에 들어가는 데이터를 변경하면 자유자재로 코드 활용이 가능하다.

print 문에서는 각각의 데이터들의 좌표 설정을 확인한다.

유클리디안 방법으로 거리를 계산하기 위해 EPSG:5179로 좌표계를 맞춰주었다.

위경도 좌표계를 사용한다면 유클리디안 방법이 아닌 haversine 방법을 사용해 거리 계산을 진행한다.

2-2. Extract Coordinates

''' Extract Coordinates '''
crds = [[list(centroid.geometry[i].coords)[0][0], list(centroid.geometry[i].coords)[0][1]] for i in range(len(centroid))]
crds_arr = np.array(crds) 
sub_crds = [[list(subway.geometry[i].coords)[0][0], list(subway.geometry[i].coords)[0][1]] for i in range(len(subway))]
sub_crds_arr = np.array(sub_crds)

Geometry 객체에서 X, Y 좌표값에 대한 정보만 추출한다.

2-3. Load OSM streets as a Graph using OSMnx

''' Load OSM streets as a Graph using OSMnx '''
G = ox.graph_from_place('강남구, 서울특별시, 대한민국', network_type='all_private') # 오래 걸림
G_utm = ox.project_graph(G, to_crs="epsg:5179")

여기부터 메인 코드의 시작이다.

OSMnx를 사용해 추출하고자 하는 지역명을 string으로 입력하여, 해당 지역의 도로 네트워크를 G (Graph)형태로 반환한다.

첫 줄에서는 ox.graph_from_place() 함수를 사용하였지만 지역명 이외에도

graph_from_address()
graph_from_bbox()
graph_from_point()
graph_from_polygon()
graph_from_xml()

등 다양한 그래프 추출 함수들이 존재한다. (https://osmnx.readthedocs.io/en/stable/osmnx.html#module-osmnx.graph)

더불어 불러오고자 하는 도로 네트워크의 종류도 파라미터로 지정할 수 있다.

network_type : string {"all_private", "all", "bike", "drive", "drive_service", "walk"}

"강남구, 서울특별시, 대한민국"보다 넓은 범위인 "서울특별시, 대한민국"을 파라미터로 설정하였을 시, 서울특별시의 모든 지역의 도로 네트워크가 하나의 거대그래프로 반환된다. 반환까지의 시간이 매우 오래 걸린다, ~~주의하길 바람...~~

2-4. Get the Nearest Nodes and Plot

''' Get Nearest Nodes using OSMnx '''
nearest, dist_st = ox.distance.nearest_nodes(G_utm, X=crds_arr[:,0], Y=crds_arr[:,1], return_dist=True)
nearest_sub, dist_sub = ox.distance.nearest_nodes(G_utm, X=sub_crds_arr[:,0], Y=sub_crds_arr[:,1], return_dist=True)


''' Plot OSMnx graph with nearest subway nodes and nearest stree nodes '''
G_utm_nodes = list(G_utm.nodes)
target_idx = [G_utm_nodes.index(nearest[i]) for i in range(len(nearest))]
subway_idx = [G_utm_nodes.index(nearest_sub[i]) for i in range(len(nearest_sub))]

nc = ['black']* len(list(G_utm.nodes))
for i in range(len(nc)): 
    if i in target_idx: 
        nc[i] = 'blue'
    if i in subway_idx: 
        nc[i] = 'red'
ns = [0.0005]* len(list(G_utm.nodes))
for i in range(len(ns)): 
    if i in target_idx: 
        ns[i] = 0.03
    if i in subway_idx: 
        ns[i] = 10

fig, ax = ox.plot_graph(G_utm, bgcolor='w', node_color=nc, node_edgecolor=None, node_size=ns,
                            node_zorder=3, edge_color='black', edge_linewidth=0.2, dpi=300)

바로 이 단락이 앞서 말했던 "Open Street Map 상에서 모두 해결하면 코드가 한결 간편해진다"에 해당하는 코드이다.

출발점과 도착점 모두 OSM에서 제공하는 데이터를 사용한다면 "내가 가지고 있는 출발/도착점 데이터"를 "OSM 그래프의 좌표"와 매칭 시킬 작업이 필요 없다.

무슨 말이냐 하면,

OSMnx의 최단거리 계산은 nx.shortest_path_length()라는 함수를 사용하는데
이때 해당 함수의 파라미터로 그래프(G), 출발 노드, 도착 노드를 입력한다.
여기서 문제는 출발/도착 노드의 정보가 좌표가 아닌, 인덱스 "번호"로 들어가야 한다는 것이다.
만약 출발/도착 노드를 OSM 상에서 구했다면 상관 없지만, 특정 데이터 (도로명주소 데이터, 따릉이 대여소)등을 출발/도착 지점으로 사용하고 싶다면 -- 그 특정 데이터에 해당하는 (혹은 가장 가까운) 그래프(G) 상 노드 인덱스를 찾아야하는 문제가 발생한다.

골치 아프다... 정말 골치 아프다....

그래서 최단거리를 계산할 일이 있으면 최대한 OSM 상에서 모든 데이터를 해결하는 것이 좋다고 말하고 싶다...ㅋ.. 은근 데이터 퀄리티도 괜찮음.

자, 다시 본론으로 돌아와서...

첫 번째 두 줄이 바로 "특정 데이터에 해당하는 (혹은 가장 가까운) 그래프(G) 상 노드 인덱스를 찾는" 코드이다.

그 밑부턴 아래 plot을 위한 빌드업 코드임..ㅇㅇ

강남구 도로의 중심점(blue), 지하철역(red), 도로네트워크(black)

2-5. Calculate the Shortest Path

''' Calculate the Shortest Path '''
shortest_dist2sub = []
for i in tqdm(range(len(nearest))): 
    centroid_point = (G_utm.nodes[nearest[i]]['x'], G_utm.nodes[nearest[i]]['y'])
    buffer = Point(centroid_point).buffer(1000) # 1000m 이내의 지하철역까지만 고려함 
    temp = []
    for j in range(len(nearest_sub)): 
        subway_point_xy = (G_utm.nodes[nearest_sub[j]]['x'], G_utm.nodes[nearest_sub[j]]['y'])   
        if buffer.contains(Point(subway_point_xy)):
            try:
                dist = nx.shortest_path_length(G_utm, nearest[i], nearest_sub[j],weight='length')
                temp.append(dist)
            except: 
                pass
    if len(temp) > 0 : 
        shortest_dist2sub.append(min(temp))
    else: 
        shortest_dist2sub.append(None)


''' Export the results '''
segment['dist2sub'] = shortest_dist2sub # add the distance to the nearest sub as a new column 
segment.to_file(os.path.join(data_path, 'result.shp'), encoding='cp949')

이번 코드의 꽃이라 말할 수 있는 부분이다 (이중 for-loop인 것은 살짝 부끄럽 ^^;;)

흠흠 어쨌든 shortest_dist2sub에 각 출발점의 가장 가까운 지하철역까지의 거리가 m단위로 담긴다.

출발점인 도로 세그먼트의 centroid 만큼 1차 for-loop을 돈다.
i번째 centroid가 원점이면서 반경이 1000m인 원 폴리곤("buffer")를 생성한다.
도착점인 지하철역의 좌표만큼 2차 for-loop을 도는데, 이때 j번째 좌표가 "buffer"의 범위에 포함되면 최단거리를 계산한다.
계산된 최단거리는 temp에 쌓는다.
2차 for-loop에서 빠져나온 후 temp의 min값만 최종 최단거리로 남겨둔다.

result 시각화 결과:

결과 이미지

point: 지하철역
녹색이 연할수록 지하철역과 가깝다는 뜻
빨간색: 인근 지하철역까지의 거리가 1200m 이상 3600m 이하
지하철역까지 거리가 너무 멀어서 'None'으로 표기한 도로

도로명주소 데이터를 OSM 그래프의 도로로 매핑하는 부분에서 에러가 나는 도로가 일부 있다.

(육안으로 봐도 1000m 안에 인접 지하철역이 있음에도 계산된 거리가 터무니 없이 멀다거나...)

이러한 부분은 추후 후처리를 통해 버리고 가야할 부분인듯.

어쨌든 오늘의 포스팅 끝 :) 일년 만의 포스팅 ^___^..

[solidity] 스마트컨트랙트 배포하기

anweh — Mon, 14 Feb 2022 15:31:30 +0900

스마트 컨트랙트 생성 순서

1. 스마트 컨트랙트 코드 작성 (.sol)

pragma solidity ^0.8.0;
//  solcjs --version 로 버전확인

contract hello { 
  string value;

  constructor(){
    value = "hello solidity";
  }

  // 파일에 저장된 내용을 가져올 것인지? storage
  // 메모리에 저장된 내용을 가져올 것인지? memory
  function get() public view returns(string memory){
    return value; 
  }

  //solcjs --bin --abi .\hello.sol
  // 파일명_확장자_컨트랙트명
}

hello_sol.sol로 저장해준다

2. 스마트 컨트랙트 코드 컴파일

해당 컨트랙트가 위치한 경로로 이동해서 컴파일 해야함
```
solcjs --abi --bin [파일명]
```
성공적으로 컴파일 되었다면, 해당 폴더 안에 .abi, .bin파일이 생성되어야 함
- abi (Application Binary Interface) : 1에서 작성한 스마트 컨트랙트 코드의 설명이 담긴 JSON 파일
- bin : 바이너리 파일

3. 컴파일 결과를 배포

'배포'한다라는 것은 블록체인 상에 컴파일한 스마트컨트랙트의 ByteCode를 Transaction에 실어 블록에 포함시킨 상태 (출처: https://lbm93.tistory.com/8)
hello_sol.sol이 위치한 폴더에 hello_sol.js 파일 생성, 다음과 같이 입력 (출처: https://velog.io/@wlgus2134 )

onst Web3 = require('web3')
let connection = new Web3('http://127.0.0.1:8545')

// abi파일에 있는 정보들을 JSON형식으로 변형해서 ABI_CODE변수에 담아줌
const ABI_CODE = JSON.parse('[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"get","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]');

// bin 파일에 있는 정보들을 ''으로 감싸서 BYTECODE 변수에 담아줌
// bin 파일에 있는 것을 복붙하세요. 
const BYTECODE = ' '

const contract = new connection.eth.Contract(ABI_CODE)

contract.deploy({
    data:BYTECODE
})

// from 안에 Ganache를 돌려서 얻었던 Available Accounts중 하나를 ''로 감싸서 입력
// Gas(수수료)는 Gas Limit에 입력되어있던 6721975로 설정
.send({
    from:'0x11eeC4232900708324D58ebca115566a02F59Ddd', // ganache-cli --host 0.0.0.0 입력 후 아무거나 선택
    gas:'6721975'
},(error,result)=>{
    console.log(error)
})
.then( data =>{
    console.log(data.options.address)
})

터미널 창을 열어 다음 명령어 입력
```
node hello_sol.js
```
로컬 virtual 지갑을 생성하고 있는 ganache cmd창을 확인해보면, 다음과 같이 sendTransaction 결과가 나와있다.

얼렁뚱땅 따라하긴했는데 100% 이해가 안된다...

파이썬이 엄청 편한 언어였구나...

[python/GIS] 세종시 생활권 별 최근린녹지공원까지의 평균거리 구하기 (geopandas, geojson, haversine)

anweh — Tue, 28 Dec 2021 14:21:56 +0900

오늘은 아주 예전에.. 데이터분석 경진대회에 사용했던 코드를 포스팅 하려고 한다.

사실 예전 코드를 다시 뜯어보는 것만큼 좋은 공부가 없는 것 같아, 요즘은 예전에 작성한 코드를 다시 읽어보고 있다.

물론 '왜 이렇게 비효율적으로 짠거지' 하는 부분도 있지만 '오, 진짜 기발하게 짰네'하는 부분도 있다.

어쨌든! 오늘 포스팅 할 내용은 세종시의 생활권 별 최근린 녹지공원까지의 평균 거리를 계산하는 코드다.

0. 필요 라이브러리

import os 
import geopandas as gpd
from tqdm import tqdm 
import haversine as hs
from haversine import Unit
import pandas as pd

이 테스크에 사용하는 라이브러리는 위와 같다.

이중 geopandas, haversine은 유명한 라이브러리가 아니기 때문에 짧은 설명을 덧붙이고 넘어가자면..

geopandas: 판다스의 gis버전이다. 데이터프레임 형태의 자료구조를 가지는데, 특이한 점은 지오메트리 정보도 저장할 수 있다는 점이다. geopandas는 설치 순서가 좀 까다롭다... (개열받음) shapely, fiona를 먼저 깔아줘야 하는데, 해당 라이브러리 설치 순서는 다음 블로그를 참고하면 된다. 나도 설치 순서 까먹어서 매번 이 블로그 참고함..ㅋㅋㅋㅋ (https://hansuho113.tistory.com/22)
haversine: 거리 계산에 사용하는 라이브러리

1. 데이터 로드

''' Data Load ''' 
data_path = os.path.join(os.getcwd(), 'data')
gdf_31 = gpd.read_file(os.path.join(data_path, '31.세종시_법정경계(읍면동).geojson'))
gdf_23 = gpd.read_file(os.path.join(data_path, '23.세종시_도로명주소_건물.geojson'))
park_gdf = gpd.read_file(os.path.join(data_path, 'TL_SPOT_PARK.shp'), encoding='euc-kr')

깃헙에 올려진 코드를 보면 알겠지만, 이 포스팅에 사용된 모든 데이터는 'data'라는 폴더 안에 정리해줬다.

지오메트리 정보를 포함하고 있는 데이터는 geopandas를 통해 불러왔다.

가끔 인코딩 정보를 명시해줘야 하는 데이터가 있다. (ex. park_gdf)

데이터에 대한 짧은 설명을 하고 넘어가자.

gdf_31: 세종시 법정동 geojson데이터
gdf_23: 세종시 내 건물 geojson데이터
park_gdf: 전국 근린녹지공원 geojson데이터

아래에서 보다시피, park_gdf는 전국 대상 데이터이다. 나중에 필터 작업이 필요하다.

자 이제 위 데이터들 안에는 어떤 정보가 담겨있는지 '내용'을 확인해보자.

gdf_23

gdf_31

park_gdf

각각의 데이터가 갖고 있는 정보는 당연히 다르겠지만 유독 눈에 띄는게 있다.

바로 '좌표계'이다.

geometry컬럼을 보면, 공원 데이터만 좌표계가 다르다.

거리 계산을 위해선 나중에 좌표계 통일 작업이 필요할 거란 예상을 할 수 있다.

데이터 확인은 이쯤 하면 됐고, 이제 전처리로 넘어가보자.

2. 데이터 전처리

'''
<전처리 1>
생활권에 해당하는 면폴리곤만 남기기
- gdf_31은 세종시 전체를 포함하고 있는 데이터이므로, 1~6생활권 폴리곤만 추출해야함 
'''
happy_city_gdf = gdf_31.loc[(gdf_31['EMD_KOR_NM'] == '집현동') | (gdf_31['EMD_KOR_NM'] == '반곡동') | (gdf_31['EMD_KOR_NM'] == '소담동') | (gdf_31['EMD_KOR_NM'] == '보람동') | 
                            (gdf_31['EMD_KOR_NM'] == '대평동') | (gdf_31['EMD_KOR_NM'] == '가람동') | (gdf_31['EMD_KOR_NM'] == '한솔동') | (gdf_31['EMD_KOR_NM'] == '새롬동') | (gdf_31['EMD_KOR_NM'] == '나성동') |
                            (gdf_31['EMD_KOR_NM'] == '다정동') | (gdf_31['EMD_KOR_NM'] == '어진동') | (gdf_31['EMD_KOR_NM'] == '종촌동') | (gdf_31['EMD_KOR_NM'] == '고운동') | (gdf_31['EMD_KOR_NM'] == '도담동') |
                            (gdf_31['EMD_KOR_NM'] == '아름동') | (gdf_31['EMD_KOR_NM'] == '해밀동') | (gdf_31['EMD_KOR_NM'] == '산울동') | (gdf_31['EMD_KOR_NM'] == '합강동')]

# r(region) 
r1 = ['고운동', '아름동', '종촌동', '도담동', '어진동'] # 1생활권
r2 = ['다정동', '새롬동', '한솔동', '나성동', '가람동'] # 2생활권
r3 = ['대평동', '보람동', '소담동'] # 3생활권
r4 = ['반곡동', '집현동'] # 4생활권
r5 = ['합강동'] # 5생활권
r6 = ['산울동', '해밀동'] # 6생활권 

rs = []
for i in range(len(happy_city_gdf)): 
    cur_emd_cd = happy_city_gdf.iloc[i]['EMD_CD']
    cur_emd_nm = happy_city_gdf.iloc[i]['EMD_KOR_NM']
    
    if cur_emd_nm in r1: 
        rs.append('1생활권')
    if cur_emd_nm in r2: 
        rs.append('2생활권')
    if cur_emd_nm in r3: 
        rs.append('3생활권')
    if cur_emd_nm in r4: 
        rs.append('4생활권')
    if cur_emd_nm in r5: 
        rs.append('5생활권')
    if cur_emd_nm in r6: 
        rs.append('6생활권')
happy_city_gdf['생활권'] = rs
rs.append('중앙녹지공원')




'''
<전처리 2>
생활권 별 건물 나누기
'''
gdf_23 = gdf_23.sample(frac=0.8).reset_index(drop=True) # 건물 개수가 너무 많아서 샘플링 했다. 

# 1생활권
gdf_23_1 = gdf_23.loc[(gdf_23['EMD_CD'] == '111') | (gdf_23['EMD_CD'] == '112') | (gdf_23['EMD_CD'] == '113') | (gdf_23['EMD_CD'] == '114') | (gdf_23['EMD_CD'] == '110')]

# 2생활권
gdf_23_2 = gdf_23.loc[(gdf_23['EMD_CD'] == '106') | (gdf_23['EMD_CD'] == '107') | (gdf_23['EMD_CD'] == '108') | (gdf_23['EMD_CD'] == '109') | (gdf_23['EMD_CD'] == '105')]

# 3생활권
gdf_23_3 = gdf_23.loc[(gdf_23['EMD_CD'] == '102') | (gdf_23['EMD_CD'] == '103') | (gdf_23['EMD_CD'] == '104')]

# 4생활권
gdf_23_4 = gdf_23.loc[(gdf_23['EMD_CD'] == '101') | (gdf_23['EMD_CD'] == '118')]

# 5생활권
gdf_23_5 = gdf_23.loc[(gdf_23['EMD_CD'] == '117')]

# 6생활권 
gdf_23_6 = gdf_23.loc[(gdf_23['EMD_CD'] == '115') | (gdf_23['EMD_CD'] == '116')]

<전처리 1, 2>

gdf_31, 23을 보면 알 수 있듯이 세종시 전체에 대한 면폴리곤, 빌딩 폴리곤을 포함하고 있다.

내가 관심 있는 지역은 세종시 중에서도 '행복도시'에 해당하는 1 ~ 6생활권의 지역이기 때문에,

관심 지역에만 해당하는 폴리곤을 추출하기 위해 전처리를 진행했다.

gdf_31은 EMD_KOR_NM이라는 컬럼을 통해 행복도시만 골라낼 수 있다.

gdf_23은 EMD_CD라는 컬럼을 통해 행복도시만 골라내었다.

생활권을 가만 보면, 4생활권부터는 법정동 개수가 1,2,3생활권에 비해 적은 것을 알 수 있다.

이는 세종시 행복도시의 입주가 1,2,3생활권은 거의 완료된 데에 비해, 4생활권부터는 아직 개발 단계이기 때문이다.

여담인데 행복도시의 주택 구매가 있는 사람은 6생활권 입주가 끝나기 전에 계획하는 것이 좋을듯.. 나는 항상 눈여겨 보고 있음

''' 
<전처리 3>
- 좌표계 통일 (5179 --> 4326)
- 세종시에 해당하는 녹지공간만 추출 
'''
park_gdf.set_crs(epsg=5179, inplace=True, allow_override=True)
park_gdff = park_gdf.loc[(park_gdf['SIG_CD'] == '36110')] # 세종시의 시군구코드는 36110 
park_gdff_ = park_gdff.to_crs(epsg=4326)

세 번째 전처리는 전국 녹지공원 데이터인 park_gdf이다.

우선 좌표계를 gdf_31, gdf_23과 동일하게 맞춰주고,

시군구코드 컬럼(SIG_CD)을 사용하여 세종시 녹지공원만 추출했다.

3. 공원까지 거리 계산

''' 
각 생활권 별로 ‘집에서’ 녹지공간까지의 접근성이 동일한가? -- happy_city_park, happy_city_park_dong
'''
print('각 생활권 별로 ‘집에서’ 녹지공간까지의 접근성이 동일한가? -- happy_city_park \n')

def assign_dong_value(dictionary, df_dong, attr): 
    
    df_dong[attr] = ''
    for i in range(len(df_dong)):
        cur_dong_nm = df_dong.iloc[i]['EMD_NM']
        
        for k, v in dictionary.items(): 
            if k == cur_dong_nm : 
                df_dong.at[i, attr] = v
                
    return df_dong

def calculate_dist_to_park(gdf, park_gdff_): 
    
    bldg_2_park = []
    
    for i in tqdm(range(len(gdf))):
        # 해당 gdf(동)내 모든 빌딩에 대하여 중심점을 구함
        cur_bldg_coord_x = gdf.iloc[i]['geometry'].centroid.xy[0][0]
        cur_bldg_coord_y = gdf.iloc[i]['geometry'].centroid.xy[1][0] 
        
        park_dist_ls  = []
        min_d = 9999
        for j in range(len(park_gdff_)): 
            # 세종시 내 모든 녹지공원의 중심점을 구함 
            cur_park_x = park_gdff_.iloc[j]['geometry'].centroid.xy[0][0]
            cur_park_y = park_gdff_.iloc[j]['geometry'].centroid.xy[1][0] 
            
            meter_dist = hs.haversine((cur_park_y, cur_park_x), 
                                      (cur_bldg_coord_y, cur_bldg_coord_x), 
                                      unit=Unit.METERS)
            
            if (meter_dist/1000.0) < 5: 
                polygon_type = park_gdff_.iloc[j]['geometry'].type
                
                # park_gdf의 폴리곤이 두 종류로 이루어져 있어, 종류에 따라 다른 계산법을 적용해야함 
                if polygon_type == 'MultiPolygon': 
                    for q in range(len(list(park_gdff_.iloc[j]['geometry']))):
                        polys = list(park_gdff_.iloc[j]['geometry'])
                        polyy = polys[q]
                        polyy_crd_length = len(polyy.exterior.coords)     
                        
                        for mc in range(polyy_crd_length):
                            ex_x = polyy.exterior.coords.xy[0][mc]
                            ex_y = polyy.exterior.coords.xy[1][mc]
                            
                            dist1 = hs.haversine((ex_y, ex_x), (cur_bldg_coord_y, cur_bldg_coord_x), unit=Unit.METERS)
                            if dist1 < min_d: 
                                min_d = dist1
                        park_dist_ls.append(min_d)
                            
                if polygon_type == 'Polygon':
                    simple_polygon = park_gdff_.iloc[j]['geometry'].simplify(0.05)
                    for c in range(len(simple_polygon.exterior.coords.xy[0])):
                
                        ex_xx = simple_polygon.exterior.coords.xy[0][c]
                        ex_yy = simple_polygon.exterior.coords.xy[1][c]
                
                        dist2 = hs.haversine((ex_yy, ex_xx), (cur_bldg_coord_y, cur_bldg_coord_x), unit=Unit.METERS)
                    
                        if dist2 < min_d: 
                            min_d = dist2
                    park_dist_ls.append(min_d)
                        
            else:       
                park_dist_ls.append(min_d)
                
        bldg_2_park.append(min(park_dist_ls))
    
    return bldg_2_park

def find_dong_nm(gdf, happy_city_gdf):
    
    gdf['DONG_NM'] = ''
    
    for i in range(len(gdf)):
        cur_apt_poly = gdf.iloc[i]['geometry']
        
        if cur_apt_poly == None : 
            continue 
        
        cur_apt_centroid = cur_apt_poly[0].centroid 

        
        for j in range(len(happy_city_gdf)):
            cur_dong_poly = happy_city_gdf.iloc[j]['geometry'][0]
            cur_dong_nm = happy_city_gdf.iloc[j]['EMD_KOR_NM']
            
            if cur_dong_poly.contains(cur_apt_centroid): 
                gdf.at[i, 'DONG_NM'] = cur_dong_nm

    
    return gdf 

            

bldg_2_park_gdf_23_1 = calculate_dist_to_park(gdf_23_1, park_gdff_)
gdf_23_1 = gdf_23_1.reset_index()
gdf_23_1 = gdf_23_1.drop(['index'], axis=1)
gdf_23_1 = find_dong_nm(gdf_23_1, happy_city_gdf)
gdf_23_1['최근린녹지거리'] = bldg_2_park_gdf_23_1

bldg_2_park_gdf_23_2 = calculate_dist_to_park(gdf_23_2, park_gdff_)
gdf_23_2 = gdf_23_2.reset_index()
gdf_23_2 = gdf_23_2.drop(['index'], axis=1)
gdf_23_2 = find_dong_nm(gdf_23_2, happy_city_gdf)
gdf_23_2['최근린녹지거리'] = bldg_2_park_gdf_23_2

bldg_2_park_gdf_23_3 = calculate_dist_to_park(gdf_23_3, park_gdff_)
gdf_23_3 = gdf_23_3.reset_index()
gdf_23_3 = gdf_23_3.drop(['index'], axis=1)
gdf_23_3 = find_dong_nm(gdf_23_3, happy_city_gdf)
gdf_23_3['최근린녹지거리'] = bldg_2_park_gdf_23_3

bldg_2_park_gdf_23_4 = calculate_dist_to_park(gdf_23_4, park_gdff_)
gdf_23_4 = gdf_23_4.reset_index()
gdf_23_4 = gdf_23_4.drop(['index'], axis=1)
gdf_23_4 = find_dong_nm(gdf_23_4, happy_city_gdf)
for i in range(len(gdf_23_4)):
    cur_ = gdf_23_4.iloc[i]['EMD_CD']
    if cur_ == '101': 
        gdf_23_4.at[i, 'DONG_NM'] = '반곡동'
gdf_23_4['최근린녹지거리'] = bldg_2_park_gdf_23_4

bldg_2_park_gdf_23_5 = calculate_dist_to_park(gdf_23_5, park_gdff_)
gdf_23_5 = gdf_23_5.reset_index()
gdf_23_5 = gdf_23_5.drop(['index'], axis=1)
gdf_23_5 = find_dong_nm(gdf_23_5, happy_city_gdf)
gdf_23_5['최근린녹지거리'] = bldg_2_park_gdf_23_5

bldg_2_park_gdf_23_6 = calculate_dist_to_park(gdf_23_6, park_gdff_)
gdf_23_6 = gdf_23_6.reset_index()
gdf_23_6 = gdf_23_6.drop(['index'], axis=1)
gdf_23_6 = find_dong_nm(gdf_23_6, happy_city_gdf)
gdf_23_6['최근린녹지거리'] = bldg_2_park_gdf_23_6
    
happy_city_park = {'1생활권': gdf_23_1['최근린녹지거리'].sum()/len(gdf_23_1), 
                   '2생활권': gdf_23_2['최근린녹지거리'].sum()/len(gdf_23_2),
                   '3생활권': gdf_23_3['최근린녹지거리'].sum()/len(gdf_23_3),
                   '4생활권': gdf_23_4['최근린녹지거리'].sum()/len(gdf_23_4),
                   '5생활권': gdf_23_5['최근린녹지거리'].sum()/len(gdf_23_5),
                   '6생활권': gdf_23_6['최근린녹지거리'].sum()/len(gdf_23_6)}
    
happy_city_park_dong = {'고운동': gdf_23_1.loc[gdf_23_1['DONG_NM']=='고운동']['최근린녹지거리'].sum()/len(gdf_23_1[gdf_23_1['DONG_NM']=='고운동']), 
                        '아름동': gdf_23_1.loc[gdf_23_1['DONG_NM']=='아름동']['최근린녹지거리'].sum()/len(gdf_23_1[gdf_23_1['DONG_NM']=='아름동']),
                        '종촌동': gdf_23_1.loc[gdf_23_1['DONG_NM']=='종촌동']['최근린녹지거리'].sum()/len(gdf_23_1[gdf_23_1['DONG_NM']=='종촌동']),
                        '도담동': gdf_23_1.loc[gdf_23_1['DONG_NM']=='도담동']['최근린녹지거리'].sum()/len(gdf_23_1[gdf_23_1['DONG_NM']=='도담동']),
                        '어진동': gdf_23_1.loc[gdf_23_1['DONG_NM']=='고운동']['최근린녹지거리'].sum()/len(gdf_23_1[gdf_23_1['DONG_NM']=='어진동']),
                        '다정동': gdf_23_2.loc[gdf_23_2['DONG_NM']=='다정동']['최근린녹지거리'].sum()/len(gdf_23_2[gdf_23_2['DONG_NM']=='다정동']),
                        '새롬동': gdf_23_2.loc[gdf_23_2['DONG_NM']=='새롬동']['최근린녹지거리'].sum()/len(gdf_23_2[gdf_23_2['DONG_NM']=='새롬동']),
                        '한솔동': gdf_23_2.loc[gdf_23_2['DONG_NM']=='한솔동']['최근린녹지거리'].sum()/len(gdf_23_2[gdf_23_2['DONG_NM']=='한솔동']),
                        '나성동': gdf_23_2.loc[gdf_23_2['DONG_NM']=='나성동']['최근린녹지거리'].sum()/len(gdf_23_2[gdf_23_2['DONG_NM']=='나성동']),
                        '가람동': gdf_23_2.loc[gdf_23_2['DONG_NM']=='가람동']['최근린녹지거리'].sum()/len(gdf_23_2[gdf_23_2['DONG_NM']=='가람동']),
                        '대평동': gdf_23_3.loc[gdf_23_3['DONG_NM']=='대평동']['최근린녹지거리'].sum()/len(gdf_23_3[gdf_23_3['DONG_NM']=='대평동']),
                        '보람동': gdf_23_3.loc[gdf_23_3['DONG_NM']=='보람동']['최근린녹지거리'].sum()/len(gdf_23_3[gdf_23_3['DONG_NM']=='보람동']),
                        '소담동': gdf_23_3.loc[gdf_23_3['DONG_NM']=='소담동']['최근린녹지거리'].sum()/len(gdf_23_3[gdf_23_3['DONG_NM']=='소담동']),
                        '반곡동': gdf_23_4.loc[gdf_23_4['DONG_NM']=='반곡동']['최근린녹지거리'].sum()/len(gdf_23_4[gdf_23_4['DONG_NM']=='반곡동']),
                        '집현동': gdf_23_4.loc[gdf_23_4['DONG_NM']=='집현동']['최근린녹지거리'].sum()/len(gdf_23_4[gdf_23_4['DONG_NM']=='집현동']),
                        '합강동': gdf_23_5.loc[gdf_23_5['DONG_NM']=='합강동']['최근린녹지거리'].sum()/len(gdf_23_5[gdf_23_5['DONG_NM']=='합강동']),
                        '산울동': gdf_23_6.loc[gdf_23_6['DONG_NM']=='산울동']['최근린녹지거리'].sum()/len(gdf_23_6[gdf_23_6['DONG_NM']=='산울동']),
                        '해밀동': gdf_23_6.loc[gdf_23_6['DONG_NM']=='해밀동']['최근린녹지거리'].sum()/len(gdf_23_6[gdf_23_6['DONG_NM']=='해밀동'])}    
                  
dong_dict = {'고운동': [0, 0], '아름동': [0, 0], '종촌동': [0, 0], '도담동': [0, 0], '어진동': [0, 0], '다정동': [0, 0],
             '새롬동': [0, 0], '한솔동': [0, 0], '나성동': [0, 0], '가람동': [0, 0], '대평동': [0, 0], '보람동': [0, 0],
             '소담동': [0, 0], '반곡동': [0, 0], '집현동': [0, 0], '합강동': [0, 0], '산울동': [0, 0], '해밀동': [0, 0]}

df_dong = pd.DataFrame(dong_dict.keys(), columns=['EMD_NM'])                                                     
df_dong = assign_dong_value(happy_city_park_dong, df_dong, '최근린녹지까지의평균거리')

거리 계산 프로세스를 정의하자면,

1. gdf_23_1 ~ gdf_23_6에 대하여 (행복도시의 각 생활권에 대하여)
2. 각 생활권 내 모든 주거용 건물의 중심점(cur_bldg_coord_x, cur_bldg_coord_y)으로부터
최근린 녹지공원 중심점(cur_park_x, cur_park_y)을 찾는다.
3. 최근린 녹지공원 폴리곤의 바운더리 포인트 중, 주거용 건물에서 가장 가까운 포인트(ex_x, ex_y)를 찾는다.
4. 거리(dist1, dist2)를 계산하여 bldg_2_park에 저장한다.
5. bldg_2_park에 저장된 거리를 모두 합하여, 해당 생활권 내 주거용 건물의 개수로 나누어 '평균'을 구한다.
6. 각 생활권을 동(df_dong)으로 분류하여 정리한다.

실행 결과:

4. FYI

사실 아주 예전에 짜뒀던 코드라 그리 깔끔하지 못하다. (데이터가 엉망인 탓도 있다.)

코드와 데이터는 모두 깃헙에 업로드 하였으니, 직접 다운 받아 디버깅 하며 스텝바이스텝 따라가 보는 편이 가장 이해가 빠를 것 같다!

https://github.com/henewsuh/sejong_find_near_park

GitHub - henewsuh/sejong_find_near_park: first_commit

first_commit. Contribute to henewsuh/sejong_find_near_park development by creating an account on GitHub.

github.com

Water Cherry House

anweh — Mon, 27 Dec 2021 17:30:10 +0900

0123456789

건축가: Kengo Kuma

Location: Tokyo, Japan

[python] libpng warning: iCCP: known incorrect sRGB profile 문제 해결

anweh — Mon, 13 Dec 2021 18:23:08 +0900

0. ImageMagick 다운로드

http://www.imagemagick.org/script/download.php#windows

ImageMagick

Create, Edit, Compose, or Convert Digital Images

imagemagick.org

imagemagick 이라는 이미지 파일 편집기 프로그램을 다운로드하고, exe 파일을 실행시켜 install을 진행한다.

사이트가 좀 구려서, 뭔가 찜찜했지만 별 문제(?)는 없었다.

이때 다음 박스에 꼭 체크하고 넘어간다.

저는 이거 땜에 1시간 삽질함.

1. CMD 창에서 문제가 있는 png 폴더로 이동

반드시 문제가 발생한 이미지가 있는 폴더로 이동한 후에 다음 명령어를 입력해야 한다.

이동하고 다음 명령어를 쳐주자.

> mogrify *.png

끝.

아오... install legacy utilities 하나 체크 안해서 한시간 헤맸다.

80개 파일을 모두 고쳐줬는데, 1분 정도 걸린다.

[python] STL to VTK / VTK to STL

anweh — Mon, 13 Dec 2021 10:25:14 +0900

3D 데이터 타입 중 STL과 VTK 타입간 파일 포맷 변경에 대해 포스팅 해보겠습니다.

간단하게 두 포맷의 차이를 설명하자면,

STL: 3D 데이터의 기하 정보를 담고 있음
VTK: 기하 정보 뿐만 아니라, 사용자가 원한다면 속성 정보 또한 추가할 수 있음

어쨌든 이 두 포맷간 변환은 pyvista라는 모듈을 사용하여 진행할 수 있다.

0. pyvista 모듈 다운로드

다운로드 링크: https://docs.pyvista.org/

PyVista — PyVista 0.32.0 documentation

3D plotting and mesh analysis through a streamlined interface for the Visualization Toolkit (VTK) PyVista is… “VTK for humans”: a high-level API to the Visualization Toolkit (VTK) mesh data structures and filtering methods for spatial datasets 3D plo

docs.pyvista.org

pyvista는 3D 데이터를 다루다보면 저어어엉말 자주 마주치게 되고, 매우 유용하게 사용할 수 있는 라이브러리다.

데이터 다룰 때 유용한 것 뿐만 아니라, 시각화에도 아주 특화되어 있는 라이브러리이다.

1. 코드 설명

import os 
import pyvista as pv 

def vtk2stl(path, fname):
    vtk_f = pv.read(os.path.join(path, fname))
    pv.save_meshio(fname[:-4] + '.stl', vtk_f)
    print(fname + ' is changed to STL !')

def stl2vtk(path, fname): 
    stl_f = pv.read(os.path.join(path, fname))
    pv.save_meshio(fname[:-4] + '.vtk', stl_f)
    print(fname + ' is changed to VTK !')
    

# stl to vtk
path = os.getcwd()
fname = 'bunny.stl'
stl2vtk(path, fname)

코드는 별 거 없다.

pv.read( )로 vtk, stl 파일 둘 다 불러올 수 있고,

불러온 파일을 기존 suffix를 제거하고, 고대로 pv.save_meshio( )를 사용하여 원하는 포맷으로 저장해주면 된다.

이렇게 두가지 파일 변환 함수를 생성하여 (stl2vtk, vtk2stl) 그때 그때 호출하여 사용하면 편하다.

2. 깃헙 링크

코드와 샘플 데이터를 사용하여 바로 실험할 수 있게 깃헙에 업로드 해두었으니 참고 바람!

https://github.com/henewsuh/convert_stl_vtk

GitHub - henewsuh/convert_stl_vtk: convert between stl and vtk

convert between stl and vtk. Contribute to henewsuh/convert_stl_vtk development by creating an account on GitHub.

github.com

[알고리즘] 병합 정렬

anweh — Sun, 22 Aug 2021 17:03:37 +0900

* <모두의 알고리즘 with 파이썬>의 문제 10을 정리한 내용입니다.

출처: https://zeddios.tistory.com/38

1. 병합 정렬이란?

입력을 두 개로 분리하고 각각 해결한 다음, 이 결과를 모아서 원래의 문제를 해결하는 전략이다.
대개 재귀 호출을 이용하여 구현한다.
일반적으로 다음과 같은 과정을 거친다.
- 분할: 입력 데이터를 2개로 분할한다. 이때, 파이썬에서는 // 연산자를 사용한다.
- 정복: 부분 데이터를 정렬한다.
- 결합: 정렬된 부분 배열을 다시 하나의 배열에 합병한다.

아래 그림에서 [6, 5, 12, 10, 9, 1]이 입력 배열이라고 했을 때, 가장 먼저 [6, 5, 12] 와 [10, 9, 1]로 분리한다.
[6, 5, 12]는 [6]과 [5, 12]로 분리하고, [10, 9, 1]은 [10]과 [9, 1]로 분리한다. 더 쪼갤 수 있는가?
[5, 12]는 [5] 와 [12]로 분리하고, [9, 1]은 [9] 와 [1]로 분리한다. 이제 정렬을 시작한다.
[5]와 [12]를 순서대로 정렬하여 [5, 12]를 반환하고, [9]와 [1]도 정렬하여 [1, 9]를 반환한다.
[6]과 [5, 12]를 정렬할 때, 맨 앞자리를 비교한다. 왜? 이미 정렬이 된 배열이기 때문에 맨 앞자리가 해당 배열에서 가장 작은 수이기 때문이다. 정렬하면 [5, 6, 12]가 된다. 마찬가지 방법으로 [1, 9, 10]이 정렬되었다.
- 이 부분에서 해당 알고리즘의 효율성을 엿볼 수 있다. 어차피 이미 정렬해서 올라온 배열이기 때문에, 뒤에 있는 수는 상관없이 맨 앞자리 수만 비교하면 된다.
두 개의 배열 [5, 6, 12]와 [1, 9, 10]을 병합 정렬한다. 맨 앞자리 수를 비교하여 pop으로 result값에 넣어준다.

2. 병합 정렬의 시간 복잡도

병합 정렬의 시간 복잡도는 O(nlogn)로 선택 정렬이나 삽입 정렬의 계산 복잡도 O(n^2)보다 낮다.
최악의 경우에도 O(nlogn) 시간 복잡도를 가진다.

3. 일반적인 병합 정렬 알고리즘

def merge_sort(a):
    n = len(a)
    
    print("a: {}".format(a))
    if n <= 1: 
        return a
    
    mid = n // 2
    g1 = merge_sort(a[:mid])
    g2 = merge_sort(a[mid:])
    print("g1: {}".format(g1))
    print("g2: {}".format(g2))
    
    result = [] 
    
    while g1 and g2 : 
        if g1[0] <  g2[0]: 
            result.append(g1.pop(0))
        else: 
            result.append(g2.pop(0))
        print('first while: {}'.format(result))
        
    while g1: 
        result.append(g1.pop(0))
        print('second while: {}'.format(result))
    while g2: 
        result.append(g2.pop(0))
        print('thrid while: {}'.format(result))
    
    
    return result 

d = [6, 8, 3, 9, 10, 1, 2, 4, 7, 5]
print(merge_sort(d))

오름차순 정렬을 큰 수에서 작은 수 순서대로 나열하는 내림차순 정렬로 바꾸려면 프로그램의 어느 부분을 바꿔야 할까요?
- 첫 번째 while 문의 첫 번째 if문을 수정하였다. (if g1[0] < g2[0]: --> if g1[0] > g2[0]: )

[알고리즘] 삽입 정렬

anweh — Sun, 15 Aug 2021 16:12:41 +0900

* <모두의 알고리즘 with 파이썬>의 문제 09를 정리한 내용입니다.

1. 삽입 정렬이란?

자신보다 앞의 원소가 큰지 작은지 확인하여 자신의 위치를 찾아 '삽입'하는 알고리즘이다.
정렬되어 있는 경우는 비교를 하지 않기 때문에 버블 정렬과 달리 불필요한 비교가 줄어들었다.

2. 일반적인 삽입 정렬 알고리즘

def ins_sort(a):
    n = len(a)
    for i in range(1, n):  # 앞 원소와 비교해야하기 때문에 가장 앞 원소는 무시한다
        key = a[i] # 기준 원소
        j = i - 1 # 바로 하나 앞 원소
        
        while j >=0 and a[j] > key: # 앞 원소가 나보다 클 경우만 위치 변경
            a[j+1] = a[j] # a[j+1]는 기준 원소
            j -= 1 # 한 칸씩 앞으로 전진하며 비교 
        
        a[j+1] = key  # 삽입할 위치
    return a 

d = [2, 4, 5, 1, 3]
print(ins_sort(d))

3. 위의 알고리즘은 오름차순 정렬이었습니다. 이를 큰 수에서 작은 수 순서로 나열하는 내림차순 정렬로 바꾸려면 프로그램의 어느 부분을 바꿔야 할까요?

def ins_sort(a):
    n = len(a)
    for i in range(1, n):  # 앞 원소와 비교해야하기 때문에 가장 앞 원소는 무시한다
        key = a[i] # 기준 원소
        j = i - 1 # 바로 하나 앞 원소
        
        while j >=0 and a[j] < key: # 앞 원소가 나보다 작을 경우만 위치 변경
            a[j+1] = a[j] # a[j+1]는 기준 원소
            j -= 1 # 한 칸씩 앞으로 전진하며 비교 
        
        a[j+1] = key  # 삽입할 위치
    return a 

d = [2, 4, 5, 1, 3]
print(ins_sort(d))

while문의 조건을 수정해주었다. 기존 while문은 앞 원소가 나보다 클 경우에만 앞으로 옮겼다. 알고리즘 정의를 내림차순으로 바꾼다면, 앞 원소가 나보다 작을 경우에만 기준 원소를 앞으로 옮기면 된다.

FM House

anweh — Sun, 1 Aug 2021 18:46:25 +0900

0123456789

Location: Argentina

Architects: alarciaferrer arquitectos