도구의인간 메이커스 위키 - 새 문서 목록 [ko]

Python http requests module

2019-09-15T05:30:13Z

Doguin: 새 문서: # HTTP request in Python : requests module python의 requests 모듈을 사용해 REST 프로토콜을 쉽게 다룰 수 있다. 너무 널리사용되는, 사실상의 파이선 내...

# HTTP request in Python : requests module
python의 requests 모듈을 사용해 REST 프로토콜을 쉽게 다룰 수 있다. 너무 널리사용되는, 사실상의 파이선 내장모듈이라고 볼 수 있다.
참고: https://realpython.com/api-integration-in-python/
공식문서: https://2.python-requests.org/en/master/

## 설치
```bash
$ pip install requests
```
* 아마도 대부분의 경우 기본으로 설치되어있음

## 기본 사용법
### basic get
get(), post(), put() 메소드를 가지고 있고 서버의 응답이 이들 메소드의 리턴이 된다. 심플하다.

```python
import requests

URL = ''https://todolist.example.com/tasks/''
resp = requests.get(URL)
if resp.status_code == 200: # OK
for item in resp.json():
print(item)
else : # something wrong
raise ApiError(resp.status_code)
```
* resp.json()의 리턴은 파이썬 오브젝트다 일반 딕셔너리나 리스트처럼 간편하게 다룰 수 있다.
* raw data를 그대로 보려면 'resp.text' 프로퍼티를 사용하면 된다.

### parameter 전달
get() 메소드에 'params=' 아규먼트를 추가해 보낸다

```python
params = {'key':'value'}
res = requests.get('http://www.tistoty.com', params=params)
print(res.url)
# http:./www.tistody.com/?key=value
```

### header 전달
get(), post() 메소드에 'headers=' 아규먼트를 추가해 보낸다.

### data 전달
post() 메소드에 'data=' 아규먼트를 추가해 보낸다.

```python
body = {"key1": "value1", "key2": "value2" }
resp = requests.post(URL,
data=json.dumps(body),
headers={'Content-Type':'application/json'},
)
```
혹은 'data=' 대신에 'json='아규먼트를 사용하면 requests가 알아서 딕셔너리를 json으로 바꾸어준다. 아래 예는 위 코드와 동일하다.

```python
resp = requests.post(URL,json=body)
```

GPS module neo-6m

2019-09-15T04:37:56Z

Doguin: 새 문서: # GPS + raspberry pi ## gps module Neo-6m gps 모듈을 사용한다. 대부분의 gps 모듈이 serial UART 통신을 사용한다. 참고자료가 많은 쪽이 좋으므로 시...

# GPS + raspberry pi

## gps module
Neo-6m gps 모듈을 사용한다.
대부분의 gps 모듈이 serial UART 통신을 사용한다. 참고자료가 많은 쪽이 좋으므로 시리얼 통신방식 부품을 고른다.
 ![||600](https://www.makerlab-electronics.com/my_uploads/2017/06/GPS-Module-01.jpg)

 5Hz position update rate
 EEPROM to save configuration settings
 Rechargeable battery for Backup
 The cold start time of 38 s and Hot start time of 1 s
 Configurable from 4800 Baud to 115200 Baud rates. (default 9600)
 SuperSense ® Indoor GPS: -162 dBm tracking sensitivity
 Support SBAS (WAAS, EGNOS, MSAS, GAGAN)
 Separated 18X18mm GPS antenna
 Supply voltage: 3.3 V

## 회로 구성
라즈베리의 8번째, 10번째 핀이 시리얼 통신용이다.
 ![||600](https://cdn.instructables.com/FP7/CQBO/ICJLZ1TL/FP7CQBOICJLZ1TL.LARGE.jpg?auto=webp&frame=1&width=664&fit=bounds)

 ![||600](https://cl.ly/49839d/Image%202019-08-30%20at%204.54.46%20PM.png)

## 라즈베리파이 시리얼 포트 설정
참고: http://lhdangerous.godohosting.com/wiki/index.php/%EB%9D%BC%EC%A6%88%EB%B2%A0%EB%A6%AC%ED%8C%8C%EC%9D%B4_%EC%8B%9C%EB%A6%AC%EC%96%BC_%ED%86%B5%EC%8B%A0_%EC%84%A4%EC%A0%95_(setting_up_Raspberry_pi_serial_connection_via_GPIO)

## GPS FIX
* gps에서 사용되는 중요한 개념중에 FIX라는 것이 있다.
디바이스를 부팅하고나서도 위성으로부터 전파를 받아 디바이스의 위치를 계산할 수 았으려면 조금 시간이 걸리는데, 이렇게 충분한 데이터를 모아 자신의 위치를 계산할 수 있게되면 fix되었다라고 이야기한다. 더 구체적인 내용은 공부를 더 해보자.

* neo-6m gps는 유난히 fix 하는데 시간이 오래 걸리는 듯 하다. 위성 신호가 잘 잡혀도 길게는 10분정도 걸리는 경우가 있다.

## NMEA 프로토콜
gps 통신 표준을 관리하는 곳은 재미있게도 NMEA, 'National Marine Electronics Association' 해양전자협회? 이다. 그래서 gps표준 프로토콜 이름도 'NMEA-0183' 이다.
잘 정리된 한글자료: https://techlog.gurucat.net/239 [하얀쿠아의 이것저것 만들기 Blog]
nmea 표준 레퍼런스: https://www.sparkfun.com/datasheets/GPS/NMEA%20Reference%20Manual-Rev2.1-Dec07.pdf

NMEA 데이터 형태
``` $GPGGA,141113.999,3730.0308,N,12655.2369,E,1,06,1.7,98.9,M,,,,0000*3E

$GPGSA,A,3,02,07,01,20,04,13,,,,,,,3.7,1.7,3.2*31

$GPRMC,141113.999,A,3730.0308,N,12655.2369,E,19.77,195.23,101200,,*3C

$GPGGA,141114.999,3730.0264,N,12655.2351,E,1,07,1.2,98.8,M,,,,0000*3C

$GPGSA,A,3,02,07,01,20,24,04,13,,,,,,2.3,1.2,1.9*3E

$GPRMC,141114.999,A,3730.0264,N,12655.2351,E,15.51,202.12,101200,,*3C

$GPGGA,141115.999,3730.0231,N,12655.2345,E,1,07,1.2,98.7,M,,,,0000*37

$GPGSA,A,3,02,07,01,20,24,04,13,,,,,,2.3,1.2,1.9*3E

$GPGSV,2,1,07,07,84,025,47,04,51,289,48,20,40,048,47,02,32,203,46*74

$GPGSV,2,2,07,01,23,101,47,13,20,131,32,24,19,268,40*49

$GPRMC,141115.999,A,3730.0231,N,12655.2345,E,12.14,194.75,101200,,*33

$GPGGA,141116.999,3730.0210,N,12655.2330,E,1,07,1.2,98.5,M,,,,0000*37

$GPGSA,A,3,02,07,01,20,24,04,13,,,,,,2.3,1.2,1.9*3E

$GPRMC,141116.999,A,3730.0210,N,12655.2330,E,8.01,194.65,101200,,*0F

$GPGGA,141117.998,3730.0199,N,12655.2320,E,1,06,1.3,98.2,M,,,,0000*33

$GPGSA,A,3,02,07,01,20,24,04,,,,,,,2.4,1.3,2.0*30
```
* $ : 각 문장의 시작
* \n (CR/LF) : 각 문장의 끝
* sentence id : $다음에 오는 다섯 글자로,디바이스 종류를 밝히는두자(예를들어 GP) 와 이어지는 데이터 종류를 밝히는 3글자(예를들어 GGA)로 구성됨.
* 데이터: 콤마로 구분된 데이터들은 앞의 sentence id에 따라 해석하게 된다.
가장 기본적인 몇가지만 읽는 방법을 알아보자
### GPGGA
GPGGA는 'Global Positioning System Fix Data'를 의미한다. 아래의 GPGGA 예제 sentence를 살펴보자.

GPGGA는 총 17개의 field를 가진다.
 ![||600](https://cl.ly/de0df9/Image%202019-09-04%20at%203.10.19%20PM.png)
 ![||600](https://cl.ly/69bb04/Image%202019-09-04%20at%203.10.36%20PM.png)

### GPRMC
GPRMC는 'Recommended Minimum Specific GNSS Data'로 정의되어있다.
NMEA에는 GPS에서 필수적인 PVT(Position, Velocity, Time) 데이터의 고유한 버전이 있다.
그것을 RMC라고 부른다. 'RMC'에서 RM이 Recommended Minimum의 약자이고, C는 GNSS를 의미한다. RMA, RMB도 있으며 각각 LORAN-C와 Navigation을 의미한다. 상식으로 알아두자.
 ![||600](https://cl.ly/fc6b5f/Image%202019-09-04%20at%203.11.51%20PM.png)
 ![||600](https://cl.ly/f09f14/Image%202019-09-04%20at%203.12.04%20PM.png)

### GPGSV
GSV는 'GNSS Satellite in View' 를 의미한다. 각각 위성의 상태에 대해 나와있는 문장이다.
 ![||600](https://cl.ly/50a166/Image%202019-09-04%20at%203.13.52%20PM.png)

### checksum
NMEA checksum 계산방법 및 예제코드
지금까지 예제로 보여준 NMEA sentence들을 살펴보면 알겠지만, checksum은 * 뒤에 16진수 두자리로 표시한다.

checksum의 계산은 $, * 의 사이에 있는 각 문자를 exclusive-or (XOR) 연산한 값을 표시한다.

어떤 NMEA sentence가 주어지면, * 뒤에 있는 16진수 두자리의 checksum과 직접 XOR연산한 값이 일치하는지를 검사해야 한다. 일치하지 않는다면, 그 sentence는 통신상의 문제 등의 이유로, 결함이 있는 것으로 간주해야 하며, 사용하면 안된다.
예를 들어보자.

>$GPRMC,155123.000,A,4043.8432,N,07359.7653,W,0.15,83.25,200407,,\*28

이와 같은 NMEA sentence가 주어졌을때, checksum계산을 위한 XOR연산은 아래 각 문자들에 대해서 수행하면 된다.

>GPRMC,155123.000,A,4043.8432,N,07359.7653,W,0.15,83.25,200407,,

## python 에서 NMEA 데이터 사용 예제
### manually
참고: http://ozzmaker.com/using-python-with-a-gps-receiver-on-a-raspberry-pi/

```python
import serial

port = "/dev/serial0"

def parseGPS(data):
# print "raw:", data #prints raw data
if data[0:6] == "$GPRMC":
sdata = data.split(",")
if sdata[2] == 'V':
print "no satellite data available"
return
print "---Parsing GPRMC---",
time = sdata[1][0:2] + ":" + sdata[1][2:4] + ":" + sdata[1][4:6]
lat = decode(sdata[3]) #latitude
dirLat = sdata[4] #latitude direction N/S
lon = decode(sdata[5]) #longitute
dirLon = sdata[6] #longitude direction E/W
speed = sdata[7] #Speed in knots
trCourse = sdata[8] #True course
date = sdata[9][0:2] + "/" + sdata[9][2:4] + "/" + sdata[9][4:6]#date

print "time : %s, latitude : %s(%s), longitude : %s(%s), speed : %s, True Course : %s, Date : %s" % (time,lat,dirLat,lon,dirLon,speed,trCourse,date)

def decode(coord):
#Converts DDDMM.MMMMM > DD deg MM.MMMMM min
x = coord.split(".")
head = x[0]
tail = x[1]
deg = head[0:-2]
min = head[-2:]
return deg + " deg " + min + "." + tail + " min"

print "Receiving GPS data"
ser = serial.Serial(port, baudrate = 9600, timeout = 0.5)
while True:
data = ser.readline()
parseGPS(data)
```

### pynmea2 library 사용
NMEA 데이터 파싱을 도와주는 pynmea2 라이브러리를 사용할 수 있다.
* 라이브러리 설치
```bash
$ pip install pynmea2
```
* 예제

```python
import serial
import pynmea2

port = "/dev/serial0"

def parseGPS(str):
if str.find('GGA') > 0:
msg = pynmea2.parse(str)
print "Timestamp: %s -- Lat: %s %s -- Lon: %s %s -- Altitude: %s %s -- Satellites: %s" % (msg.timestamp,msg.lat,msg.lat_dir,msg.lon,msg.lon_dir,msg.altitude,msg.altitude_units,msg.num_sats)

serialPort = serial.Serial(port, baudrate = 9600, timeout = 0.5)
while True:
str = serialPort.readline()
parseGPS(str)
```

## GPSD
gpsd 는 GPS daemon의 약자로, 백그라운드에서 동작하면서 gps 사용을 도와주는 프로그램이다. 시리얼포트에서 들어오는 로데이터를 바로 사용할 수도 있지만, gpsd과, 이와 연계된 라이브러리를 사용하면 더 쉽게 gps가 제공하는 정보를 활용할 수 있다.
Adafruit 참고자료: https://learn.adafruit.com/adafruit-ultimate-gps-hat-for-raspberry-pi/use-gpsd
gpsd 공식문서:https://gpsd.gitlab.io/gpsd/index.html

### gpsd 와 파이썬 라이브러리 설치
```bash
$ sudo apt-get update
$ sudo apt-get install gpsd gpsd-clients python-gps
```

### 라즈비안의 디폴트 서비스 제거
라즈비안에서는 라즈베리파이에 USB를 통해 외부 gps장치를 연결이 감지되면 gpsd가 실행되도록하는 systemd 서비스가 기본 켜져있다. 이 부분이 간섭일으키므로 disable 시킨다.
```bash
$ sudo systemctl stop gpsd.socket
$ sudo systemctl disable gpsd.socket
```
#### 부팅시 gpsd 자동으로 시작하기
* [ ] systemd를 죽이는 대신에 usb가 아닌 serial0에 연결된 gps 가 부팅과 동시에 실행되도록 하려면, /etc/default/gpsd 를 수정토록 한다.
```bash
$ sudo nano /etc/default/gpsd
```
from:
>DEVICES=""

to:
>DEVICES="/dev/serial0"

그리고 systemd 서비스는 다시 켜준다.
```bash
$ sudo systemctl enable gpsd.socket
$ sudo systemctl start gpsdsocket
```

### gpsd 실행
```bash
$ sudo gpsd /dev/serial0 -F /var/run/gpsd.sock
```
끌 때는
``` bash
$ sudo killall gpsd
```

### test: cgps
gpsd가 제공하는 데이터를 실시간으로 확인할 수 있다.
```bash
$ cgps
```
 ![||600](https://cl.ly/dc6e40/Image%202019-09-04%20at%2012.36.37%20PM.png)

### gpsd 가 제공하는 데이터 구조
gpsd의 데이터는 json 형식으로, 'class' attribute 에 따라 해석한다.
gpsd 프로토콜 공식문서: https://gpsd.gitlab.io/gpsd/gpsd_json.html

#### gpsd + python 예제
* gpsd로부터 TPV (time, position, velocity) 기본정보 가져오기

```python
#! /usr/bin/python

from gps import *
import time

gpsd = gps(mode=WATCH_ENABLE|WATCH_NEWSTYLE)
print 'latitude\tlongitude\ttime utc\t\t\taltitude\tepv\tept\tspeed\tclimb' # '\t' = TAB to try and output the data in columns.

try:

while True:
report = gpsd.next() #
if report['class'] == 'TPV':

print getattr(report,'lat',0.0),"\t",
print getattr(report,'lon',0.0),"\t",
print getattr(report,'time',''),"\t",
print getattr(report,'alt','nan'),"\t\t",
print getattr(report,'epv','nan'),"\t",
print getattr(report,'ept','nan'),"\t",
print getattr(report,'speed','nan'),"\t",
print getattr(report,'climb','nan'),"\t"

time.sleep(1)

except (KeyboardInterrupt, SystemExit): #when you press ctrl+c
print "Done.\nExiting."
```
* 인공위성 정보 가져오기

```python
#! /usr/bin/python

from gps import *
import time
import os

gpsd = gps(mode=WATCH_ENABLE|WATCH_NEWSTYLE)

try:
while True:

report = gpsd.next() #
if report['class'] == 'SKY':
os.system('clear')
print ' Satellites (total of', len(gpsd.satellites) , ' in view)'
for i in gpsd.satellites:
print 't', i

print '\n\n'
print 'PRN = PRN ID of the satellite. 1-63 are GNSS satellites, 64-96 are GLONASS satellites, 100-164 are SBAS satellites'
print 'E = Elevation in degrees'
print 'As = Azimuth, degrees from true north'
print 'ss = Signal stength in dB'
print 'used = Used in current solution?'

time.sleep(1)

except (KeyboardInterrupt, SystemExit): #when you press ctrl+c
print "Done.\nExiting."
```

Google API python client 사용법-simple

2019-09-14T06:39:47Z

Doguin:

# Python Google
API 사용하기
라즈베리파이에서 gmail등의 구글 서비스를 확인하고 조작 할 수 있는 python 코드 사용법. 구글의 표준 api를 사용한다. 이하에서는 Gmail과 Google calendar 를 예로 사용한다.
참고: https://developers.google.com/gmail/api/quickstart/python

## Google OAuth2.0 을 통한 인증
참고:
* 구글 공식 개념설명: https://developers.google.com/identity/protocols/OAuth2
* 구글 샘플: https://developers.google.com/gmail/api/quickstart/python
* 라이브러리 도큐먼트: https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html

gmail 데이터를 사용하는 웹 서비스나 어플리케이션, 혹은 기기를 만든다고 하면, 신뢰와 관련한 2가지 문제가 발생한다.
1. 이 사용자가 정말 본인인가?
2. 이 어플이 어디까지 민감한 정보를 다루도록 허용할 것인가?

1번 문제를 authentication의 문제라고하고, 두번째의 문제를 authorization의 문제라고 한다.
개인개발자가 해결하기에는 어려운 두가지 문제를 구글이라는 능력자에게 위탁해버리는 해결책이 OAuth2.0 이라는 프로토콜이다.

간단히 요약하자면, 구글의 인증을 받은 프로젝트(구글인증서버에 대해 클라이언트)는 클라이언트 인증정보(Oauth2.0 client ID, Pass 등) 을 발급받아 가지고 있다가 Gmail 데이터가 필요한 순간에 사용자가 직접 어플에 구글 아이디를 입력하는 대신 구글의 로그인 창(consent screen)을 띄워주고, 구글측에서 사용자가 확인되면 사용자에게 '이러이러한 앱에서 너의 gmail 데이터에 접근하도록 허락할래?'라고 물어본 후, 허락들 받으면 어플에 gmil api에 리퀘스트를 보낼때 꼭 필요한 Access Token을 발급해주는 절차이다.

![||600](https://cl.ly/333ddb/Screen%20Recording%202019-08-07%20at%2012.55%20PM-Animated%20Image%20(Small).gif)

Oauth2.0의 개념에 대한 설명은 다양한 자료에서 다루고 있으므로 참고하도록 하고, 여기서는 Raspberry pi 상에서 Gmail 정보를 가져오은 python 스크립트를 구현하기 위한 실제적인 내용들만 확인하자.

### 1. google cloud platform 가입
gmail api 는 구글 클라우드 플랫폼이라는 서비스의 일부이다. 먼저 구글 계정을 만들어 google cloud platform에 가입하고 프로젝트를 새로 생성한다.
http://www.google.com/cloud
기존의 gmail 계정을 사용해도 되며, 무료로 가입해도 대부분의 기본 기능을 마음껏 사용할 수 있다.(신용카드 등록을 해도 결제가 되지는 않는다. 신용카드 등록하지 않고 창을 닫아도 작동되는 듯 하다.)

### 2. 새 프로젝트 생성
구글 클라우드 플랫폼 콘솔화면에서 새로운 프로젝트를 생성한다.
 ![||600](https://cl.ly/ab0ad7/Image%202019-08-05%20at%205.45.31%20PM.png)
Gmail-test라고 이름지었다.

### 3. Gmail API 켜기
API 및 서비스 > 대시보드 ( https://console.developers.google.com/apis )에서 Gamil api를 Enabled 시켜준다.
 ![||600](https://cl.ly/a8753e/Image%202019-08-05%20at%205.49.35%20PM.png)

 ![||600](https://cl.ly/3e7ee6/Image%202019-08-05%20at%205.59.36%20PM.png)

 ![||600](https://cl.ly/24249b/Image%202019-08-05%20at%206.04.18%20PM.png)

 ![||600](https://cl.ly/2017ec/Image%202019-08-02%20at%206.40.18%20PM.png)

### 4. 인증정보 (OAuth Client ID, PASS) 생성
"이 프로그램은 너의 구글 계정에서 이러이러한 개인정보를 가져다가 쓸거야. 허용할래?" 라고 물어보는 화면을 consent screen이라고 한다. 메뉴 > APIs & Services > 사용자 인증정보 에서 인증 정보를 만든다. 3가지 방식 중 고를 수 있도록 되어있는데, 어떤 방식을 골라야 할지 잘 모른다면 마지막의 '사용자 인증정보 선택 도움말'을 활용한다. 우리는 OAuth 클라이언트 ID를 선택.
 ![||600](https://cl.ly/9cd427/Image%202019-08-05%20at%206.23.17%20PM.png)
동의 화면 (구글 로그인창) 구성
 ![||600](https://cl.ly/1c08c7/Image%202019-08-05%20at%206.28.06%20PM.png)
프로젝트 이름, 로고, 문의사항 보낼 수 있는 지원 이메일 등등 넣을 수 있다.
 ![||600](https://cl.ly/9f43dd/Image%202019-08-05%20at%206.32.38%20PM.png)
만들고 있는 프로젝트 유형에 따라 애플리케이션 유형을 선택한다.
우리는 raspberry pi 의 cli 환경에서 사용할 예정이므로 구글에서 제공하는 동의화면을 바로 디바이스에 띄울 수가 없고, 제3의 디바이스를 통해 접근토록 해야한다.
이런경우 반드시 **'기타'** 를 선택한다.
'OAuth 클라이언트 이름'은 프로젝트명과는 별개로, 나는 gmail_test라고 지었다.
 ![||600](https://cl.ly/4b1766/Image%202019-08-05%20at%206.35.38%20PM.png)
인증정보 생성 완료!
 ![||600](https://cl.ly/4e7818/Image%202019-08-05%20at%206.36.31%20PM.png)

인증정보 (credentials)를 다운로드 해 두면 번거롭게 한자씩 타이핑해 넣지 않아도 되므로 편하다.
 ![||600](https://cl.ly/6972be/Image%202019-08-05%20at%206.37.49%20PM.png)
다운받은 .json 파일은 실행시킬 파이선 코드와 같은 위치에 넣어둔다.

### 2. Google Client Library 를 설치한다.

```bash
$pip install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib
```
* [x] 라즈베리에서 설치하려니 sudo 권한이 필요한데, 확인 필요하다.

### 3. Gmail api 공식 샘플 코드를 실행시켜 잘 작동하는지 확인
참고: https://developers.google.com/gmail/api/quickstart/python
* 27행의 'credentials.json' 은 앞서 받아둔 클라이언트 인증 정보파일로 파일명 바꾼다.

* 우리는 라즈베리파이의 콘솔환경에서 실행시키고 있으므로, consent screen을 디바이스에 바로 띄울 수 없다. 제3의 디바이스에서 브라우저를 열고 consent screen 을 찾아가서 확인 코드를 받고 콘솔 창에 입력하는 방식으로 해야하는데, 이를 위해서는 28행의 'flow.run_local_server(port=0)' 은 'flow.run_console()'로 교체되어야 한다.
참고: https://google-auth-oauthlib.readthedocs.io/en/latest/reference/google_auth_oauthlib.flow.html

* 예제는 gmail에서 데이터를 읽어오는 것까지만 권한 요청한다. 만일 프로젝트에서 필요로하는 권한의 범위가 달라진다면 행8의 SCOPES = [...]를 수정, 혹은 추가 해야 한다.
참고: https://developers.google.com/gmail/api/auth/scopes

```python
# gmail-test.py
# raspberry pi 콘솔용. gmail label 목록을 불러온다.

import pickle
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request

# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/gmail.readonly']

def main():
"""Shows basic usage of the Gmail API.
Lists the user's Gmail labels.
"""
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'client_secret_497460368822-l2vljgso619t68g4nnfbej5i9kel4767.apps.googleusercontent.com.json', SCOPES)
creds = flow.run_console()
print(creds)
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)

service = build('gmail', 'v1', credentials=creds)

# Call the Gmail API
results = service.users().labels().list(userId='me').execute()
labels = results.get('labels', [])

if not labels:
print('No labels found.')
else:
print('Labels:')
for label in labels:
print(label['name'])

if __name__ == '__main__':
main()

```

 ![||600]( https://cl.ly/8829db/Screen%20Recording%202019-08-07%20at%2003.23%20PM-Animated%20Image%20(Large).gif )

## Google api python library 사용법
구글 공식 문서: https://github.com/googleapis/google-api-python-client/blob/master/docs/start.md#building-and-calling-a-service
google python 라이브러리가 지원하는 모든 google api 리스트와 사용법 reference: https://github.com/googleapis/google-api-python-client/blob/c977304a1af233058f572787538edafc2ef122e6/docs/dyn/index.md

구글의 모든 서비스 api는 비슷한 구조를 가지고 있다. gmail도 마찬가지.
### 1. 구글 서비스 객체 만들기
* apiclient.discovery.build()사용해 서비스 객체 만든다.
* 어떤 서비스 api를 사용할 것인지, api버전은 어느 것 사용하는지, [link](https://github.com/googleapis/google-api-python-client/blob/c977304a1af233058f572787538edafc2ef122e6/docs/dyn/index.md) 중에서 선택한다.
* 앞서 획득한 access token도 이때 전달한다.
```python
from apiclient.discovery import build
service = build('api_name', 'api_version', credencials='아까얻은 AcessToken')
```

### 2. collection
구글 서비스의 모든 데이터는 계층적인 집합을 이루고 있는데, 이 한 단위의 계층을 collection이라고 부른다.
gmail 같으면 user 콜렉션 아래에는 여러개의 message 콜렉션이 있고, 그 아래에는.... 하는 식이다.
이들 콜렉션에 아래와 같이 접근할 수 있다.
```python
collection = service.users().messages()
```

### 3. request and response
어떤 특정한 collection에 대해 구글에 요청할 수 있는 명령어는 콜렉션마다 다 다르다. [이곳](https://developers.google.com/gmail/api/v1/reference/) 에서 검색 할 수 있다.
gmail의 message 콜렉션이 list()명령을 가지고 있다면,
```python
request = service.users().messages().list(userId='me')
```
실제 request를 구글 api 서버에 보내고 응답을 받아오는 건 execute() 함수를 사용.
```python
response = request.execute()
# or
response = servie.users().mesages().list(userId='me').execute()
```
* 구글로부터의 답장은 원래는 JSON형식으로 온다. 그렇지만 우리가 사용하는 python api가 자동으로 사용하기 쉽게 python 데이터 타입(dict)로 바꾸어주기 때문에 get()함수로 원하는 항목을 쉽게 뽑아 쓸 수 있다.

## 구글 캘린더 예제
구글 캘린더 api소개자료의 가장 기본 예제.
참고: https://developers.google.com/calendar/quickstart/python
```python
# quickstart.py
# 사용자의 기본캘린더 (primary)에서
# 지금이후(timeMin=now)로 시작하는
# 10개의 이벤트(maxResult-10)를 가져와 표시하기

from __future__ import print_function
import datetime
import pickle
import os.path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request

# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']

def main():
"""Shows basic usage of the Google Calendar API.
Prints the start and name of the next 10 events on the user's calendar.
"""
creds = None
# The file token.pickle stores the user's access and refresh tokens, and is
# created automatically when the authorization flow completes for the first
# time.
if os.path.exists('token.pickle'):
with open('token.pickle', 'rb') as token:
creds = pickle.load(token)
# If there are no (valid) credentials available, let the user log in.
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
creds.refresh(Request())
else:
flow = InstalledAppFlow.from_client_secrets_file(
'credentials.json', SCOPES)
creds = flow.run_local_server(port=0)
# Save the credentials for the next run
with open('token.pickle', 'wb') as token:
pickle.dump(creds, token)

service = build('calendar', 'v3', credentials=creds)

# Call the Calendar API
now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time
print('Getting the upcoming 10 events')
events_result = service.events().list(calendarId='primary', timeMin=now,
maxResults=10, singleEvents=True,
orderBy='startTime').execute()
events = events_result.get('items', [])

if not events:
print('No upcoming events found.')
for event in events:
start = event['start'].get('dateTime', event['start'].get('date'))
print(start, event['summary'])

if __name__ == '__main__':
main()
```

## json module for python
참고: https://www.w3schools.com/python/python_json.asp

Json 데이터를 다루어야 하는 경우, 파이썬에 기본 포함 되어있는 json모듈을 사용하면 JSON 파일/string을 파이썬 dictionary 나 list 로 만들어 사용할 수 있어 편리하다. 더우기 indent= 아규먼트를 사용하면 print() 로 표시할 때 줄 맞추어 주므로 보기에도 편하다.

```python
import json
...
print json.dumps(response, sort_keys=True, indent=4)
"""
For example, if the printed JSON is the following:
{
"count": 2,
"items": [
{
"cents": 5,
"name": "#586 1923-26 5-cent blue Theodore Roosevelt MLH perf 10"
},
{
"cents": 5,
"name": "#628 1926 5-cent Ericsson Memorial MLH"
}
]
}
"""
# You can access the data like this:
print 'Num 5 cent stamps: %d' % response['count']
print 'First stamp name: %s' % response['items'][0]['name']
```
|method|용도 |
|-|-|
|json.load(json) / json.load**s**(json_string)|JSON 파일을 python dictionary 로 바꾸어 읽어들임 / json 문자열을 파이썬 데이타로 변환 |
|json.dump(puthon_object) / json.dump**s**(python_object)|python 데이터를 JSON으로 바꾸어 파일로 저장/ python 데이터를 json 형식 문자열로 변환. parameter: sort_keys=(True/False), parameter: indent= 들여쓰기칸수|

Python datetime 모듈 quick reference

2019-09-11T10:21:49Z

Doguin: 새 문서: # datetime 모듈 quick reference 공식문서 참고: https://docs.python.org/ko/3/library/datetime.html 쉬운 한글자료: https://python.bakyeono.net/chapter-11-3.html 일상생...

# datetime 모듈 quick reference
공식문서 참고: https://docs.python.org/ko/3/library/datetime.html
쉬운 한글자료: https://python.bakyeono.net/chapter-11-3.html
일상생활에서 사용하는 날짜와 시간을 다루기 위한 파이썬 기본 모듈.
날짜를 나타내는 datetime.date class, 시각을 나타내는 datetime.time class, 둘 모두를 나타내는 datetime.datetime class 를 가지고 있다.

당연하게도 OS에서 현재 timezone과 시간이 올바르게 셋팅되어있어야한다.
라즈베리파이에서는 raspi-config 프로그램으로 타임존을 셋팅해주면 된다.

OS 기반의 시간을 다루는 time 모듈도 있으니 참고.

## datetime.date class
* 특정날짜 객체 생성: datetime.date(1978,8,6)
* 오늘날짜 객체 생성: datetime.date.today()

```python
# datetime.date-test.py
from datetime import date

print(date(1978,8,6))
print(date.today())

# 1978-08-06
# 2019-08-14
```
|datetime.date class 속성 또는 메서드 |값 또는 기능|
|-|-|
year| 년
month |월
day| 일
weekday() |요일 (월요일=0, 일요일=6)
isoformat() |ISO 표준 문자열 표현 “년-월-일”(예: 1986-03-06)과 같은 형식
strftime(format) | 형식을 지정하여 표현 (자료 참고)

```python
# datetime.date-test.py
from datetime import date

myBirthDay = date(1978,8,6)
today = date.today()
print(myBirthDay)
print(today)

# 1978-08-06
# 2019-08-14

print('나는 %d년 %d월 %d일에 태어남' %(myBirthDay.year, myBirthDay.month,myBirthDay.day))
# 나는 1978년 8월 6일에 태어남

day = '월화수목금토일'[today.weekday()]
print('오늘은 %s요일이에요' %day)
# 오늘은 수요일이에요
```

## datetime.time class
밀리세컨드까지 특정해 표현가능.
* 특정 시각 객체 생성: datetime.time(13,30,0,100000) # 13시30분0초.100000
|datetime.time class 속성 또는 메서드| 값 또는 기능|
|-|-|
hour |시
minute| 분
second |초
microsecond |마이크로초
isoformat() I|SO 표준 문자열 표현
strftime(format) |임의 형식으로 문자열 표현

```python
# python interpreter
>>> from datetime import time
>>> at = time(15, 30, 45)
>>> at.hour, at.minute, at.second # 시, 분, 초
(15, 30, 45)

>>> at.microsecond # 마이크로초
0

>>> at.isoformat() # ISO 표준 문자열 표현
'15:30:45'
```
### isoformat 문자열을 다시 datetime객체로
* datetime.fromisoformat(string)

## datetime.datetime class
datetime.date 와 datetime.time 을 합쳐놓은 class. 양쪽의 속성과 메소드를 모두 사용할 수 있다.
* 특정 일시 객체 생성: datetime(년, 월, 일, 시, 분, 초, 마이크로초)
* 현재 일시 객체 생성: datetime.now()
* 날짜와 시각 결합: datetime.combine(날짜, 시각)

```python
# python interpreter

>>> from datetime import datetime
>>> datetime(2017, 11, 14)
datetime.datetime(2017, 11, 14, 0, 0)

>>> datetime(2017, 11, 14, 8, 30)
datetime.datetime(2017, 11, 14, 8, 30)

>>> datetime(2017, 11, 14, 8, 30, 50, 200000)
datetime.datetime(2017, 11, 14, 8, 30, 50, 200000)

>>> datetime.now() # 현재 일시
datetime.datetime(2017, 11, 14, 19, 4, 7, 950704)

>>> datetime.combine(date.today(), time(15)) # 오늘 3시
datetime.datetime(2017, 11, 14, 15, 0)

>>> now = datetime.now()
>>> now.year, now.month, now.day, '월화수목금토일'[now.weekday()]
(2017, 11, 14, '화')

>>> now.hour, now.minute, now.second, now.microsecond
(19, 8, 52, 283277)

>>> now.date(), now.time()
(datetime.date(2017, 11, 14), datetime.time(19, 8, 52, 283277))

>>> now.isoformat()
'2017-11-14T19:08:52.283277'
```

## datetime.timedelta class
두시간 사이의 차를 나타내는 timedelta class를 사용가능하다.
예를 들어,
date2 = date1 + timedelta
timedelta = date1 - date2
와 같은 연산이 가능하다.
자세한 내용은 참고자료 검토.

```python
# python interpreter
>>> from datetime import datetime, timedelta
>>> now = datetime.now() # 현재 일시
>>> after_1000h = timedelta(hours=1000) # 1천 시간
>>> now + after_1000h # 지금부터 1천 시간 후
datetime.datetime(2017, 12, 26, 11, 42, 32, 103816)

>>> birthday = date(1986, 3, 6) # 생년월일
>>> today = date.toady() # 오늘
>>> today - birthday # 태어난 뒤 오늘까지의 기간
datetime.timedelta(11576)
```

## 세계시계 datetime.tzinfo class
* time 이나 datetime 오브젝트의 멤버변수인 tzinfo가 None이 아닌 값(tzinfo나 그 서브클래스인 timezone 오브젝트)을 갖는 경우 세계시계로 작동하게 된다. (공식 문서에서 aware 라고 표현됨.)
* 생성자에 `tzinfo=` 아규먼트를 넣어줌으로써 세계시계작동시킨다.
* 써머타임 등 고려해 직접 tzinfo의 서브클래스를 작성 토록되어있지만(tzinfo는 추상클래스다) utc+9:00(서울 ) 등등 대부분의 간단한 경우를 나타내기 위해 이미 만들어져있는 timezone class를 사용할 수 있다.
참고: https://spoqa.github.io/2019/02/15/python-timezone.html

```python
>>> from datetime import datetime, timedelta, tzinfo, timezone

>>> datetime.utcnow()
datetime.datetime(2019, 8, 14, 21, 12, 22, 857347) # 영국 그리니치의 현재시간을 표시하고있기는 하지만 tzinfo=None으로, 세계시간 aware 하지는 않다.

>>> datetime.now(timezone.utc)
datetime.datetime(2019, 8, 14, 21, 14, 17, 112890, tzinfo=datetime.timezone.utc) # 세계시간 aware한 세계표준시

>>> seoulnow = datetime.now(timezone(timedelta(hours=9))) # utc+9:00 (서울표준시)
>>> seoulnow
datetime.datetime(2019, 8, 15, 6, 18, 34, 177299, tzinfo=datetime.timezone(datetime.timedelta(0, 32400)))

>>> seoulnow.utcoffset()
datetime.timedelta(0, 32400) # 세계표준시와 시차
>>> seoulnow.tzname()
'UTC+09:00' # 타임존 이름보기

>>> seoulnow.astimezone(timezone(timedelta(hours=-4))) # 같은 시간을 뉴욕표준시(utc-4:00)로 표현하면?
datetime.datetime(2019, 8, 14, 17, 18, 34, 177299, tzinfo=datetime.timezone(datetime.timedelta(-1, 72000)))
```

PIL (python image library) / pillow quick reference

2019-09-11T10:01:50Z

Doguin: 새 문서: # PIL (python Imaging library) Quick reference python 에서 비트맵 이미지를 그리고 편집하고 등등 여러가지 할 수 있는 오픈소스 이미지 프로세싱 라...

# PIL (python Imaging library) Quick reference
python 에서 비트맵 이미지를 그리고 편집하고 등등 여러가지 할 수 있는 오픈소스 이미지 프로세싱 라이브러리. 간편해서 매우널리 쓰인다.

## PIL 설치
* 오리지날 PIL 은 개발중단 되었고, pillow 프로젝트가 뒤를 잇고 있다. 대부분의 사용방법이 동일하다.
* 더 다양한 기능을 활용하기 위해 아래 외부 라이브러리를 먼저 설치해도 좋다.
(아래는 라즈베리파이에서 apt-get을 사용해 설치했으나 macos 에서는 homebrew사용해 설치 할 수 잇다.)
참고: https://pillow.readthedocs.io/en/stable/installation.html#external-libraries

```bash
$ sudo apt-get install libjpeg-dev -y
$ sudo apt-get install zlib1g-dev -y
$ sudo apt-get install libfreetype6-dev -y
$ sudo apt-get install liblcms1-dev -y
$ sudo apt-get install libopenjp2-7 -y
$ sudo apt-get install libtiff5 -y

$ sudo pip3 install pillow
```
## Image class
PIL 의 가장 기본이 되는 클래스. 비트맵 이미지 데이터를 갖는다.
* Image.open() 을 사용해 비트맵 이미지를 불러들여 Image 오브젝트 만들 수 있다.

```python
form PIL import Image
im = Image.open("hopper.ppm")
```

* 혹은 Image.new(mode, size, color=0) 를 통해 수동으로 이미지 오브젝트를 만들 수도 있다.

|parameter|설명|
|-|-|
|mode| 1 (1-bit pixels, black and white, stored with one pixel per byte),
||L (8-bit pixels, black and white),
||P (8-bit pixels, mapped to any other mode using a color palette)
||RGB (3x8-bit pixels, true color)
||RGBA (4x8-bit pixels, true color with transparency mask)
||CMYK (4x8-bit pixels, color separation)
||YCbCr (3x8-bit pixels, color video format)
||Note that this refers to the JPEG, and not the ITU-R BT.2020, standard
||HSV (3x8-bit pixels, Hue, Saturation, Value color space)
||I (32-bit signed integer pixels)
||F (32-bit floating point pixels)|
|size| 2-tuple (width, height)|
|color| 배경색. RGB 모드인 경우 3-tuple|

* array 로부터 이미지를 만들 수도 있는데, Numpy 사용하는 경우 유용하다.

```python
from PIL import Image
import numpy as np

im = Image.open('hopper.jpg')
a = np.asarray(im)

im = Image.fromarray(a)
```

* image.show()를 사용해 이미지를 미리보기 할 수 있다.
os의 미리보기 유틸리티를 활용한다. macos에서 는 quicklook으로 이미지를 보여준다.

```python
im.show()
```
* image.save(filename) 으로 파일로 저장할 수 있다.
파일명에 따라 파일포맷을 자동으로 결정한다.

```python
import os, sys
from PIL import Image

f,e = os,path.splitext(filename) # 파일명과 확장자로 나눔
outfile = f + ".jpg"
if filename != outfile:
try:
Image.open(filename).save(outfile) # .jpg로 save하면 자동으로 jpg 포맷으로 변환
except:
print("cannot convert", filename)
```

* crop(), transpose(), paste() 할 수 있다.

```python
box = (100,100,400,400)
region = im.crop(box)

region = region.transpose(Image.ROTATE_180)
im.paste(region, box)
```
|Parameters| 기능|
|-|-|
|PIL.Image.FLIP_LEFT_RIGHT|좌우반전|
|PIL.Image.FLIP_TOP_BOTTOM|상하반전|
| PIL.Image.ROTATE_90|90도 회전|
| PIL.Image.ROTATE_180|180도 회전 |
|PIL.Image.ROTATE_270|-90도 회전 |
| PIL.Image.TRANSPOSE||
|PIL.Image.TRANSVERSE|-|

## ImageDraw class
* Image object 위에 간단한 2d drawing .
1. 빈 image를 만든다.
2. ImageDraw.Draw(image)로 drawing context를 득한다.
3. 여러가지 그림도 그리고 글씨도(!) 쓴다.
4. image.show()로 디스플레이한다.

```python
from PIL import Image, ImageDraw, ImageFont
# get an image
base = Image.open('Pillow/Tests/images/hopper.png').convert('RGBA')

# make a blank image for the text, initialized to transparent text color
txt = Image.new('RGBA', base.size, (255,255,255,0))

# get a font
fnt = ImageFont.truetype('Pillow/Tests/fonts/FreeMono.ttf', 40)
# get a drawing context
d = ImageDraw.Draw(txt)

# draw text, half opacity
d.text((10,10), "Hello", font=fnt, fill=(255,255,255,128))
# draw text, full opacity
d.text((10,60), "World", font=fnt, fill=(255,255,255,255))

out = Image.alpha_composite(base, txt)

out.show()
```
* ImageDraw.Draw(im, mode=None)
im - 그림그릴 이미지 오브젝트
mode - 흑백모드 '1', grayscale모드 'L' , RGB, RGBA ...

* ImageDraw.ImageDraw.point(xy, fill=None)
xy - 점들의 좌표. 2-tuples like [(x, y), (x, y), ...] or numeric values like [x, y, x, y, ...]
fill - 점 색

* ImageDraw.ImageDraw.rectangle(xy, fill=None, outline=None, width=0)
xy - 두 대각 꼭지점. [(x0, y0), (x1, y1)] or [x0, y0, x1, y1]
outline - 선 색
fill - 채움 색
width - 라인 두께

* ImageDraw.ImageDraw.line(xy, fill=None, width=0, joint=None)
xy - 선분을 이루는 점의 연속. [(x, y), (x, y), ...] or [x, y, x, y, ...]
fill - 채움 색
width - 라인 두께 (pixel)
joint - None or "curve" 모서리 둥글리기

```python
from PIL import Image, ImageDraw

im = Image.open("hopper.jpg")

draw = ImageDraw.Draw(im)
draw.line((0, 0) + im.size, fill=128)
draw.line((0, im.size[1], im.size[0], 0), fill=128)

# write to stdout
im.save(sys.stdout, "PNG")
```

* ImageDraw.ImageDraw.arc(xy, start, end, fill=None, width=0)
xy - 아크 외접 사각형. [(x0, y0), (x1, y1)] or [x0, y0, x1, y1]
start - 출발각(degree), 3시방향이 0˚부터 시작해서 시계방향으로 증가.
end - 도착각
fill - 도형의 색
width - 라인 두께 (pixel)

* ImageDraw.ImageDraw.ellipse(xy, fill=None, outline=None, width=0)
xy - 타원 외접 사각형. [(x0, y0), (x1, y1)] or [x0, y0, x1, y1]
outline - 선 색
fill - 채움 색
width - 라인 두께(pixel)

## ImageText class - text 표시하기
폰트를 로딩한 후, ImageDraw.text() 를 사용해 텍스트를 표시할 수 있다.

* ImageFont.truetype(font=None, size=10, index=0, encoding='', layout_engine=None)
font - truetype font 파일.
size - 폰트 크기. piont 단위
index - light, bold 등 fontface 선택. 디폴트는 index=0
encoding - 'unic'(unicode. default), 'symb'(Microsoft Symbol), 'ADOB'(Adobe Standard), 'ADBE'(Adobe Export), 'armn'(Apple Roman)

```python
from PIL import Image, ImageDraw, ImageFont

im = Image.new('RGB', (128,64),0)
draw = ImageDraw.Draw(im)

font = ImageFont.truetype("Arial.ttf",15)

draw.text((10,10), "hello world\n I'm a boy \n You are a girl", font=font)
im.show()

```

* ImageDraw.ImageDraw.text(xy, text, fill=None, font=None, anchor=None, spacing=0, align="left", direction=None, features=None, language=None)
텍스트를 표시한다.
xy - 텍스트 위치. 텍스트 상자의 좌상단위치임.
text - 표시할 텍스트.
fill - 텍스트 컬러
font - ImageFont instance
spacing - 줄 간격,(pixel)
align - "left", "center" or "right"
direction - 'rtl'(right to left) or 'ltr' or 'ttb'(top to bottom). libraqm 라이브러리 필요함.
features - opentype의 다양한 기능
language - https://www.w3.org/International/articles/language-tags/

* ImageDraw.ImageDraw.textsize(text, font=None, spacing=4, direction=None, features=None, language=None)
표시될 text의 크기를 (가로, 세로)(pixel) 로 리턴한다.
text - 표시할 텍스트
font - ImageFont instance
spacing - 행 간격

### 한글표시
* 한글폰트가 잘 표시되지 않는다는 리포트가 많이 있었으나 테스트 결과 별다른 조작 없이 잘 된다.
python2에서 유니코드 지원이 원활치 않아 있었던 문제로 생각된다. python3에서는 잘 된다.
* 폰트파일의 위치는 중요하다. 기본적으로 cwd(currunt working directory - 디폴트는 실행중인 스크립트와 같은 위치) 에서 폰트를 찾고, 못찾으면 os에 설치된 폰트 파일을 찾아서 사용한다.(똑똑한데?) 그럼에도 내가 한참 헤맨 이유는 atom editor의 script package가 편집중인 스크립트의 위치가 아닌 프로젝트의 위치를 cwd 로 하도록 설정되어있었기 때문... script package 설정변경으로 간단히 해결됨.

```python
from PIL import Image, ImageDraw, ImageFont

im = Image.new('RGB', (128,64),0)
draw = ImageDraw.Draw(im)

font = ImageFont.truetype("malgun.ttf",15,0)

draw.text(
(10,10),
'''세종대왕
만만세''',
font=font)

im.show()
```

![||600](https://cl.ly/5d93f4/Image%202019-07-30%20at%2010.13.53%20PM.png)

## Image sequences (GIF animation)
* Image.open("....gif") 로 여러 프레임이 있는 이미지를 열었다면, image.seek() 과 image.tell()로 특정 프레임을 로드하고 볼 수 있다. 파일 끝에서는 EOFError 발생한다.

```python
from PIL import Image
im = Image.open("source.gif")
im.seek(1)

try:
while 1:
im.seek(im.tell()+1)
im.show()
except EOFError:
pass
```
* ImageSequence.Iterator 를 사용하면 좀 더 편하게 프레임을 조작 할 수 있다.

```python
from PIL import Image
from PIL import ImageSequence

im = Image.open("source.gif")
for frame in ImageSequence.Iterator(im):
frame.show()
```

## 두개의 image 합치기
* Image.paste(im, box= None, mask= None)
함수를 사용해서 원래의 이미지 위해 다른 이미지를 덧씌울 수 있다.
* im : 덧씌울 Image object
* box: 2-tuple or 4-tuple 로, 덧씌울 이미지의 위치
* mask: 원한다면 mask적용할 수도 있다('1'mode 이미지, 혹은 RGBA 모드 이미지가 사용되면 A channel). 255 값을 갖는 점은 이미지가 덧씌워지고, 0값을 갖는 점은 원래의 이미지가 그대로 사용된다.