Python：webカメラとOpenCVで動体検知してLine Notifyで画像を通知する

こんにちは　Keita Nakamorです。久々の投稿です。

今日は、webカメラとOpenCVで動体検知してLine Notifyで画像を通知する、ってことをやってみます。

予めアクセストークンをLine Notifyでとっておいて下さい。Bearer <ここにアクセストークンをはる>　ってところに貼り付けます。<>は入りませんよ。

久々すぎるのでOpenCVの基礎からやっていきます。

ステップ１：静止画像ファイルを読み込んで出力する

# ステップ１：静止画像ファイルを読み込んで出力する
import os
import cv2
import numpy as np

img =cv2.imread('Pictures/Screenpresso/2020-03-27_17h43_20.png')

# 画像サイズを調べる
img.shape # (1040, 1920, 3)

# BGR の数値を確認する
img[0][0] # array([65, 63, 60], dtype=uint8)

# 画像を出力する
cv2.imshow('img', img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 画像をファイルに出力する
#os.mkdir('./output')
cv2.imwrite('output/test.jpg', img)

# ステップ１：静止画像ファイルを読み込んで出力する

import os

import cv2

import numpy as np

img =cv2.imread('Pictures/Screenpresso/2020-03-27_17h43_20.png')

# 画像サイズを調べる

img.shape # (1040, 1920, 3)

# BGR の数値を確認する

img[0][0] # array([65, 63, 60], dtype=uint8)

# 画像を出力する

cv2.imshow('img', img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# 画像をファイルに出力する

#os.mkdir('./output')

cv2.imwrite('output/test.jpg', img)

ステップ２動画ファイルを読み込んで出力する→リアルタイムキャプチャーする

# ステップ２動画ファイルを読み込んで出力する→リアルタイムキャプチャーする
import cv2
import numpy as np
import sys

'''# 動画を読み込む
cap = cv2.VideoCapture('output/test.avi')
'''
# リアルタイムキャプチャーする
cap = cv2.VideoCapture(0)

# 動画読み込みが失敗したら強制終了
if cap.isOpened() == False:
    print('読み込み失敗')
    sys.exit()

#１フレームだけ読み込む
ret, frame = cap.read()
h, w, color = frame.shape # h,wの順 ３つ目は色数

# 書き込み設定（コーデックの指定）
fourcc = cv2.VideoWriter_fourcc(*'XVID')
dst = cv2.VideoWriter('output/test001.avi', fourcc, 30.0, (w,h)) # ファイル名 設定 fps 解像度の順

# スクリプト実行
while True:
    ret, frame = cap.read()
    
    if ret == False:
        break
    
    # 表示
    cv2.imshow('img', frame)
    
    # 書き込み
    dst.write(frame)
    
    # 停止動作
    if cv2.waitKey(30) == 27: # ESC=27
        break

# 終了処理
cv2.destroyAllWindows()
cap.release()

# ステップ２動画ファイルを読み込んで出力する→リアルタイムキャプチャーする

import cv2

import numpy as np

import sys

'''# 動画を読み込む

cap = cv2.VideoCapture('output/test.avi')

'''

# リアルタイムキャプチャーする

cap = cv2.VideoCapture(0)

# 動画読み込みが失敗したら強制終了

if cap.isOpened() == False:

print('読み込み失敗')

sys.exit()

#１フレームだけ読み込む

ret, frame = cap.read()

h, w, color = frame.shape # h,wの順３つ目は色数

# 書き込み設定（コーデックの指定）

fourcc = cv2.VideoWriter_fourcc(*'XVID')

dst = cv2.VideoWriter('output/test001.avi', fourcc, 30.0, (w,h)) # ファイル名設定 fps 解像度の順

# スクリプト実行

while True:

ret, frame = cap.read()

if ret == False:

break

# 表示

cv2.imshow('img', frame)

# 書き込み

dst.write(frame)

# 停止動作

if cv2.waitKey(30) == 27: # ESC=27

break

# 終了処理

cv2.destroyAllWindows()

cap.release()

ステップ３　リアルタイムキャプチャー　と　リアルタイム背景差分処理

アクセストークンは、Line Notifyから取得して<>内にコピペしてください。かっこ部分は削除してください。

# ステップ３　リアルタイムキャプチャー　と　リアルタイム背景差分処理
import cv2
import numpy as np
import sys
import time
import datetime
import requests

def line_informer(file_name):
    # 条件 : 
    request_headers = {'Authorization': 'Bearer <ここにアクセストークンをはる>'}
    payload = {'message': 'Detected {}.'.format(datetime.datetime.now())}
    #files = {'imageFile': open("dorobou_picking.png", "rb")} #バイナリファイルを開く
    files = {'imageFile': open('output/' + file_name , "rb")}
    
    # 通知系 API のエンドポイントのホスト名は notify-api.line.me
    #r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)
    r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload, files=files)
    print(r.json())

def line_informer_start():
    #スクリプトが実行されたことを通知する
    payload = {'message': 'Monitoring Start' }
    request_headers = {'Authorization': 'Bearer <ここにアクセストークンをはる>'}

    # 通知系 API のエンドポイントのホスト名は notify-api.line.me
    r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)
    print(r.json())


line_informer_start()

'''# テスト用：動画を読み込む
cap = cv2.VideoCapture('output/test.avi')
'''
# リアルタイムキャプチャーする
cap = cv2.VideoCapture(0)

# 動画読み込みが失敗したら強制終了
if cap.isOpened() == False:
    print('読み込み失敗')
    sys.exit()

#１フレームだけ読み込んで　h ,w　を取り出す
ret, frame = cap.read()
h, w, ch = frame.shape # h,wの順 ３つ目は色数

# 書き込み設定（コーデックの指定）
time_str = str(datetime.datetime.now())
file_name = time_str[:10]+ '_' +time_str[11:13]+ time_str[14:16] + time_str[17:19] + '.avi'
print(time_str)

fourcc = cv2.VideoWriter_fourcc(*'XVID')
fps =30
dst = cv2.VideoWriter('output/' + file_name, fourcc, fps, (w,h)) # ファイル名 設定 fps 解像度の順

# 背景差分の行列領域を確保
frame_back = np.zeros((h,w,ch),dtype=np.float32)

# アラート時間インターバルの初期化
previous_datetime = datetime.datetime.now()

# スクリプト実行
while True:
    ret, frame = cap.read()

    if ret == False:
        break
        
    # 画像処理
    #frame2 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # グレースケール 
    frame3= cv2.absdiff(frame.astype(np.float32), frame_back) # 背景差分
    cv2.accumulateWeighted(frame,frame_back, 0.2)

    # 差分の大きさ
    pix_value= int(frame3.sum()/10000)
    cv2.putText(frame, 'Pix_value:{}'.format(pix_value), (0, 50), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)
    cv2.putText(frame3, 'Pix_value:{}'.format(pix_value), (0, 50), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)
    
    # しきい値としきい値を超えたときに録画REC表示する
    sreshold = 500
    if pix_value > sreshold: 
        
        # ラインに通知する（ただし　前回通知から30sec以上間隔をあけること）
        time_delta = datetime.datetime.now() - previous_datetime
        if time_delta.seconds > 10:
            
            # 画像をファイルに出力する
            #os.mkdir('./output')
            time_str = str(datetime.datetime.now())
            file_name = time_str[:10]+ '_' +time_str[11:13]+ time_str[14:16] + time_str[17:19] + '.jpg'
            cv2.imwrite('output/' + file_name, frame)
            
            line_informer(file_name)
            previous_datetime = datetime.datetime.now()        

        # REC表示
        cv2.putText(frame, 'Jadge:{}'.format('REC'), (0, 100), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)
        cv2.putText(frame3, 'Jadge:{}'.format('REC'), (0, 100), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA) 
    
        # REC保存
        dst.write(frame)

    # リアルタイム表示
    cv2.imshow('img', frame)
    #cv2.imshow('img2', frame2) #グレースケール
    cv2.imshow('img3', frame3.astype(np.uint8)) # 背景差分      

    # 停止動作
    if cv2.waitKey(30) == 27: # ESC=27
        break

# 終了処理
cv2.destroyAllWindows()
cap.release()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

# ステップ３　リアルタイムキャプチャー　と　リアルタイム背景差分処理

import cv2

import numpy as np

import sys

import time

import datetime

import requests

def line_informer(file_name):

# 条件 :

request_headers = {'Authorization': 'Bearer <ここにアクセストークンをはる>'}

payload = {'message': 'Detected {}.'.format(datetime.datetime.now())}

#files = {'imageFile': open("dorobou_picking.png", "rb")} #バイナリファイルを開く

files = {'imageFile': open('output/' + file_name , "rb")}

# 通知系 API のエンドポイントのホスト名は notify-api.line.me

#r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)

r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload, files=files)

print(r.json())

def line_informer_start():

#スクリプトが実行されたことを通知する

payload = {'message': 'Monitoring Start' }

request_headers = {'Authorization': 'Bearer <ここにアクセストークンをはる>'}

# 通知系 API のエンドポイントのホスト名は notify-api.line.me

r = requests.post('https://notify-api.line.me/api/notify', headers=request_headers, data=payload)

print(r.json())

line_informer_start()

'''# テスト用：動画を読み込む

cap = cv2.VideoCapture('output/test.avi')

'''

# リアルタイムキャプチャーする

cap = cv2.VideoCapture(0)

# 動画読み込みが失敗したら強制終了

if cap.isOpened() == False:

print('読み込み失敗')

sys.exit()

#１フレームだけ読み込んで　h ,w　を取り出す

ret, frame = cap.read()

h, w, ch = frame.shape # h,wの順３つ目は色数

# 書き込み設定（コーデックの指定）

time_str = str(datetime.datetime.now())

file_name = time_str[:10]+ '_' +time_str[11:13]+ time_str[14:16] + time_str[17:19] + '.avi'

print(time_str)

fourcc = cv2.VideoWriter_fourcc(*'XVID')

fps =30

dst = cv2.VideoWriter('output/' + file_name, fourcc, fps, (w,h)) # ファイル名設定 fps 解像度の順

# 背景差分の行列領域を確保

frame_back = np.zeros((h,w,ch),dtype=np.float32)

# アラート時間インターバルの初期化

previous_datetime = datetime.datetime.now()

# スクリプト実行

while True:

ret, frame = cap.read()

if ret == False:

break

# 画像処理

#frame2 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) # グレースケール

frame3= cv2.absdiff(frame.astype(np.float32), frame_back) # 背景差分

cv2.accumulateWeighted(frame,frame_back, 0.2)

# 差分の大きさ

pix_value= int(frame3.sum()/10000)

cv2.putText(frame, 'Pix_value:{}'.format(pix_value), (0, 50), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)

cv2.putText(frame3, 'Pix_value:{}'.format(pix_value), (0, 50), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)

# しきい値としきい値を超えたときに録画REC表示する

sreshold = 500

if pix_value > sreshold:

# ラインに通知する（ただし　前回通知から30sec以上間隔をあけること）

time_delta = datetime.datetime.now() - previous_datetime

if time_delta.seconds > 10:

# 画像をファイルに出力する

#os.mkdir('./output')

time_str = str(datetime.datetime.now())

file_name = time_str[:10]+ '_' +time_str[11:13]+ time_str[14:16] + time_str[17:19] + '.jpg'

cv2.imwrite('output/' + file_name, frame)

line_informer(file_name)

previous_datetime = datetime.datetime.now()

# REC表示

cv2.putText(frame, 'Jadge:{}'.format('REC'), (0, 100), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)

cv2.putText(frame3, 'Jadge:{}'.format('REC'), (0, 100), cv2.FONT_HERSHEY_PLAIN, 4, (255, 255, 255), 5, cv2.LINE_AA)

# REC保存

dst.write(frame)

# リアルタイム表示

cv2.imshow('img', frame)

#cv2.imshow('img2', frame2) #グレースケール

cv2.imshow('img3', frame3.astype(np.uint8)) # 背景差分

# 停止動作

if cv2.waitKey(30) == 27: # ESC=27

break

# 終了処理

cv2.destroyAllWindows()

cap.release()

以上

OpenCV:異物検出プログラム

Jetaon Nanoで異物を検出したいのですが、まずは使い慣れたPCで作ってみます。

カメラ

エレコム WEBカメラ 200万画素マイク内蔵 MAC対応ブラック UCAM-C0220FBNBK

2015年に買った、２０００円くらいの安物です。

レア過ぎて価格にプレミアがついていました。

インストール

参考にさせていただきました：https://www.kkaneko.jp/tools/win/cv2.html

Python3.7.7を入れました。最新の3.8.2はOpenCVが対応してない可能性があるのでやめておきました。

https://www.python.org/downloads/release/python-377/

Windows x86-64実行可能インストーラー

cmdでpythonとして、 3.7.7が起動させます。

pip listをすると

pip 19.2.3
setuptools 41.2.0
WARNING: You are using pip version 19.2.3, however version 20.0.2 is available.
You should consider upgrading via the ‘python -m pip install –upgrade pip’ command.

とバージョンアップを促されるので、

python -m pip install –upgrade pip

します。

numpyも入れてみましょう。

pip install numpy　で1.18.2が入りました。

ではVScodeを起動させて、メニュー>view > select interpriter で python 3.7.7を選択し・・・たいところですが、ありません。

一旦VScodeを起動させ（まだpython 3.7.7は表示されない。）、そしてVScode下部のターミナルで一旦pythonを起動させます。3.7.7が起動しました。

スクリプト実行を何回かさせて、numpyがないよー、と言われながら、interpriterの指定を開くと,python 3.7.7が選択できるようになっていました。

で、スクリプトを実行すると、今度はcv2がないよー、といわれましたので、cmdから

$ py -m pip install -U opencv-python

1	$ py -m pip install -U opencv-python

で入れました。opencv-python-4.2.0.34が入りました。

cmdでエラーが出るときは、Power Shellを管理者権限で開いてやってみましょう。

で、確認です。

> python
import cv2
cv2.__version__
'4.2.0'

> python

import cv2

cv2.__version__

'4.2.0'

その他のライブラリをインストール

VScodeをいじっているとpylintをいれてと促されるので

$ -m pip install -U pylint –user

いろんなライブラリも同時に勝手にはいりました。

Package Version
—————– ——–
astroid 2.3.3
colorama 0.4.3
isort 4.3.21
lazy-object-proxy 1.4.3
mccabe 0.6.1
numpy 1.18.2
opencv-python 4.2.0.34
pip 20.0.2
pylint 2.4.4
setuptools 41.2.0
six 1.14.0
typed-ast 1.4.1
wrapt 1.11.2

エラー

こんなんがでます、frame.shepeがわからないそうです。

File “c:/Users/keita/scripts/shihenDetector/main.py”, line 39, in <module>
height, width, channels = frame.shape
AttributeError: ‘NoneType’ object has no attribute ‘shape’

frame.shepe[:3]にして、カメラ番号を１から０に変更したら内蔵カメラが映りました。

webカメラをUSBに指して、カメラ番号１に戻したらこれでも映りました。

ということで[:3]は関係なかったと思われます。

画像処理

OpenCVで

案１：BGR画像→グレースケール→検査窓トリミング→現在画像→二値化

案２：BGR画像→グレースケール→検査窓トリミング→初期画像と現在画像を差分を取る→二値化

の２案をやってみましたが、結果的に案１を採用します。

案１は、背景が動いたりカメラが動いたりしたときでも、検出精度は変わらない利点があります。

案２は、初期画像と現在画像を比較するので、背景になんらかの均一でない構造があったとしても、初期画像と現在画像で比較するので異物検出のロバスト性が高くなる利点があります。しかし、背景が動いたりカメラが動いたりして、初期画像とのズレが発生するとと検出できないか検出精度が大幅に落ちます。

今回は、よりシンプルな案１でやっていきます。

結果

スクリプトを回すと自動的に時系列データがcsvファイルとして入ってきます、

グラフ化

作成されたcsvファイル読み込んでグラフ化しました。

横軸が時間、縦軸は検出された異物（黒）の画素数です。

検出画像

開始５秒の画像は異物がない、まっさらな状態です。影一つありません。

開始１５秒で5mm程度の異物を置いてみました。黒い点が現れます。

開始６０秒で1mmと5mm程度の異物を置いてみました。どちらも黒い点になって現れます。２００万画素の安物カメラでもこれだけの精度が用意に出ます。

周囲の照明コンディションが良ければ、0.5mm程度までは検出できそうです。

メインスクリプト

import numpy as np
import cv2
import datetime
import time


def interval_file_save(date, current_time, time_cnt, pixels_objects, pixels_percentile):

    # データをcsvファイルとして書き込む
    file_path = r'C:\Users\omoiy\scripts\shihenDetector\data\data.csv'
    with open(file_path, mode='a') as f:
        f.write(str(date) + ',' + str(current_time) + ',' + str(time_cnt)+ ',' + str(pixels_objects) + ',' + str(pixels_percentile) + '\n')

def onTrackber(position):
    # ２値化のスレショルド用トラックバー
    global threshold
    threshold = position
 
if __name__ == '__main__':
    # グローバル変数を定義
    ESC_KEY = 27     # Escキー
    INTERVAL= 33     # インターバル
    FRAME_RATE = 30  # フレームレートfps

    # 検出範囲を指定
    x_min = 150
    x_max = 640 - x_min
    y_min = 120
    y_max = 480 - y_min
    
    # 使用カメラの選択 1: 外部UVCカメラ
    DEVICE_ID = 1
 
    # カメラ映像を取得
    cap = cv2.VideoCapture(DEVICE_ID)
 
    # 初期フレームを読み込む
    end_flag, frame = cap.read()
    height, width, channels = frame.shape
    
    # 基準画像の定義
    img_bgr = frame
    img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY) # RGB to Gray:Y←0.299⋅R+0.587⋅G+0.114⋅B
    img_partial_gray = img_gray[y_min : y_max, x_min : x_max]
    img_reference = img_partial_gray

    # 初期フレームは以後のフレームより若干暗いので補正係数を掛けて調整する
    c = 1.0 # 補正係数
    img_reference = (img_reference * c ).astype('uint8') # 初期画像 以後、この画像を基準して参照する

    #２値化用トラックバー
    #cv2.namedWindow("img_diff_abs_adbinary")
    #threshold = 100  #初期値
    #cv2.createTrackbar("track", "img_diff_abs_adbinary", threshold, 255, onTrackber)

    # 画像処理
    date_init = datetime.datetime.now()
    pixels_objects = 0    # 初期値
    pixels_percentile = 0 # 初期値

    pixels_objects1 = 0    # 初期値
    pixels_percentile1 = 0 # 初期値

    # データ保存の時間間隔（インターバル）
    initial_time = datetime.datetime.now() # 初期値
    time_cnt = 0      # sec 初期値
    time_interval = 5 # sec 定期実行の時間間隔


    # OpenCV リアルタイム処理開始
    while end_flag == True:

        # 現在時間 sec
        current_time = (datetime.datetime.now() - initial_time).total_seconds()
 
        # 画像行列の取得と変換
        img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
        img_partial_gray = img_gray[y_min : y_max, x_min : x_max]

        # BGRカラー画像を表示する
        img_bgr = frame
        line_thickness = 10
        cv2.rectangle(img_bgr, (x_min-line_thickness, y_min-line_thickness),
                               (x_max+line_thickness, y_max+line_thickness),
                                color=(100,100,255), thickness = line_thickness)     
        cv2.imshow('img_bgr', img_bgr)

        # グレースケール画像を表示する    
        #cv2.imshow('img_gray', img_gray)

        # 基準画像を表示する
        cv2.imshow('img_referece', img_reference)

        # リアルタイム画像を表示する
        cv2.imshow('img_partial_gray', img_partial_gray)

        # リアルタイム画像と基準画像との差を算出して表示する (負の場合は絶対値が自動的に取られる)
        img_diff_abs = np.abs(img_partial_gray - img_reference)
        cv2.imshow('img_diff_abs', img_diff_abs)

        # リアルタイム画像と基準画像との差の２乗算出して表示する
        #img_diff_sqared = np.square(img_partial_gray - img_reference)
        #cv2.imshow('img_diff_sqared', img_diff_sqared)

        # リアルタイム画像と基準画像との差の画像をアダプティブスレッショルドで２値化する
        # img_diff_abs_adbinary = cv2.adaptiveThreshold(img_diff_abs, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, threshold) #アダプティブスレショルド
        # cv2.imshow("img_diff_abs_adbinary", img_diff_abs_adbinary)

        # リアルタイム画像と基準画像との差の画像を固定スレッショルドで２値化する
        ret, img_diff_abs_binary = cv2.threshold(img_diff_abs,127, 255, cv2.THRESH_BINARY) 


        # 上記img_diff_abs_binary画像の異物の画素数と割合を出力する(ただし１フレーム前)
        txt = str(time_cnt) + 's,' + str(pixels_objects) + 'pix,{:.2f}%'.format(pixels_percentile)
        cv2.putText(img=img_diff_abs_binary, text=txt, org=(10, 30),
                    fontFace=cv2.FONT_HERSHEY_PLAIN, fontScale=1.5,
                    color=(255, 255, 255), thickness=1, lineType=cv2.LINE_AA)
        
        cv2.imshow("img_diff_abs_binary", img_diff_abs_binary)



        # リアルタイム画像の画像を固定スレッショルドで２値化する
        ret, img_partial_gray_binary = cv2.threshold(img_partial_gray,127, 255, cv2.THRESH_BINARY) 

        # 上記img_partial_gray_binary画像の異物の画素数と割合を画面内に出力する(ただし１フレーム前)
        txt1 = str(time_cnt) + 's,' + str(pixels_objects1) + 'pix,{:.2f}%'.format(pixels_percentile1)
        cv2.putText(img=img_partial_gray_binary, text=txt1, org=(10, 30),
                    fontFace=cv2.FONT_HERSHEY_PLAIN, fontScale=1.5,
                    color=(0, 0, 0), thickness=1, lineType=cv2.LINE_AA)
        
        cv2.imshow("img_partial_gray_binary", img_partial_gray_binary )
        #cv2.imwrite(image_path + '.new.jpg', img)


        # ==== 異物の画素数をカウントする ====       

        # 検出窓の画素数
        pixels_window = (img_partial_gray_binary.shape[0] * img_partial_gray_binary.shape[1])

        # ---- 異物の画素数　と　割合 をターミナルに出力する ----

        # img_diff_abs_binary リアルタイム画像と基準画像との差の画像を固定スレッショルドで２値化した画像
        date = datetime.datetime.now()
        pixels_objects = np.count_nonzero(img_diff_abs_binary == 255)
        pixels_percentile = pixels_objects / pixels_window * 100
        print(date, ' : ',
              date - date_init, ' : ',
              '異物の画素数 / pixels: ', pixels_objects,
              '割合 / % : {:.2f}'.format(pixels_percentile)) 

        # img_partial_gray_binary リアルタイム画像の画像を固定スレッショルドで２値化した画像
        pixels_objects1 = np.count_nonzero(img_partial_gray_binary == 0)
        pixels_percentile1 = pixels_objects1 / pixels_window * 100
        print(date, ' : ',
              date - date_init, ' : ',
              '異物の画素数 / pixels: ', pixels_objects1,
              '割合 / % : {:.2f}'.format(pixels_percentile1)) 

        # ---- time_interval毎に定期実行する内容 ----
        if current_time >= time_cnt :

            # データをテキストデータとしてファイルに書き出す
            if time_cnt == 0:
                pixels_objects = 0 # フレーム1枚目はカメラの光量不足で大きな数値になってしまうので強制的にゼロにする
            else:
                interval_file_save(date, current_time, time_cnt, pixels_objects1, pixels_percentile1)

            # 画像データを保存する
            # file_path =  r'C:\Users\omoiy\scripts\shihenDetector\img.jpg'
            numbering = time_cnt
            file_path =  r'C:\Users\omoiy\scripts\shihenDetector\img\img_' + str(numbering) + r'.jpg'
            cv2.imwrite(file_path, img_partial_gray_binary)

            # 次回、定期実行する時刻 time_cntを更新
            time_cnt += time_interval # sec

        # Escキーで終了
        key = cv2.waitKey(INTERVAL)
        if key == ESC_KEY:
            break
 
        # 次のフレーム読み込み
        end_flag, frame = cap.read()
 
    # 終了処理
    cv2.destroyAllWindows()
    cap.release()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

import numpy as np

import cv2

import datetime

import time

def interval_file_save(date, current_time, time_cnt, pixels_objects, pixels_percentile):

# データをcsvファイルとして書き込む

file_path = r'C:\Users\omoiy\scripts\shihenDetector\data\data.csv'

with open(file_path, mode='a') as f:

f.write(str(date) + ',' + str(current_time) + ',' + str(time_cnt)+ ',' + str(pixels_objects) + ',' + str(pixels_percentile) + '\n')

def onTrackber(position):

# ２値化のスレショルド用トラックバー

global threshold

threshold = position

if __name__ == '__main__':

# グローバル変数を定義

ESC_KEY = 27 # Escキー

INTERVAL= 33 # インターバル

FRAME_RATE = 30 # フレームレートfps

# 検出範囲を指定

x_min = 150

x_max = 640 - x_min

y_min = 120

y_max = 480 - y_min

# 使用カメラの選択 1: 外部UVCカメラ

DEVICE_ID = 1

# カメラ映像を取得

cap = cv2.VideoCapture(DEVICE_ID)

# 初期フレームを読み込む

end_flag, frame = cap.read()

height, width, channels = frame.shape

# 基準画像の定義

img_bgr = frame

img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY) # RGB to Gray:Y←0.299⋅R+0.587⋅G+0.114⋅B

img_partial_gray = img_gray[y_min : y_max, x_min : x_max]

img_reference = img_partial_gray

# 初期フレームは以後のフレームより若干暗いので補正係数を掛けて調整する

c = 1.0 # 補正係数

img_reference = (img_reference * c ).astype('uint8') # 初期画像以後、この画像を基準して参照する

#２値化用トラックバー

#cv2.namedWindow("img_diff_abs_adbinary")

#threshold = 100 #初期値

#cv2.createTrackbar("track", "img_diff_abs_adbinary", threshold, 255, onTrackber)

# 画像処理

date_init = datetime.datetime.now()

pixels_objects = 0 # 初期値

pixels_percentile = 0 # 初期値

pixels_objects1 = 0 # 初期値

pixels_percentile1 = 0 # 初期値

# データ保存の時間間隔（インターバル）

initial_time = datetime.datetime.now() # 初期値

time_cnt = 0 # sec 初期値

time_interval = 5 # sec 定期実行の時間間隔

# OpenCV リアルタイム処理開始

while end_flag == True:

# 現在時間 sec

current_time = (datetime.datetime.now() - initial_time).total_seconds()

# 画像行列の取得と変換

img_gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)

img_partial_gray = img_gray[y_min : y_max, x_min : x_max]

# BGRカラー画像を表示する

img_bgr = frame

line_thickness = 10

cv2.rectangle(img_bgr, (x_min-line_thickness, y_min-line_thickness),

(x_max+line_thickness, y_max+line_thickness),

color=(100,100,255), thickness = line_thickness)

cv2.imshow('img_bgr', img_bgr)

# グレースケール画像を表示する

#cv2.imshow('img_gray', img_gray)

# 基準画像を表示する

cv2.imshow('img_referece', img_reference)

# リアルタイム画像を表示する

cv2.imshow('img_partial_gray', img_partial_gray)

# リアルタイム画像と基準画像との差を算出して表示する (負の場合は絶対値が自動的に取られる)

img_diff_abs = np.abs(img_partial_gray - img_reference)

cv2.imshow('img_diff_abs', img_diff_abs)

# リアルタイム画像と基準画像との差の２乗算出して表示する

#img_diff_sqared = np.square(img_partial_gray - img_reference)

#cv2.imshow('img_diff_sqared', img_diff_sqared)

# リアルタイム画像と基準画像との差の画像をアダプティブスレッショルドで２値化する

# img_diff_abs_adbinary = cv2.adaptiveThreshold(img_diff_abs, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 3, threshold) #アダプティブスレショルド

# cv2.imshow("img_diff_abs_adbinary", img_diff_abs_adbinary)

# リアルタイム画像と基準画像との差の画像を固定スレッショルドで２値化する

ret, img_diff_abs_binary = cv2.threshold(img_diff_abs,127, 255, cv2.THRESH_BINARY)

# 上記img_diff_abs_binary画像の異物の画素数と割合を出力する(ただし１フレーム前)

txt = str(time_cnt) + 's,' + str(pixels_objects) + 'pix,{:.2f}%'.format(pixels_percentile)

cv2.putText(img=img_diff_abs_binary, text=txt, org=(10, 30),

fontFace=cv2.FONT_HERSHEY_PLAIN, fontScale=1.5,

color=(255, 255, 255), thickness=1, lineType=cv2.LINE_AA)

cv2.imshow("img_diff_abs_binary", img_diff_abs_binary)

# リアルタイム画像の画像を固定スレッショルドで２値化する

ret, img_partial_gray_binary = cv2.threshold(img_partial_gray,127, 255, cv2.THRESH_BINARY)

# 上記img_partial_gray_binary画像の異物の画素数と割合を画面内に出力する(ただし１フレーム前)

txt1 = str(time_cnt) + 's,' + str(pixels_objects1) + 'pix,{:.2f}%'.format(pixels_percentile1)

cv2.putText(img=img_partial_gray_binary, text=txt1, org=(10, 30),

fontFace=cv2.FONT_HERSHEY_PLAIN, fontScale=1.5,

color=(0, 0, 0), thickness=1, lineType=cv2.LINE_AA)

cv2.imshow("img_partial_gray_binary", img_partial_gray_binary )

#cv2.imwrite(image_path + '.new.jpg', img)

# ==== 異物の画素数をカウントする ====

# 検出窓の画素数

pixels_window = (img_partial_gray_binary.shape[0] * img_partial_gray_binary.shape[1])

# ---- 異物の画素数　と　割合をターミナルに出力する ----

# img_diff_abs_binary リアルタイム画像と基準画像との差の画像を固定スレッショルドで２値化した画像

date = datetime.datetime.now()

pixels_objects = np.count_nonzero(img_diff_abs_binary == 255)

pixels_percentile = pixels_objects / pixels_window * 100

print(date, ' : ',

date - date_init, ' : ',

'異物の画素数 / pixels: ', pixels_objects,

'割合 / % : {:.2f}'.format(pixels_percentile))

# img_partial_gray_binary リアルタイム画像の画像を固定スレッショルドで２値化した画像

pixels_objects1 = np.count_nonzero(img_partial_gray_binary == 0)

pixels_percentile1 = pixels_objects1 / pixels_window * 100

print(date, ' : ',

date - date_init, ' : ',

'異物の画素数 / pixels: ', pixels_objects1,

'割合 / % : {:.2f}'.format(pixels_percentile1))

# ---- time_interval毎に定期実行する内容 ----

if current_time >= time_cnt :

# データをテキストデータとしてファイルに書き出す

if time_cnt == 0:

pixels_objects = 0 # フレーム1枚目はカメラの光量不足で大きな数値になってしまうので強制的にゼロにする

else:

interval_file_save(date, current_time, time_cnt, pixels_objects1, pixels_percentile1)

# 画像データを保存する

# file_path = r'C:\Users\omoiy\scripts\shihenDetector\img.jpg'

numbering = time_cnt

file_path = r'C:\Users\omoiy\scripts\shihenDetector\img\img_' + str(numbering) + r'.jpg'

cv2.imwrite(file_path, img_partial_gray_binary)

# 次回、定期実行する時刻 time_cntを更新

time_cnt += time_interval # sec

# Escキーで終了

key = cv2.waitKey(INTERVAL)

if key == ESC_KEY:

break

# 次のフレーム読み込み

end_flag, frame = cap.read()

# 終了処理

cv2.destroyAllWindows()

cap.release()

グラフ作成スクリプト

pandasとmatplotlibを使うのでインストールします。

pip install pandas

installed pandas-1.0.3 python-dateutil-2.8.1 pytz-2019.3

pip install matplotlib

installed cycler-0.10.0 kiwisolver-1.2.0 matplotlib-3.2.1 pyparsing-2.4.7

はい、ではスクリプト実行しましょう。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

file_path = r'C:\Users\omoiy\scripts\shihenDetector\data\data.csv'

df = pd.read_csv(file_path, sep=',', names=('date', 'current_time','time_cnt', 'pixels', 'ratio'))

print(df.head())
#print(df.current_time, df.time_cnt)
plt.plot(df['time_cnt'], df['pixels'], label='pixels')
plt.title('Object Pixels', fontsize=18)
plt.xlabel('Time / sec', fontsize=18)
plt.ylabel('Pixels', fontsize=18)
plt.legend(loc='best', fontsize=18)
plt.grid()
plt.show()

# time_cntとcurrent_timeとのズレを確認　: 0~70sec
# plt.plot(df.time_cnt, df.current_time-df.time_cnt)
# plt.show()

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

file_path = r'C:\Users\omoiy\scripts\shihenDetector\data\data.csv'

df = pd.read_csv(file_path, sep=',', names=('date', 'current_time','time_cnt', 'pixels', 'ratio'))

print(df.head())

#print(df.current_time, df.time_cnt)

plt.plot(df['time_cnt'], df['pixels'], label='pixels')

plt.title('Object Pixels', fontsize=18)

plt.xlabel('Time / sec', fontsize=18)

plt.ylabel('Pixels', fontsize=18)

plt.legend(loc='best', fontsize=18)

plt.grid()

plt.show()

# time_cntとcurrent_timeとのズレを確認　: 0~70sec

# plt.plot(df.time_cnt, df.current_time-df.time_cnt)

# plt.show()

以上です。

shihenDetector

IOT:ラズベリーパイにVNC接続してOpenCVで顔認識する

どーもこんにちは(´・ω・`)です。

前回、ラズベリーパイにVNC接続してOpenCVでカメラの起動に成功しました。

今回は更に、そのOpenCVで顔認識も追加していこうと思います。

bcm2835-v4l2　の自動化

前回ハマりました、bcm2835-v4l2　についてですが、やはりシャットダウンすると、無効になってしまい、OpenCVが機能しませんでした。

今回は、まず起動したときに自動的にbcm2835-v4l2　が実行される方法からやっていきます。

/etc/modules を開くと

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with “#” are ignored.

i2c-dev

と書いてありますが、これは”ブートするときにロードするためのカーネルモジュール群”　を書いておく場所になっています。Windowsでいうとスタートアップです。

ここにbcm2835-v4l2をいれればOKなのですが、このファイルは書き込み禁止なので、予め解除しておきます。

ファイル書き込み禁止を解除する

パーミッションを確認します。

pi@pi:/etc $ ls -l modules

-rw-r–r– 1 root root 203 3月 23 20:29 modules

スーパーユーザーsudoとしてチェンジモードchmodして、パーミッションを777にします。

pi@pi:/etc $ sudo chmod 777 modules

で、変更が成功したか確認すると
pi@pi:/etc $ ls -l modules

-rwxrwxrwx 1 root root 203 3月 23 20:29 modules

フルアクセスに変更されました。

その上で、チェンジディレクトリcd /etc/でvimでmodulesを開きます。

pi@pi:/etc $ vim modules

i2c-devの下にbcm2835-v4l2を追加して保存しましょう。

# /etc/modules: kernel modules to load at boot time.
#
# This file contains the names of kernel modules that should be loaded
# at boot time, one per line. Lines beginning with “#” are ignored.

i2c-dev
bcm2835-v4l2

キャットで確認すれば

pi@pi:/etc $ cat modules

しっかりとbcm2835-v4l2が追加されているのがわかると思います。

本題：Opencvで顔認識をやってみる

基本的には、前回のコードに学習済みハールカスケードと顔認識した顔に四角い図形でマーキングをするスクリプトを追加するだけです。

まずhaarcascade_frontalface_alt2.xmlは/usr/local/share/OpenCV/haarcascades/　の中に入っているので、作業ディレクトリであるhome/pi/の中へコピーを作っておきます。

import numpy as np
import cv2

if __name__ == '__main__':
    # グローバル変数を定義
    ESC_KEY = 27     # Escキー
    INTERVAL= 33     # インターバル
    FRAME_RATE = 30  # フレームレートfps
    
    # ウィンドウ名称を定義
    ORIGINAL_WINDOW_NAME = "original"
    GRAY_SCALE_WINDOW_NAME = "gray_scale"

    DEVICE_ID = 0

    # 学習済みの分類器を定義
    cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")

    # カメラ映像を取得
    cap = cv2.VideoCapture(DEVICE_ID)

    # 初期フレームを読み込む
    end_flag, frame = cap.read()
    height, width, channels = frame.shape

    # ウィンドウの準備
    cv2.namedWindow(ORIGINAL_WINDOW_NAME)
    cv2.namedWindow(GRAY_SCALE_WINDOW_NAME)

    # 画像処理
    while end_flag == True:

        # 画像の取得と顔の検出
        img = frame
        img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))

        # 検出した顔に四角いマーキングを付ける
        for (x, y, w, h) in face_list:
            color = (100, 100, 225) # GBR
            line_width = 3
            cv2.rectangle(img_gray, (x, y), (x+w, y+h), color, thickness = line_width)

        # フレームを表示
        cv2.imshow(ORIGINAL_WINDOW_NAME, frame)
        cv2.imshow(GRAY_SCALE_WINDOW_NAME, img_gray)

        # Escキーで終了
        key = cv2.waitKey(INTERVAL)
        if key == ESC_KEY:
            break

        # 次のフレーム読み込み
        end_flag, frame = cap.read()

    # 終了処理
    cv2.destroyAllWindows()
    cap.release()

import numpy as np

import cv2

if __name__ == '__main__':

# グローバル変数を定義

ESC_KEY = 27 # Escキー

INTERVAL= 33 # インターバル

FRAME_RATE = 30 # フレームレートfps

# ウィンドウ名称を定義

ORIGINAL_WINDOW_NAME = "original"

GRAY_SCALE_WINDOW_NAME = "gray_scale"

DEVICE_ID = 0

# 学習済みの分類器を定義

cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")

# カメラ映像を取得

cap = cv2.VideoCapture(DEVICE_ID)

# 初期フレームを読み込む

end_flag, frame = cap.read()

height, width, channels = frame.shape

# ウィンドウの準備

cv2.namedWindow(ORIGINAL_WINDOW_NAME)

cv2.namedWindow(GRAY_SCALE_WINDOW_NAME)

# 画像処理

while end_flag == True:

# 画像の取得と顔の検出

img = frame

img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

face_list = cascade.detectMultiScale(img_gray, minSize=(100, 100))

# 検出した顔に四角いマーキングを付ける

for (x, y, w, h) in face_list:

color = (100, 100, 225) # GBR

line_width = 3

cv2.rectangle(img_gray, (x, y), (x+w, y+h), color, thickness = line_width)

# フレームを表示

cv2.imshow(ORIGINAL_WINDOW_NAME, frame)

cv2.imshow(GRAY_SCALE_WINDOW_NAME, img_gray)

# Escキーで終了

key = cv2.waitKey(INTERVAL)

if key == ESC_KEY:

break

# 次のフレーム読み込み

end_flag, frame = cap.read()

# 終了処理

cv2.destroyAllWindows()

cap.release()

以上、簡単ですね。

IOT:ラズベリーパイにVNC接続してOpenCVで cv2.VideoCapture(0)してみる

どーもこんにちはKeita_Nakamori(´・ω・`)です。

今日は、WindowsマシンからラズベリーパイにVNC接続してOpenCVで cv2.VideoCapture(0)に挑戦します。

まずはrealVNC viewerを起動してIPアドレスを打ってVNC接続します。

1回つなげたことのあるIPアドレスは保存され、アイコンみたいに表示されるので２回目からはアイコンをクリックするだけの簡単操作でした。

落とし穴

早速ハマりました。cap=cv2.VideoCapture(0)してもcapにはなにもデータが入ってきません。ふぁ～(*´Д｀)

ret, img = cap.read() しても、当然imgはNoneです。

なぜだ！

思い出しました

そう、かつてハマりまくった、あのときを・・・

ラズパイ専用カメラをしようしているので、一般的なwebカメラとして認識できるように下記のコードを実行することが必要でした。

注意点としては最後の部分は　「ぶい　よん　える　に」　です。

「ぶい　よん　いち　に」　だと思って奮闘してしまいました。

sudo modprobe bcm2835-v4l2

ということで、shellでsudo modprobe bcm2835-v4l2と打ってカメラを認識させます。

テストコードを実行すると・・・

はい、隣の部屋のソファーが写っています。

弱点

ラズパイはwifi接続、Windowsマシンは有線ですが、VNC解像度をミディアムにしても、カメラのキャプチャー映像はガックガク！！です。

低解像度だと色がキッタナイ！

どうにもなりません。

念の為、試運転のコードを貼っておきます。

# -*- coding: utf-8 -*-
import numpy as np
import cv2

cap = cv2.VideoCapture(0)

while(True):
    # Capture frame-by-frame
    ret, frame = cap.read()

    # Our operations on the frame come here
    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

    # Display the resulting frame
    cv2.imshow('frame',frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

# When everything done, release the capture
cap.release()
cv2.destroyAllWindows()

# -*- coding: utf-8 -*-

import numpy as np

import cv2

cap = cv2.VideoCapture(0)

while(True):

# Capture frame-by-frame

ret, frame = cap.read()

# Our operations on the frame come here

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

# Display the resulting frame

cv2.imshow('frame',frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

# When everything done, release the capture

cap.release()

cv2.destroyAllWindows()

OpenCV：python 画像追跡

こんにちは、かずまなぶです(*’ω’*)　

動画中の物体を追跡する方法を勉強しました。メモを貼っておきます。

https://ensekitt.hatenablog.com/entry/2017/12/19/200000

# coding: utf-8

# In[ ]:


#色検出：動画から色を抜き出す
import cv2
import numpy as np

capture=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/mobility.mp4")
while True:
    #ウィンドウサイズを小さくしておく（元画像が大きすぎる）
    cv2.namedWindow("img",cv2.WINDOW_NORMAL)
    cv2.resizeWindow("img",640,480)
    
    #１フレームだけ読み込む
    ret,frame=capture.read()
    
    if ret==False: #最終フレームなら抜ける
        break
    
    hsv=cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)#読み込んだ１フレームをBGRからHSV形式に変換する
    
    #黄色っぽい色を定義
    lower=np.array([20,50,50])#Hue=20とすると実際は40になる
    upper=np.array([25,255,255])
    frame_mask=cv2.inRange(hsv,lower,upper)#hsvと黄色の定義を渡す
    dst=cv2.bitwise_and(frame,frame,mask=frame_mask)#２値画像の論理積（共通する部分）を取り出す。mask黄色だけが抽出される
    
    #画像を表示する
    cv2.imshow("img",dst)
    if cv2.waitKey(10)==27:
        break
       
cv2.destroyAllWindows()
    

# オプティカルフロー　：　動画中の特徴点を追跡する
（１）特徴点を見つける
（２）特徴点とその周りは同じ方向へ流れると仮定して
　　　フローベクトを求める

フローベクトルを求める 特徴点の画素値I
I(x,y,t)=I(x+⊿x,y+⊿y,t+⊿t)

右辺をテーラー展開して、１次の項までを採用すると
I(x+⊿x,y+⊿y,t+⊿t)=I(x,y,t)[1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t]

よって、元の式は
I(x,y,t)=I(x,y,t)[1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t]
1=1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t
(∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t=0

ここで偏微分を
(∂I/∂x)=Ix
(∂I/∂y)=Iy
(∂I/∂t)=It
とおくと

I(x,y,t)=I(x,y,t)[1+ (Ix*⊿x) + (Iy*⊿y) + (It*⊿t)]
なので
1=1+ (Ix*⊿x) + (Iy*⊿y) + (It*⊿t)
(Ix*⊿x) + (Iy*⊿y) + (It*⊿t)=0

さらに両辺を⊿tで割ると
(Ix*⊿x/⊿t) + (Iy*⊿y/⊿t) +It=0
ここで
⊿x/⊿t=u
⊿y/⊿t=v
とおくと
(Ix*u) + (Iy*v) +It=0
(Ix,Iy)*(u,v)+It=0
このベクトル(u,v)をフローベクトルという。
特徴点の周辺のフローベクトルと連立させて解く

参考URL：https://www.slideshare.net/hitoshinishimura75/lucas-kanade
# In[ ]:


import cv2
#動画サイズを小さくしておく
cv2.namedWindow("img",cv2.WINDOW_NORMAL)
cv2.resizeWindow("img",1200,800)

#パラメータの設定
COUNT=500 # 500点　特徴点を検出する

"""ルーカス・カナデ法
  画像ピラミッド：解像度を落とした画像を段階的に作って、軽くした状態で特徴点を分析する
  winSize：ウィンドウサイズ　探索窓の大きさ
  maxLevel：ピラミッドの階層の数
  収束条件：最大反復回数　もしくは　値が動かなくなったら
"""
criterita=(cv2.TERM_CRITERIA_MAX_ITER|cv2.TERM_CRITERIA_EPS,20,0.03)
lucas_kanade_params=dict(winSize=(10,10),maxLevel=4,criteria=criterita)

#1フレームを読み込む
capture=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cosmos.mp4")
ret,frame=capture.read()
frame_pre=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化して、一個前のフレームとして定義する

while True:
    ret,frame=capture.read()
    if ret==False:#画像がなくなったらブレークする
        break
        
    frame_now=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化した画像を現在フレームとする
    feature_pre=cv2.goodFeaturesToTrack(frame_pre,COUNT,0.001,5)#追いかけるべき特徴点を見つける コーナー検出精度、コーナー間の最低限の距離
    
    if feature_pre is None:#特徴点がなかったら、再びwhile文の先頭に戻って、また次のフレームを読み込んでくる
        continue
        
    #うまく特徴点を見つけられたら
    feature_now,status,err=cv2.calcOpticalFlowPyrLK(frame_pre,frame_now,feature_pre,None,**lucas_kanade_params)#ルーカスカナデ本体
    
    #描画する
    for i in range(COUNT):
        pre_x=feature_pre[i][0][0]
        pre_y=feature_pre[i][0][1]
        now_x=feature_now[i][0][0]
        now_y=feature_now[i][0][1]
        cv2.line(frame,(pre_x,pre_y),(now_x,now_y),(255,0,0),3)
    cv2.imshow("img",frame)
    frame_pre=frame_now.copy()
    
    if cv2.waitKey(10)==27:
        break

cv2.destroyAllWindows()

# MeanShift / CamShift
ピクセル密度（画素値）が最大の場所へ向かっていく
①ある場所から探索窓が出発する（ユーザーが指定）
②探索窓内の画素値の重心を計算する
③探索窓の中心を重心に移す
②③を繰り返す
CamShiftは窓の大きさが可変になる
# In[ ]:


import cv2

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cruse.mp4")
ret,frame=cap.read()
h,w,ch=frame.shape#動画サイズを抜き出す

rct=(600,500,100,100)#探索窓の開始点x,y,窓の大きさ⊿x,⊿y
cv2.namedWindow("win",cv2.WINDOW_NORMAL) #名前を付ける
cv2.resizeWindow("win",1200,800)#動画の名前を指定して、動画サイズの変更
criteria=(cv2.TERM_CRITERIA_COUNT|cv2.TERM_CRITERIA_EPS,10,1) #反復回数の閾値（１０回動いたら　または　１ピクセルしか動かなくなったら）

while True:
    threshold=100#二値化の閾値
    ret,frame=cap.read()#まずは１フレームを読み込む
    
    if ret==False:#最後まで読み込んでいたらブレークで終わる
        break
    
    img_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化する
    ret,img_bin=cv2.threshold(img_gray,threshold,255,cv2.THRESH_BINARY)#グレースケールを二値化する
    ret,rct=cv2.CamShift(img_bin,rct,criteria)#二値化画像をmeanShift または CamShiftしてrct（四角）を得る
    x,y,w,h=rct#rct：四角の座標と大きさ
    frame=cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),3)#四角を書く
    #frame=cv2.rectangle(img_bin,(x,y),(x+w,y+h),(255,0,0),3)#四角を書く
    cv2.imshow("win",frame) # frame　または　img_bin
    
    if cv2.waitKey(10)==27:
        break
        
cv2.destroyAllWindows()

#背景差分
背景かそれ以外かを分離することができる
現在フレーム-背景フレーム=背景差分
# In[ ]:


import cv2
import numpy as np

cv2.namedWindow("img",cv2.WINDOW_NORMAL)
cv2.resizeWindow("img",1200,800)
cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Pepole.mp4")
ret,frame=cap.read()#１フレームだけ読む
h,w,ch=frame.shape
frame_back=np.zeros((h,w,ch),dtype=np.float32)#float32に指定しないと差分をとれない
while True:
    ret,frame=cap.read()#１フレームだけ読む
    
    if ret==False:
        break
        
    frame_diff=cv2.absdiff(frame.astype(np.float32),frame_back)#差分を作る
    cv2.accumulateWeighted(frame,frame_back,0.03)#3%ずつ混ぜていく：
    
    #フレームバックをだんだんフレームに近づけていく
    #移動しているものは白く映る
    cv2.imshow("img",frame_diff.astype(np.uint8))
    
    if cv2.waitKey(10)==27:
        break

cv2.destroyAllWindows()   


# In[1]:


#パーティクルフィルター
import cv2
import numpy as np
import random2
import likelihood as li

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Tram.mp4")
ret,frame=cap.read()
h,w=frame.shape[:2]
np.random.seed(100)
Np=500
px=np.zeros((Np),dtype=np.int64)
py=np.zeros((Np),dtype=np.int64)
lp=np.zeros((Np))
for i in range(Np):
    px[i]=int(np.random.uniform(0,w))
    py[i]=int(np.random.uniform(0,h))
obj=[0,110,160]

while True:
    ret,frame=cap.read()
    if ret==False:
        break
    lp=li.likelihood(frame,px,py,obj,Np,sigma2=0.001)
    pxnew=np.array(random2.choices(population=px,weights=lp,k=Np))+np.random.randint(-15,15,Np)
    pynew=np.array(random2.choices(population=py,weights=lp,k=Np))+np.random.randint(-15,15,Np)   
    px=np.where(pxnew>w-1,w-1,pxnew)
    py=np.where(pynew>h-1,h-1,pynew)
    px=np.where(px<0,0,px)
    py=np.where(py<0,0,py)
    
    for i in range(Np):
        cv2.circle(frame,(px[i],py[i]),1,(0,255,0),1)
    
    cv2.imshow("img",frame)
        
    if cv2.waitKey(10)==27:
        break
        
cv2.destroyAllWindows()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

# coding: utf-8

# In[ ]:

#色検出：動画から色を抜き出す

import cv2

import numpy as np

capture=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/mobility.mp4")

while True:

#ウィンドウサイズを小さくしておく（元画像が大きすぎる）

cv2.namedWindow("img",cv2.WINDOW_NORMAL)

cv2.resizeWindow("img",640,480)

#１フレームだけ読み込む

ret,frame=capture.read()

if ret==False: #最終フレームなら抜ける

break

hsv=cv2.cvtColor(frame,cv2.COLOR_BGR2HSV)#読み込んだ１フレームをBGRからHSV形式に変換する

#黄色っぽい色を定義

lower=np.array([20,50,50])#Hue=20とすると実際は40になる

upper=np.array([25,255,255])

frame_mask=cv2.inRange(hsv,lower,upper)#hsvと黄色の定義を渡す

dst=cv2.bitwise_and(frame,frame,mask=frame_mask)#２値画像の論理積（共通する部分）を取り出す。mask黄色だけが抽出される

#画像を表示する

cv2.imshow("img",dst)

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

# オプティカルフロー　：　動画中の特徴点を追跡する

（１）特徴点を見つける

（２）特徴点とその周りは同じ方向へ流れると仮定して

　　　フローベクトを求める

フローベクトルを求める特徴点の画素値I

I(x,y,t)=I(x+⊿x,y+⊿y,t+⊿t)

右辺をテーラー展開して、１次の項までを採用すると

I(x+⊿x,y+⊿y,t+⊿t)=I(x,y,t)[1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t]

よって、元の式は

I(x,y,t)=I(x,y,t)[1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t]

1=1+ (∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t

(∂I/∂x)*⊿x + (∂I/∂y)*⊿y + (∂I/∂t)*⊿t=0

ここで偏微分を

(∂I/∂x)=Ix

(∂I/∂y)=Iy

(∂I/∂t)=It

とおくと

I(x,y,t)=I(x,y,t)[1+ (Ix*⊿x) + (Iy*⊿y) + (It*⊿t)]

なので

1=1+ (Ix*⊿x) + (Iy*⊿y) + (It*⊿t)

(Ix*⊿x) + (Iy*⊿y) + (It*⊿t)=0

さらに両辺を⊿tで割ると

(Ix*⊿x/⊿t) + (Iy*⊿y/⊿t) +It=0

ここで

⊿x/⊿t=u

⊿y/⊿t=v

とおくと

(Ix*u) + (Iy*v) +It=0

(Ix,Iy)*(u,v)+It=0

このベクトル(u,v)をフローベクトルという。

特徴点の周辺のフローベクトルと連立させて解く

参考URL：https://www.slideshare.net/hitoshinishimura75/lucas-kanade

# In[ ]:

import cv2

#動画サイズを小さくしておく

cv2.namedWindow("img",cv2.WINDOW_NORMAL)

cv2.resizeWindow("img",1200,800)

#パラメータの設定

COUNT=500 # 500点　特徴点を検出する

"""ルーカス・カナデ法

画像ピラミッド：解像度を落とした画像を段階的に作って、軽くした状態で特徴点を分析する

winSize：ウィンドウサイズ　探索窓の大きさ

maxLevel：ピラミッドの階層の数

収束条件：最大反復回数　もしくは　値が動かなくなったら

"""

criterita=(cv2.TERM_CRITERIA_MAX_ITER|cv2.TERM_CRITERIA_EPS,20,0.03)

lucas_kanade_params=dict(winSize=(10,10),maxLevel=4,criteria=criterita)

#1フレームを読み込む

capture=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cosmos.mp4")

ret,frame=capture.read()

frame_pre=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化して、一個前のフレームとして定義する

while True:

ret,frame=capture.read()

if ret==False:#画像がなくなったらブレークする

break

frame_now=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化した画像を現在フレームとする

feature_pre=cv2.goodFeaturesToTrack(frame_pre,COUNT,0.001,5)#追いかけるべき特徴点を見つけるコーナー検出精度、コーナー間の最低限の距離

if feature_pre is None:#特徴点がなかったら、再びwhile文の先頭に戻って、また次のフレームを読み込んでくる

continue

#うまく特徴点を見つけられたら

feature_now,status,err=cv2.calcOpticalFlowPyrLK(frame_pre,frame_now,feature_pre,None,**lucas_kanade_params)#ルーカスカナデ本体

#描画する

for i in range(COUNT):

pre_x=feature_pre[i][0][0]

pre_y=feature_pre[i][0][1]

now_x=feature_now[i][0][0]

now_y=feature_now[i][0][1]

cv2.line(frame,(pre_x,pre_y),(now_x,now_y),(255,0,0),3)

cv2.imshow("img",frame)

frame_pre=frame_now.copy()

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

# MeanShift / CamShift

ピクセル密度（画素値）が最大の場所へ向かっていく

①ある場所から探索窓が出発する（ユーザーが指定）

②探索窓内の画素値の重心を計算する

③探索窓の中心を重心に移す

②③を繰り返す

CamShiftは窓の大きさが可変になる

# In[ ]:

import cv2

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cruse.mp4")

ret,frame=cap.read()

h,w,ch=frame.shape#動画サイズを抜き出す

rct=(600,500,100,100)#探索窓の開始点x,y,窓の大きさ⊿x,⊿y

cv2.namedWindow("win",cv2.WINDOW_NORMAL) #名前を付ける

cv2.resizeWindow("win",1200,800)#動画の名前を指定して、動画サイズの変更

criteria=(cv2.TERM_CRITERIA_COUNT|cv2.TERM_CRITERIA_EPS,10,1) #反復回数の閾値（１０回動いたら　または　１ピクセルしか動かなくなったら）

while True:

threshold=100#二値化の閾値

ret,frame=cap.read()#まずは１フレームを読み込む

if ret==False:#最後まで読み込んでいたらブレークで終わる

break

img_gray=cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#グレースケール化する

ret,img_bin=cv2.threshold(img_gray,threshold,255,cv2.THRESH_BINARY)#グレースケールを二値化する

ret,rct=cv2.CamShift(img_bin,rct,criteria)#二値化画像をmeanShift または CamShiftしてrct（四角）を得る

x,y,w,h=rct#rct：四角の座標と大きさ

frame=cv2.rectangle(frame,(x,y),(x+w,y+h),(255,0,0),3)#四角を書く

#frame=cv2.rectangle(img_bin,(x,y),(x+w,y+h),(255,0,0),3)#四角を書く

cv2.imshow("win",frame) # frame　または　img_bin

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

#背景差分

背景かそれ以外かを分離することができる

現在フレーム-背景フレーム=背景差分

# In[ ]:

import cv2

import numpy as np

cv2.namedWindow("img",cv2.WINDOW_NORMAL)

cv2.resizeWindow("img",1200,800)

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Pepole.mp4")

ret,frame=cap.read()#１フレームだけ読む

h,w,ch=frame.shape

frame_back=np.zeros((h,w,ch),dtype=np.float32)#float32に指定しないと差分をとれない

while True:

ret,frame=cap.read()#１フレームだけ読む

if ret==False:

break

frame_diff=cv2.absdiff(frame.astype(np.float32),frame_back)#差分を作る

cv2.accumulateWeighted(frame,frame_back,0.03)#3%ずつ混ぜていく：

#フレームバックをだんだんフレームに近づけていく

#移動しているものは白く映る

cv2.imshow("img",frame_diff.astype(np.uint8))

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

# In[1]:

#パーティクルフィルター

import cv2

import numpy as np

import random2

import likelihood as li

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Tram.mp4")

ret,frame=cap.read()

h,w=frame.shape[:2]

np.random.seed(100)

Np=500

px=np.zeros((Np),dtype=np.int64)

py=np.zeros((Np),dtype=np.int64)

lp=np.zeros((Np))

for i in range(Np):

px[i]=int(np.random.uniform(0,w))

py[i]=int(np.random.uniform(0,h))

obj=[0,110,160]

while True:

ret,frame=cap.read()

if ret==False:

break

lp=li.likelihood(frame,px,py,obj,Np,sigma2=0.001)

pxnew=np.array(random2.choices(population=px,weights=lp,k=Np))+np.random.randint(-15,15,Np)

pynew=np.array(random2.choices(population=py,weights=lp,k=Np))+np.random.randint(-15,15,Np)

px=np.where(pxnew>w-1,w-1,pxnew)

py=np.where(pynew>h-1,h-1,pynew)

px=np.where(px<0,0,px)

py=np.where(py<0,0,py)

for i in range(Np):

cv2.circle(frame,(px[i],py[i]),1,(0,255,0),1)

cv2.imshow("img",frame)

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

OpenCVで画像処理

こんにちは　かずまなぶです(*’ω’*)

今日はOpenCVの使い方を学びました。ひたすらメモを残していきます！！

近日、この知識を元に、ラズパイカメラで寸法測定を行うということをやる予定です。

http://toyo-interest.com/rasbery-pi3-b%E3%81%A8opencv%E3%81%A7%e3%80%80%E3%81%99%E3%81%8D%E3%81%BE%E3%82%92%E6%B8%AC%E5%AE%9A%E3%81%97%E3%81%9F%E3%81%84-1/

以下、ひたすらメモ

# coding: utf-8
# OpenCVを学ぶ

画素値は(B,G,R) 0-255で表現する。
画像の左上が原点(0,0)

#画像処理＝解析しやすくする。情報を抽出する
（１）グレースケール化+平滑化
①Gray=0.1140B+0.5870G+0.2989R
②平滑化出力画像=(I*G)
　ノイズ画素を指定したとき、その周辺の画素データになじむように自分の画素データを修正する。
　ガウシアンカーネル（代表的な平滑化カーネル）　グレースケールの画像に畳み込む
gaussian=np.array([[1/16,2/16,/1/16],
                   [2/16,4/16,/2/16],
                   [1/16,2/16,/1/16]])
                   
（２）グレースケール化+Canny
①Gray=0.1140B+0.5870G+0.2989R
②canny
ぼかす→微分→エッジを残す

sift surfは特許で使えないものもある
# In[ ]:


#OpenCVのコンテンツ
グレースケール
２値化
リサイズ
ガンマ変換
ヒストグラム均一化

アフィン変換
畳み込み（平滑化の一部）
平滑化
モルフォロジー演算
インペイント

#特徴抽出
線　円の検出
輪郭の検出
ブロブの検出
特徴点抽出

#動画解析
オプティカルフロー
Meansift / Camshift
背景差分
パーティクルフィルター

#そのほか
カメラモデル　機械学習　sift surf 
# In[ ]:


#on anaconda pronpt

#conda create :新たな環境を作る
#-n opencv : opencvというnameの環境
#python=3.5:opencv3はpython3.5が最大 3.6には対応していないのでダウングレードして使用する
conda create -n opencv python=3.5 anaconda

#環境が作成されているか確認する
conda info -e

activate opency              #環境に入る
deactivate                   #環境から抜ける
conda remove -n opencv --all #環境を削除（今回はやらない）

#OpenCVのインストール (環境名opencv　上にインストール)
conda install -c menpo opencv3

#インストールされたか確認
ipython #ipythonに入る
import cv2 # cv3でもcv2と記載する。ややこしいので注意


# In[ ]:


#画像の基礎知識
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")
print(type(img))#画素値は(B,G,R) 0-255で表現する。<class 'numpy.ndarray'>
h,w=img.shape[0:2] #高さ、幅　、3つ目の成分もあるが　なぞ
img.shape #(589, 960, 3)
print(h,w)         #589 960


# In[ ]:


#y,x座標を指定して　blue成分の値を取得する
img[300][500][0] # 104  img[y][x][color] color:B=0 ro G=1 or R=2


# In[ ]:


#画像の読み込み,表示と出力
import cv2 , os
img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")
img.shape   #(589, 960, 3)
img[0][0]   #原点での色情報BGR　array([128, 176, 194], dtype=uint8)

cv2.imshow("title",img)
cv2.waitKey(0) #3を入れると3msecキーボード入力を受け付ける。0はなにか押されるまで待つ　という意味
cv2.destroyAllWindows()

os.mkdir("./output")
cv2.imwrite("output/test.jpg",img) # True


# In[ ]:


import cv2 , sys
cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cosmos.mp4")#読み込む
if cap.isOpened()==False: #開けたかチェックする
    sys.exit()
    
ret,frame=cap.read()#ret=開けたかどうか ,  frame=１フレーム読んだ画像
h,w=frame.shape[:2] #動画の解像度を取得。３番目の色情報は不要
print(h,w)          #1080 1920

fourcc=cv2.VideoWriter_fourcc(*"XVID")#コーデックの設定情報
fps=30.0 #fpsを設定する
dst=cv2.VideoWriter("output/test.avi",fourcc,fps,(w,h))#書き込む用　。解像度の入力は(x,y)で入れるので注意

#プログラムの本体
while True:
    ret,frame=cap.read() #ret=開けたかどうか ,  frame=１フレーム読んだ画像
    if ret==False:#ちゃんと読み込めなかった場合はブレークする
        break
    cv2.imshow("title",frame)#１コマを表示させる
    dst.write(frame)#動画を書き込む
    if cv2.waitKey(30)==27:#escキーが押されるとブレークする
        break
        
cv2.destroyAllWindows()
cap.release()


# In[ ]:


#ウィンドウの調整
import cv2
img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")
cv2.namedWindow("window",cv2.WINDOW_AUTOSIZE)#ウィンドウの設定
cv2.imshow("window",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


import cv2
img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")
cv2.namedWindow("window",cv2.WINDOW_NORMAL)#ウィンドウの設定 リサイズ可能になる
cv2.imshow("window",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


import cv2
img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")
cv2.namedWindow("window",cv2.WINDOW_NORMAL)#ウィンドウの設定 リサイズ可能になる
cv2.resizeWindow("window",640,480)#解像度を指定する（アスペクト比は変わる）
cv2.imshow("window",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像のリサイズ
import cv2
img=cv2.imread(r"C:\Users\omoiy\data\src/Grapes.jpg")
#cv2.imshow("window",img)
#cv2.waitKey(0)
#cv2.destroyAllWindows()
img.shape      # (640, 960, 3) =(高さ,幅,カラー画像)

size=(300,200) # 幅、高さ ※リサイズするときのパラメータは（幅,高さ)と逆になるので注意すること。
img_resize=cv2.resize(img,size)#imgをリサイズする
img_resize.shape   #(200, 300, 3)

cv2.imshow("resized_img",img_resize)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画質を比べてみる
img_area=cv2.resize(img,size,interpolation=cv2.INTER_AREA)
img_linear=cv2.resize(img,size,interpolation=cv2.INTER_LINEAR)#デフォルトの設定はインターリニア
cv2.imshow("img_area",img_area)
cv2.imshow("ing_linear",img_linear)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#色空間・グレースケール
RGB表現 赤　緑　青　0-255

HSV表現
 色相 Hue        0-359deg 色の種類　例）黄色っぽい色=30～60
 彩度 Saturation 0-100%   選んだ色相の深さ
 明度 Value      0-100%   明るさ
　　※OpenCVでは 0-179 0-255 0-255の範囲になっているので、割合を変換して使用すること

グレースケール    
Gray=0.1140B+0.5870G+0.2989R
 色強度という１つの数値に簡略化するので扱いやすい。
 ここから二値化をしやすい


# In[ ]:


#やってみよう
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")
img_gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) # cvt=convert の略,BGR2GRAY=BGR to グレイスケールの略
img_hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)


# In[ ]:


#シェイプの内容を比較
img.shape      #(640, 960, 3)
img_gray.shape #(640, 960)　色情報がなくなっている
img_hsv.shape  #(640, 960, 3)


# In[ ]:


#オリジナル画像とグレースケールを比較
cv2.imshow("img",img)
cv2.imshow("img_gray",img_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#もっと簡単にグレースケール化する方法
import cv2
img_gray2=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0)#cvtColor　を使わない方法。imreadで読み込んだ時点で オプション0をつける
cv2.imshow("img_gray2",img_gray2)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


img_hsv

"""
h , s , v の順に並んでいるが h=46の場合、本当は２倍の92であることに注意

array([[[ 46, 138, 175],
        [ 46, 152, 159],
        [ 45, 128, 177],
        ...,
"""     


# In[ ]:


#ヒストグラム
import cv2
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')


# In[ ]:


img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg")
cv2.imshow("img_title",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


color_list=["blue","green","red"]
for i,j in enumerate(color_list):
    print(i,j)
    hist=cv2.calcHist([img],[i],None,[256],[0,256])#カッコでくくるのがポイント　画像,番号BGR,マスク,binの数,binの数
    plt.plot(hist,color=j)


# In[ ]:


img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)#グレースケールで読む
hist_gray=cv2.calcHist([img_gray],[0],None,[256],[0,256])
plt.plot(hist_gray,color="gray")


# In[ ]:


#ヒストグラムの均一化
#　結果：暗いところはより暗く　明るいところはより明るく
import cv2
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
hist=cv2.calcHist([img],[0],None,[256],[0,256])
plt.plot(hist,color="gray")


# In[ ]:


img_eq=cv2.equalizeHist(img)
hist_e=cv2.calcHist([img_eq],[0],None,[256],[0,256])
plt.plot(hist_e)


# In[ ]:


cv2.imshow("img",img)
cv2.imshow("img_eq",img_eq)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#ガンマ変換　明るさの変換
#y=255*(x/255)**(1/gamma)# γ<1:暗くなる　, γ>1 :明るくなる
import cv2
import numpy as np

gamma=0.4
img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")
gamma_cvt=np.zeros((256,1),dtype=np.uint8) # 256行x1列の行列を用意する

for i in range(256):#ガンマ変換
    gamma_cvt[i][0]=255*(float(i)/255)**(1.0/gamma)
img_gamma=cv2.LUT(img,gamma_cvt)

cv2.imshow("img",img)
cv2.imshow("img_gamma",img_gamma)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#トラックバーの作成
#パラメータをカンタンに調整できるように
import cv2

def onTrackbar(position):
    global trackValue#グルーバル変数
    trackValue=position#トラックバーを動かすと反映される

trackValue=100 #初期値
cv2.namedWindow("img")
cv2.createTrackbar("track1","img",trackValue,255,onTrackbar)
cv2.createTrackbar("track2","img",trackValue,255,onTrackbar)
cv2.createTrackbar("track3","img",trackValue,255,onTrackbar)
cv2.waitKey(0)
cv2.destroyAllWindows()



# In[ ]:


#マウスイベント
import numpy as np
import cv2

def print_position(event,x,y,flags,param):#ボタンを押したときの動作を定義
    if event== cv2.EVENT_LBUTTONDBLCLK:#左ボタンをダブルクリックしたとき
        print(x,y)#座標を出力する

#適当な画像を用意する
img=np.zeros((512,512),np.uint8)#真っ黒
cv2.namedWindow("img")
cv2.setMouseCallback("img",print_position)
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#図形の描画
import cv2
import numpy as np

img=np.ones((500,500,3))*255#真っ白な画像を用意する
cv2.line(img,(0,0),(150,190),(255,0,0),2) #始点,終点,色,太さ
cv2.rectangle(img,(100,25),(300,150),(0,255,0),4) #始点,終点,色,太さ
cv2.circle(img,(100,100),55,(0,0,255),-1)#中心,半径,色,太さ 太さがマイナスの場合は塗りつぶしになる
cv2.ellipse(img,(250,250),(100,50),20,0,360,(255,0,0),1)#中心,(長軸,短軸),回転,書き始め角度,書き終わり角度,色,太さ

points=np.array([[100,30],[200,30],[200,80],[100,50]])
cv2.polylines(img,[points],False,(100,255,0),3)#False=閉じない , 色,太さ

font=cv2.FONT_HERSHEY_SIMPLEX
cv2.putText(img,"OpenCV",(100,300),font,1,(0,255,0),3,cv2.LINE_AA)

cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の二値化
#高速で処理できるように軽くする
img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0) #グレースケールとして読み込み
cv2.imshow("img",img)#画像確認
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


threshold=100#閾値
ret,img_th=cv2.threshold(img,threshold,255,cv2.THRESH_BINARY)# theresholdより大きい場合は255にする,変換方法

ret #100.0 retはリターンの意味 thresholdの値100が返ってくる


# In[ ]:


cv2.imshow("img_th",img_th)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#オーツの方法でthresholdを自動化する
ret2,img_o=cv2.threshold(img,0,255,cv2.THRESH_OTSU)
ret2 #自動的に決まる


# In[ ]:


#オーツの方法　アルゴリズム確認
"""
仮定：暗いところと　明るいところ　分けるべきところがあるだろう
     →山が二つ存在することが多いだろう。
""" 
import cv2
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
hist=cv2.calcHist([img],[0],None,[256],[0,256])
plt.plot(hist,color="gray")


# In[ ]:


#画像比較
cv2.imshow("img_th",img_th)
cv2.imshow("img_otsu",img_o)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#アダプティブ　スレショルドを使用する
#画像全体ではなく、小さな区間に分けてやっていく
img_ada=cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,3,1)


# In[ ]:


#画像比較
cv2.imshow("img",img)
cv2.imshow("img_th",img_th)
cv2.imshow("img_otsu",img_o)
cv2.imshow("img_ada",img_ada)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#二値化とトラックバーを組み合わせる
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/floor.jpg",0)
"""
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()
"""


# In[ ]:


def onTrackber(position):
    global threshold
    threshold=position

cv2.namedWindow("img")
threshold=100#初期値
cv2.createTrackbar("track","img",threshold,255,onTrackber)

while True:
    #ret,img_th=cv2.threshold(img,threshold,255,cv2.THRESH_BINARY) #通常の二値化
    img_th=cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,3,threshold) #アダプティブスレショルド
    cv2.imshow("img",img_th)
    cv2.imshow("src",img)
    if cv2.waitKey(10)==27:
        break
        
cv2.destroyAllWindows()

#アファイン変換
回転・移動などの線形変換

変換後　　　回転移動　　変換前　平行移動
[[x_prime]   [[a,b]     [[x]   [[t_x]
 [y_prime]] = [c,d]]  ・ [y]] + [t_y]]

まとめると

[[x_prime]   [[a,b,t_x]     [[x]
 [y_prime]  = [c,d,t_y]  ・  [y]
 [1      ]]   [0,0,1  ]]     [1]]
# In[ ]:


#アファイン変換を実装する
import cv2
import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")
h,w=img.shape[:2]
dx,dy=30,30 #基礎説明の t_x , t_y　のこと


# In[ ]:


afn_mat=np.float32([[1,0,dx],[0,1,dy]])
img_afn=cv2.warpAffine(img,afn_mat,(w,h))
cv2.imshow("trans",img_afn)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


rot_mat=cv2.getRotationMatrix2D((w/2,h/2),40,1) #回転中心,回転角度deg,スケール
img_afn2=cv2.warpAffine(img,rot_mat,(w,h))


# In[ ]:


cv2.imshow("rotation",img_afn2)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#透視変換
import cv2
import numpy as np
img=cv2.imread(r"C:\Users\omoiy\data/src/drive.jpg")
h,w=img.shape[:2]
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


per1=np.float32([[100,500],[300,500],[300,100],[100,100]])
per2=np.float32([[100,500],[300,500],[280,200],[150,200]])#per1に対応する点群

psp_matrix=cv2.getPerspectiveTransform(per1,per2)#変換前,変換後
img_psp=cv2.warpPerspective(img,psp_matrix,(w,h))
cv2.imshow("psp",img_psp)
cv2.waitKey(0)
cv2.destroyAllWindows()

#畳み込み
周囲の情報から自分の情報を更新すること
１）フィルターを用意する
２）着目画素の周囲で　画素値xフィルター を行い足していく＝畳み込み
３）全ての画素について畳み込みを行う

画素値（真ん中が着目画素=ノイズと考える）
[[5,5,4],
 [4,0,5],
 [5,4,5]]

平滑化フィルター
[[1/9 , 1/9 , 1/9],
 [1/9 , 1/9 , 1/9]
 [1/9 , 1/9 , 1/9]]

5*1/9 + 5*1/9 + 4*1/9 ....=4.11 
→4 として現在値0を更新する 
これでノイズが除去できたことになる
しかし、ぼけてしまう
# In[ ]:


#畳み込みを実装する
import cv2
import numpy as np
kernel=np.ones((3,3))/9.0 #フィルター
"""平滑化フィルター
array([[0.11111111, 0.11111111, 0.11111111],
       [0.11111111, 0.11111111, 0.11111111],
       [0.11111111, 0.11111111, 0.11111111]])
"""
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
img_ke1=cv2.filter2D(img,-1,kernel)#ビット深度　負の値をしておくと良い,kernel
cv2.imshow("img_ke1",img_ke1)
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


kernel2=np.zeros((3,3))
kernel2[0,0]=1
kernel2[1,0]=2
kernel2[2,0]=1
kernel2[0,2]=-1
kernel2[1,2]=-2
kernel2[2,2]=-1
"""横方向のエッジを検出するフィルター（sobelフィルターは縦方向）
array([[ 1.,  0., -1.],
       [ 2.,  0., -2.],
       [ 1.,  0., -1.]])
"""
img_ke2=cv2.filter2D(img,-1,kernel2)
cv2.imshow("img",img)
cv2.imshow("img_ke1",img_ke1)
cv2.imshow("img_ke2",img_ke2)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の平滑化 ブラー処理
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")
img_blur=cv2.blur(img,(3,3))
cv2.imshow("img",img)
cv2.imshow("img_blur",img_blur)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の平滑化 ガウシアン ブラー処理
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")
img_ga=cv2.GaussianBlur(img,(9,9),2)#範囲が広いので、かなりボケボケ
cv2.imshow("img",img)
cv2.imshow("img_blur",img_blur)
cv2.imshow("img_ga",img_ga)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の平滑化 メディアンフィルター
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")
img_me=cv2.medianBlur(img,5)#5x5の中の最頻値で全部を塗りつぶしてしまうので、かなりボケボケ
cv2.imshow("img",img)
cv2.imshow("img_blur",img_blur)
cv2.imshow("img_ga",img_ga)
cv2.imshow("img_me",img_me)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の平滑化 バイラテラルフィルタ
#輝度変化が激しいところはほっといて、緩やかな部分だけ平滑化をする
#エッジを残しながら、ノイズを除去することができる。
img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")
img_bi=cv2.bilateralFilter(img,20,30,20)#窓の大きさ20,エッジを保存するためのシグマ,ガウシアンブラーでも渡したシグマ
cv2.imshow("img",img)
cv2.imshow("img_bi",img_bi)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#画像の微分
①傾き=[f(x+dx)-f(x)]/dx
しかし、画像ではdx=constなので
②傾き=隣の画素値-自分の画素値
でよい


# In[ ]:


#エッジの検出 Sobel と　Laplacian
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


# Sobel フィルター
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
img_sobelx=cv2.Sobel(img,cv2.CV_32F,1,0,ksize=3) # ビット深度 1,0  x方向の微分
img_sobely=cv2.Sobel(img,cv2.CV_32F,0,1,ksize=3) # ビット深度 0,1  y方向の微分 

cv2.imshow("img_sobelx",img_sobelx)
cv2.imshow("img_sobely",img_sobely)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


# Laplacian　フィルター
#方向性がない。二次微分なので、細かいエッジも検出してしまう。
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
img_lap=cv2.Laplacian(img,cv2.CV_32F) # ビット深度

cv2.imshow("img_lap",img_lap)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#ガウシアンの後にLaplacianする
#ぼかしてからエッジを検出するのでエッジが太く検出される
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
img_ga=cv2.GaussianBlur(img,(21,21),2)
img_lap=cv2.Laplacian(img,cv2.CV_32F)
img_ga_lap=cv2.Laplacian(img_ga,cv2.CV_32F)

cv2.imshow("img",img)
cv2.imshow("img_ga",img_ga)
cv2.imshow("img_lap",img_lap)
cv2.imshow("img_ga_lap",img_ga_lap)
cv2.waitKey(0)
cv2.destroyAllWindows()

#エッジの検出　Canny
#Laplacianのような輝度変化の細かいエッジ検出を抑制してくれる
①ガウシアンでぼかす（ノイズを除去する）
②Sobelフィルター x方向微分,y方向微分　を得る
　２乗和（いわゆる強度のこと）を採用する
③極大点を探す＝エッジ
　除去：エッジではないノイズ（右肩上がり）、グラデーション（微分値が小さい）
④２段階の閾値処理でエッジを残す
　１）閾値１以上の大きなエッジは残す
　２）閾値１よりは小さいが、閾値２以上でエッジにつながっている場合は細かいエッジとして残す

# In[ ]:


#エッジの検出　Cannyを実装する
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)
img_canny=cv2.Canny(img,10,180)#低い閾値,高い閾値
img_canny2=cv2.Canny(img,120,150)#低い閾値,高い閾値

cv2.imshow("img_canny",img_canny)
cv2.imshow("img_canny2",img_canny2)
cv2.waitKey(0)
cv2.destroyAllWindows()

#直線　円の検出
直線は２つのパラメータで決まる
y=ax+b　が一般的だが

ρ：原点から直線までの距離
θ：原点を通る直線の法線とx軸とのなす角
とすると
y=-(cosθ/sinθ)x + (ρ/sinθ)
でもいい

でも、この方法はθが小さいとき yが発散してしまうので使えない。
べつの方法としベクトルを使ってみる

# In[ ]:


#直線の検出
import cv2
import numpy as np
img=cv2.imread(r"C:\Users\omoiy\data/src/road.jpg")
img_gray=cv2.imread(r"C:\Users\omoiy\data/src/road.jpg",0)
img_canny=cv2.Canny(img_gray,300,400)

cv2.imshow("img",img)
cv2.imshow("img_gray",img_gray)
cv2.imshow("img_canny",img_canny)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


lines=cv2.HoughLines(img_canny,1,np.pi/180,100)#1はρの刻み幅,θの刻み幅,集計表の閾値


# In[ ]:


for i in lines[:]:
    rho = i[0][0]
    theta = i[0][1]
    a = np.cos(theta)
    b = np.sin(theta)
    x0 = rho*a
    y0 = rho*b
    x1 = int(x0+1000*(-b))
    y1 = int(y0+1000*(a))
    x2 = int(x0-1000*(-b))
    y2 = int(x0-1000*(a))
    cv2.line(img,(x1,y1),(x2,y2),(255,0,0),1)
    
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#円の検出
import cv2
img2=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")
img2_gray=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0)
cv2.imshow("img",img2)
cv2.imshow("img_gray",img2_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


get_ipython().set_next_input('circles=cv2.HoughCircles');get_ipython().run_line_magic('pinfo', 'cv2.HoughCircles')


# In[ ]:


circles=cv2.HoughCircles(img2_gray,cv2.HOUGH_GRADIENT,dp=1,minDist=1,param1=20,param2=35,minRadius=1,maxRadius=30)


# In[ ]:


for i in circles[0]:
    cv2.circle(img2,(i[0],i[1]),i[2],(255,0,0),1)

cv2.imshow("img",img2)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#モルフォロジー演算
モノの形についての演算（黒の中に白の図形があるとき）
収縮 erode ：白が小さくなる。モノとモノを分離したいとき
膨張 dilate：白が大きくなる。モノとモノを連結したいとき

黒画像中に白いノイズがある場合
オープニング：収縮→膨張　白いノイズを小さくして、ノイズが消えてから、再びサイズを戻す。
クロージング：膨張→収縮　ノイズの大きさはそのまま。変化なし



# In[ ]:


import cv2
import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/floor.jpg",0)#グレースケール

#モルフォロジー演算をするためには２値化画像が必要になる
ret,img_th=cv2.threshold(img,110,255,cv2.THRESH_BINARY)

cv2.imshow("img",img)
cv2.imshow("img_th",img_th)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


kernel=np.ones((3,3),dtype=np.uint8) #着目画素の大きさを定義する
img_d=cv2.dilate(img_th,kernel)#膨張　着目画素に白画素があったら自分も白にする
img_e=cv2.erode(img_th,kernel)#収縮　着目画素に黒画素があったら自分も黒にする
#cv2.imshow("img",img)
#cv2.imshow("img_th",img_th)
cv2.imshow("img_dilate",img_d) #白が増える
cv2.imshow("img_erode",img_e) #黒が増える　

cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#クロージング　（膨張と比較する）
img_c=cv2.morphologyEx(img_th,cv2.MORPH_CLOSE,kernel)
cv2.imshow("img_dilate",img_d)  #膨張のみ　白が増える
cv2.imshow("img_clising",img_c) #膨張→収縮 膨張で白飛びした穴を収縮で黒く埋めていく。
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#インペイント
#画像の中の落書きを消す
#周囲の画像を使って消していく
import cv2
import numpy as np
img=cv2.imread(r"C:\Users\omoiy\data/src/Bus.jpg")        #落書き入りの元画像
img_mask=cv2.imread(r"C:/Users/omoiy/data/src/Mask.jpg",0)#落書き部分を抜き出した画像 グレースケールで

cv2.imshow("img",img)
cv2.imshow("img_mask",img_mask)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#img_mask グレースケールを二値化する
thresh=1 #閾値
ret,img_bi=cv2.threshold(img_mask,thresh,255,cv2.THRESH_BINARY)

cv2.imshow("img_binary",img_bi)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#マスクした部分の周辺画像を拾って、マスク内に繰り返し何回も侵入させていく。
img_dst=cv2.inpaint(img,img_bi,3,cv2.INPAINT_NS)#ナビエストークス

cv2.imshow("img",img)
cv2.imshow("img_dst",img_dst) #うまく落書きが消えた
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#特徴抽出
#Harirsのコーナー検出
情報量：フラット＜エッジ＜コーナー
フラット： n個の固有ベクトルの固有値に大小がない。ほぼ均一
エッジ  ： n個の固有ベクトルのうち１つの固有値が大きくなる
コーナー： n個の固有ベクトルのうち２つの固有値が大きくなる

#そのほか
ORB（早い）, KAZE , AKAZEがお手軽で良い

#商用利用不可
SIFT:徴量128次元
SURF:SIFTを高速化


# In[ ]:


#オリジナルデータを読み込む
import cv2
import numpy as np
import copy

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")#オリジナル画像
img_gray=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg",0)#グレースケール画像

cv2.imshow("img",img)
cv2.imshow("img_gray",img_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#harrisのコーナー検出をやってみる
import cv2
import numpy as np
import copy
img_harris=copy.deepcopy(img) #特徴点が元画像に上書きされてしまうので、imgのディープコピーをimg_harrisとしてとっておく
img_dst=cv2.cornerHarris(img_gray,2,3,0.04)#コーナー検出の範囲サイズ,ソーベルフィルターの大きさ,0.04～0.05がいいらしい

img_dst
"""２つの固有値を掛け算した＝値が大きいと固有値が２つあるということ
array([[ 4.5360382e-12,  4.5360382e-12,  1.1455559e-12, ...,
         3.5410072e-10,  1.2930142e-10, -5.0405020e-11],
       [ 4.5360382e-12,  4.5360382e-12,  1.1455559e-12, ...,
         3.5410072e-10,  1.2930142e-10, -5.0405020e-11],
       [ 4.2316191e-09,  4.2316191e-09,  3.0776899e-09, ...,
        -5.2589849e-10,  3.0621861e-10,  2.3705888e-09],
"""
#harrisデータimg_dstの内、5%以上であれば、特徴点とみなすことにする
img_harris[img_dst > 0.05*img_dst.max()]=[0,0,255]#BGR 特徴点を赤でマーキングする , 
cv2.imshow("img_harris",img_harris) #コーナーが検出されている
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


# kaze（ケイズ）のコーナー検出をやってみる
import cv2
import numpy as np
import copy
img_kaze=copy.deepcopy(img)                  #特徴点が元画像に上書きされてしまうので、imgのディープコピーをとっておく
kaze=cv2.KAZE_create()                       #特徴抽出器のインスタンスkazeを生成しておく
kp1=kaze.detect(img,None)                    #特徴点を探してkp1に代入する
img_kaze=cv2.drawKeypoints(img_kaze,kp1,None)#特徴点kp1を描く
cv2.imshow("img_kaze",img_kaze)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


# accerate kaze（アクセレイト　ケイズ）のコーナー検出をやってみる
import cv2
import numpy as np
import copy
img_akaze=copy.deepcopy(img)                  #特徴点が元画像に上書きされてしまうので、imgのディープコピーをとっておく
akaze=cv2.AKAZE_create()                       #特徴抽出器のインスタンスkazeを生成しておく
kp1=akaze.detect(img,None)                    #特徴点を探してkp1に代入する
img_akaze=cv2.drawKeypoints(img_akaze,kp1,None)#特徴点kp1を描く
cv2.imshow("img_akaze",img_akaze)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


# orb（オーブ）のコーナー検出をやってみる
import cv2
import numpy as np
import copy

img_orb=copy.deepcopy(img)
orb=cv2.ORB_create()#インスタンスを生成する
kp2=orb.detect(img_orb)
img_orb=cv2.drawKeypoints(img_orb,kp2,None)
cv2.imshow("img_orb",img_orb)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[ ]:


#コーナー検出を比較する
import cv2
import numpy as np
import copy
cv2.imshow("img_harris",img_harris)
cv2.imshow("img_kaze",img_kaze)
cv2.imshow("img_akaze",img_akaze)
cv2.imshow("img_orb",img_orb)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[4]:


#顏検出
import cv2

#ハールファイル　特徴検出器：すでにopencvに入っている
HAAR_FILE="C:/Users/omoiy/Anaconda3/pkgs/opencv3-3.1.0-py35_0/Library/etc/haarcascades/haarcascade_frontalface_default.xml"
cascade=cv2.CascadeClassifier(HAAR_FILE)#分類検出器のインスタンスを作成する

img=cv2.imread(r"C:/Users/omoiy/data/src/Solvay_conference_1927.jpg")
img_gray=cv2.imread(r"C:/Users/omoiy/data/src/Solvay_conference_1927.jpg",0)
cv2.imshow("img",img)
cv2.imshow("img_gray",img_gray)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[8]:


face=cascade.detectMultiScale(img_gray)
face
"""　座標x,座標y,幅w,高さh
array([[1061,  877,   37,   37],
       [ 115,  570,   53,   53],
       [ 421,  568,   60,   60],
"""
for x,y,w,h in face:
    cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),1)　#顔を四角で囲む
cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[21]:


#ブロブの検出
import cv2 ,copy

img=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png")
img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png",0)

cv2.imshow("img",img)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[23]:


ret,img_bi=cv2.threshold(img_gray,100,255,cv2.THRESH_BINARY) #グレースケールを二値化

cv2.imshow("img_bi",img_bi)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[34]:


nLabels,labelImage,stats,centroids=cv2.connectedComponentsWithStats(img_bi) #ブロブの検出
nLabels   # 5 ：ブロブが５個検出された　背景も１個として検出される
labelImage
"""ラベルのIDが　ふられる
array([[0, 0, 0, ..., 0, 0, 0],←背景
       [0, 0, 0, ..., 0, 0, 0],
       [0, 0, 0, ..., 0, 0, 0],
"""
stats
"""あるブロブの最小のx 最小のy　幅w　高さh 面積s
array([[      0,       0,    1672,    1078, 1578760],←背景
       [    818,      88,     365,     311,   56799],
       [    256,     143,     150,     150,   17656],
       [    163,     471,     336,     363,   89208],
       [   1048,     574,     302,     288,   59993]], dtype=int32)
"""
img_blob=copy.deepcopy(img)
h,w=img_gray.shape
color=[[255,0,255],[0,255,0],[0,0,255],[255,255,0]]#塗る色のリストが必要
for y in range(h):
    for x in range(w):
        if labelImage[y,x]>0:#背景のlabel Imageは0なので、それ以外の時、色を塗る
            img_blob[y,x]=color[labelImage[y,x]-1]
            
for i in range(1,nLabels):#背景(0)は除く
    xc=int(centroids[i][0])
    yc=int(centroids[i][1])
    font=cv2.FONT_HERSHEY_COMPLEX
    scale=1
    color=(255,255,255)
    cv2.putText(img_blob,str(stats[i][-1]),(xc,yc),font,scale,color)


# In[35]:


cv2.imshow("img_blob",img_blob)
cv2.waitKey(0)
cv2.destroyAllWindows()


# In[36]:


#輪郭検出
import cv2
img=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png")
img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png",0)   #グレースケール
ret,img_bi=cv2.threshold(img_gray,100,255,cv2.THRESH_BINARY) #二値化


# In[40]:


img_con,contours,hierarchy=cv2.findContours(img_bi,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)#３角形の中の３角形まで検出する,最低限の輪郭を検出
img_contour=cv2.drawContours(img,contours,-1,(255,0,0),5)#全ての輪郭を描く（-1) , 色 , 太さ


# In[41]:


cv2.imshow("img",img)
cv2.imshow("img_gray",img_gray)
cv2.imshow("img_contour",img_contour)
cv2.waitKey(0)
cv2.destroyAllWindows()

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

1001

1002

1003

1004

1005

1006

1007

1008

1009

1010

1011

1012

1013

1014

1015

1016

1017

1018

1019

1020

1021

1022

1023

1024

1025

1026

1027

1028

1029

1030

1031

1032

1033

1034

1035

1036

1037

1038

1039

1040

1041

1042

1043

1044

1045

1046

1047

1048

1049

1050

1051

1052

1053

1054

1055

1056

1057

1058

1059

1060

1061

1062

1063

1064

1065

1066

1067

1068

1069

1070

1071

1072

1073

1074

1075

1076

1077

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112

1113

1114

1115

1116

1117

1118

1119

1120

1121

1122

1123

1124

1125

1126

1127

1128

1129

1130

1131

1132

1133

1134

1135

1136

1137

1138

1139

1140

1141

1142

1143

1144

1145

1146

1147

1148

1149

1150

1151

1152

1153

1154

1155

1156

1157

1158

1159

1160

1161

1162

1163

1164

1165

1166

1167

1168

1169

1170

1171

1172

1173

1174

1175

1176

1177

1178

1179

1180

1181

1182

1183

1184

1185

1186

1187

1188

1189

1190

1191

1192

1193

1194

1195

1196

1197

1198

1199

1200

1201

1202

1203

1204

1205

1206

1207

1208

1209

1210

1211

1212

1213

1214

1215

1216

1217

1218

1219

1220

1221

1222

1223

1224

1225

1226

1227

1228

1229

1230

1231

1232

1233

1234

1235

1236

1237

1238

1239

1240

1241

1242

1243

1244

1245

1246

1247

1248

1249

1250

1251

1252

1253

1254

1255

1256

1257

1258

1259

1260

1261

1262

1263

1264

1265

1266

1267

1268

1269

1270

1271

1272

1273

1274

1275

1276

1277

1278

1279

1280

1281

# coding: utf-8

# OpenCVを学ぶ

画素値は(B,G,R) 0-255で表現する。

画像の左上が原点(0,0)

#画像処理＝解析しやすくする。情報を抽出する

（１）グレースケール化+平滑化

①Gray=0.1140B+0.5870G+0.2989R

②平滑化出力画像=(I*G)

　ノイズ画素を指定したとき、その周辺の画素データになじむように自分の画素データを修正する。

　ガウシアンカーネル（代表的な平滑化カーネル）　グレースケールの画像に畳み込む

gaussian=np.array([[1/16,2/16,/1/16],

[2/16,4/16,/2/16],

[1/16,2/16,/1/16]])

（２）グレースケール化+Canny

①Gray=0.1140B+0.5870G+0.2989R

②canny

ぼかす→微分→エッジを残す

sift surfは特許で使えないものもある

# In[ ]:

#OpenCVのコンテンツ

グレースケール

２値化

リサイズ

ガンマ変換

ヒストグラム均一化

アフィン変換

畳み込み（平滑化の一部）

平滑化

モルフォロジー演算

インペイント

#特徴抽出

線　円の検出

輪郭の検出

ブロブの検出

特徴点抽出

#動画解析

オプティカルフロー

Meansift / Camshift

背景差分

パーティクルフィルター

#そのほか

カメラモデル　機械学習　sift surf

# In[ ]:

#on anaconda pronpt

#conda create :新たな環境を作る

#-n opencv : opencvというnameの環境

#python=3.5:opencv3はpython3.5が最大 3.6には対応していないのでダウングレードして使用する

conda create -n opencv python=3.5 anaconda

#環境が作成されているか確認する

conda info -e

activate opency #環境に入る

deactivate #環境から抜ける

conda remove -n opencv --all #環境を削除（今回はやらない）

#OpenCVのインストール (環境名opencv　上にインストール)

conda install -c menpo opencv3

#インストールされたか確認

ipython #ipythonに入る

import cv2 # cv3でもcv2と記載する。ややこしいので注意

# In[ ]:

#画像の基礎知識

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")

print(type(img))#画素値は(B,G,R) 0-255で表現する。<class 'numpy.ndarray'>

h,w=img.shape[0:2] #高さ、幅　、3つ目の成分もあるが　なぞ

img.shape #(589, 960, 3)

print(h,w) #589 960

# In[ ]:

#y,x座標を指定して　blue成分の値を取得する

img[300][500][0] # 104 img[y][x][color] color:B=0 ro G=1 or R=2

# In[ ]:

#画像の読み込み,表示と出力

import cv2 , os

img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")

img.shape #(589, 960, 3)

img[0][0] #原点での色情報BGR　array([128, 176, 194], dtype=uint8)

cv2.imshow("title",img)

cv2.waitKey(0) #3を入れると3msecキーボード入力を受け付ける。0はなにか押されるまで待つ　という意味

cv2.destroyAllWindows()

os.mkdir("./output")

cv2.imwrite("output/test.jpg",img) # True

# In[ ]:

import cv2 , sys

cap=cv2.VideoCapture(r"C:\Users\omoiy\data\movie/Cosmos.mp4")#読み込む

if cap.isOpened()==False: #開けたかチェックする

sys.exit()

ret,frame=cap.read()#ret=開けたかどうか , frame=１フレーム読んだ画像

h,w=frame.shape[:2] #動画の解像度を取得。３番目の色情報は不要

print(h,w) #1080 1920

fourcc=cv2.VideoWriter_fourcc(*"XVID")#コーデックの設定情報

fps=30.0 #fpsを設定する

dst=cv2.VideoWriter("output/test.avi",fourcc,fps,(w,h))#書き込む用　。解像度の入力は(x,y)で入れるので注意

#プログラムの本体

while True:

ret,frame=cap.read() #ret=開けたかどうか , frame=１フレーム読んだ画像

if ret==False:#ちゃんと読み込めなかった場合はブレークする

break

cv2.imshow("title",frame)#１コマを表示させる

dst.write(frame)#動画を書き込む

if cv2.waitKey(30)==27:#escキーが押されるとブレークする

break

cv2.destroyAllWindows()

cap.release()

# In[ ]:

#ウィンドウの調整

import cv2

img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")

cv2.namedWindow("window",cv2.WINDOW_AUTOSIZE)#ウィンドウの設定

cv2.imshow("window",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

import cv2

img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")

cv2.namedWindow("window",cv2.WINDOW_NORMAL)#ウィンドウの設定リサイズ可能になる

cv2.imshow("window",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

import cv2

img=cv2.imread(r"C:\Users\omoiy\data\src/Lena.jpg")

cv2.namedWindow("window",cv2.WINDOW_NORMAL)#ウィンドウの設定リサイズ可能になる

cv2.resizeWindow("window",640,480)#解像度を指定する（アスペクト比は変わる）

cv2.imshow("window",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像のリサイズ

import cv2

img=cv2.imread(r"C:\Users\omoiy\data\src/Grapes.jpg")

#cv2.imshow("window",img)

#cv2.waitKey(0)

#cv2.destroyAllWindows()

img.shape # (640, 960, 3) =(高さ,幅,カラー画像)

size=(300,200) # 幅、高さ ※リサイズするときのパラメータは（幅,高さ)と逆になるので注意すること。

img_resize=cv2.resize(img,size)#imgをリサイズする

img_resize.shape #(200, 300, 3)

cv2.imshow("resized_img",img_resize)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画質を比べてみる

img_area=cv2.resize(img,size,interpolation=cv2.INTER_AREA)

img_linear=cv2.resize(img,size,interpolation=cv2.INTER_LINEAR)#デフォルトの設定はインターリニア

cv2.imshow("img_area",img_area)

cv2.imshow("ing_linear",img_linear)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#色空間・グレースケール

RGB表現赤　緑　青　0-255

HSV表現

色相 Hue 0-359deg 色の種類　例）黄色っぽい色=30～60

彩度 Saturation 0-100% 選んだ色相の深さ

明度 Value 0-100% 明るさ

　　※OpenCVでは 0-179 0-255 0-255の範囲になっているので、割合を変換して使用すること

グレースケール

Gray=0.1140B+0.5870G+0.2989R

色強度という１つの数値に簡略化するので扱いやすい。

ここから二値化をしやすい

# In[ ]:

#やってみよう

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")

img_gray=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) # cvt=convert の略,BGR2GRAY=BGR to グレイスケールの略

img_hsv=cv2.cvtColor(img,cv2.COLOR_BGR2HSV)

# In[ ]:

#シェイプの内容を比較

img.shape #(640, 960, 3)

img_gray.shape #(640, 960)　色情報がなくなっている

img_hsv.shape #(640, 960, 3)

# In[ ]:

#オリジナル画像とグレースケールを比較

cv2.imshow("img",img)

cv2.imshow("img_gray",img_gray)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#もっと簡単にグレースケール化する方法

import cv2

img_gray2=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0)#cvtColor　を使わない方法。imreadで読み込んだ時点でオプション0をつける

cv2.imshow("img_gray2",img_gray2)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

img_hsv

"""

h , s , v の順に並んでいるが h=46の場合、本当は２倍の92であることに注意

array([[[ 46, 138, 175],

[ 46, 152, 159],

[ 45, 128, 177],

...,

"""

# In[ ]:

#ヒストグラム

import cv2

import matplotlib.pyplot as plt

get_ipython().run_line_magic('matplotlib', 'inline')

# In[ ]:

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg")

cv2.imshow("img_title",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

color_list=["blue","green","red"]

for i,j in enumerate(color_list):

print(i,j)

hist=cv2.calcHist([img],[i],None,[256],[0,256])#カッコでくくるのがポイント　画像,番号BGR,マスク,binの数,binの数

plt.plot(hist,color=j)

# In[ ]:

img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)#グレースケールで読む

hist_gray=cv2.calcHist([img_gray],[0],None,[256],[0,256])

plt.plot(hist_gray,color="gray")

# In[ ]:

#ヒストグラムの均一化

#　結果：暗いところはより暗く　明るいところはより明るく

import cv2

import matplotlib.pyplot as plt

get_ipython().run_line_magic('matplotlib', 'inline')

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

hist=cv2.calcHist([img],[0],None,[256],[0,256])

plt.plot(hist,color="gray")

# In[ ]:

img_eq=cv2.equalizeHist(img)

hist_e=cv2.calcHist([img_eq],[0],None,[256],[0,256])

plt.plot(hist_e)

# In[ ]:

cv2.imshow("img",img)

cv2.imshow("img_eq",img_eq)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#ガンマ変換　明るさの変換

#y=255*(x/255)**(1/gamma)# γ<1:暗くなる　, γ>1 :明るくなる

import cv2

import numpy as np

gamma=0.4

img=cv2.imread(r"C:\Users\omoiy\data/src/Berry.jpg")

gamma_cvt=np.zeros((256,1),dtype=np.uint8) # 256行x1列の行列を用意する

for i in range(256):#ガンマ変換

gamma_cvt[i][0]=255*(float(i)/255)**(1.0/gamma)

img_gamma=cv2.LUT(img,gamma_cvt)

cv2.imshow("img",img)

cv2.imshow("img_gamma",img_gamma)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#トラックバーの作成

#パラメータをカンタンに調整できるように

import cv2

def onTrackbar(position):

global trackValue#グルーバル変数

trackValue=position#トラックバーを動かすと反映される

trackValue=100 #初期値

cv2.namedWindow("img")

cv2.createTrackbar("track1","img",trackValue,255,onTrackbar)

cv2.createTrackbar("track2","img",trackValue,255,onTrackbar)

cv2.createTrackbar("track3","img",trackValue,255,onTrackbar)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#マウスイベント

import numpy as np

import cv2

def print_position(event,x,y,flags,param):#ボタンを押したときの動作を定義

if event== cv2.EVENT_LBUTTONDBLCLK:#左ボタンをダブルクリックしたとき

print(x,y)#座標を出力する

#適当な画像を用意する

img=np.zeros((512,512),np.uint8)#真っ黒

cv2.namedWindow("img")

cv2.setMouseCallback("img",print_position)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#図形の描画

import cv2

import numpy as np

img=np.ones((500,500,3))*255#真っ白な画像を用意する

cv2.line(img,(0,0),(150,190),(255,0,0),2) #始点,終点,色,太さ

cv2.rectangle(img,(100,25),(300,150),(0,255,0),4) #始点,終点,色,太さ

cv2.circle(img,(100,100),55,(0,0,255),-1)#中心,半径,色,太さ太さがマイナスの場合は塗りつぶしになる

cv2.ellipse(img,(250,250),(100,50),20,0,360,(255,0,0),1)#中心,(長軸,短軸),回転,書き始め角度,書き終わり角度,色,太さ

points=np.array([[100,30],[200,30],[200,80],[100,50]])

cv2.polylines(img,[points],False,(100,255,0),3)#False=閉じない , 色,太さ

font=cv2.FONT_HERSHEY_SIMPLEX

cv2.putText(img,"OpenCV",(100,300),font,1,(0,255,0),3,cv2.LINE_AA)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の二値化

#高速で処理できるように軽くする

img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0) #グレースケールとして読み込み

cv2.imshow("img",img)#画像確認

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

threshold=100#閾値

ret,img_th=cv2.threshold(img,threshold,255,cv2.THRESH_BINARY)# theresholdより大きい場合は255にする,変換方法

ret #100.0 retはリターンの意味 thresholdの値100が返ってくる

# In[ ]:

cv2.imshow("img_th",img_th)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#オーツの方法でthresholdを自動化する

ret2,img_o=cv2.threshold(img,0,255,cv2.THRESH_OTSU)

ret2 #自動的に決まる

# In[ ]:

#オーツの方法　アルゴリズム確認

"""

仮定：暗いところと　明るいところ　分けるべきところがあるだろう

→山が二つ存在することが多いだろう。

"""

import cv2

import matplotlib.pyplot as plt

get_ipython().run_line_magic('matplotlib', 'inline')

hist=cv2.calcHist([img],[0],None,[256],[0,256])

plt.plot(hist,color="gray")

# In[ ]:

#画像比較

cv2.imshow("img_th",img_th)

cv2.imshow("img_otsu",img_o)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#アダプティブ　スレショルドを使用する

#画像全体ではなく、小さな区間に分けてやっていく

img_ada=cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,3,1)

# In[ ]:

#画像比較

cv2.imshow("img",img)

cv2.imshow("img_th",img_th)

cv2.imshow("img_otsu",img_o)

cv2.imshow("img_ada",img_ada)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#二値化とトラックバーを組み合わせる

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/floor.jpg",0)

"""

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

"""

# In[ ]:

def onTrackber(position):

global threshold

threshold=position

cv2.namedWindow("img")

threshold=100#初期値

cv2.createTrackbar("track","img",threshold,255,onTrackber)

while True:

#ret,img_th=cv2.threshold(img,threshold,255,cv2.THRESH_BINARY) #通常の二値化

img_th=cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_MEAN_C,cv2.THRESH_BINARY,3,threshold) #アダプティブスレショルド

cv2.imshow("img",img_th)

cv2.imshow("src",img)

if cv2.waitKey(10)==27:

break

cv2.destroyAllWindows()

#アファイン変換

回転・移動などの線形変換

変換後　　　回転移動　　変換前　平行移動

[[x_prime] [[a,b] [[x] [[t_x]

[y_prime]] = [c,d]] ・ [y]] + [t_y]]

まとめると

[[x_prime] [[a,b,t_x] [[x]

[y_prime] = [c,d,t_y] ・ [y]

[1 ]] [0,0,1 ]] [1]]

# In[ ]:

#アファイン変換を実装する

import cv2

import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")

h,w=img.shape[:2]

dx,dy=30,30 #基礎説明の t_x , t_y　のこと

# In[ ]:

afn_mat=np.float32([[1,0,dx],[0,1,dy]])

img_afn=cv2.warpAffine(img,afn_mat,(w,h))

cv2.imshow("trans",img_afn)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

rot_mat=cv2.getRotationMatrix2D((w/2,h/2),40,1) #回転中心,回転角度deg,スケール

img_afn2=cv2.warpAffine(img,rot_mat,(w,h))

# In[ ]:

cv2.imshow("rotation",img_afn2)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#透視変換

import cv2

import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/drive.jpg")

h,w=img.shape[:2]

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

per1=np.float32([[100,500],[300,500],[300,100],[100,100]])

per2=np.float32([[100,500],[300,500],[280,200],[150,200]])#per1に対応する点群

psp_matrix=cv2.getPerspectiveTransform(per1,per2)#変換前,変換後

img_psp=cv2.warpPerspective(img,psp_matrix,(w,h))

cv2.imshow("psp",img_psp)

cv2.waitKey(0)

cv2.destroyAllWindows()

#畳み込み

周囲の情報から自分の情報を更新すること

１）フィルターを用意する

２）着目画素の周囲で　画素値xフィルターを行い足していく＝畳み込み

３）全ての画素について畳み込みを行う

画素値（真ん中が着目画素=ノイズと考える）

[[5,5,4],

[4,0,5],

[5,4,5]]

平滑化フィルター

[[1/9 , 1/9 , 1/9],

[1/9 , 1/9 , 1/9]

[1/9 , 1/9 , 1/9]]

5*1/9 + 5*1/9 + 4*1/9 ....=4.11

→4 として現在値0を更新する

これでノイズが除去できたことになる

しかし、ぼけてしまう

# In[ ]:

#畳み込みを実装する

import cv2

import numpy as np

kernel=np.ones((3,3))/9.0 #フィルター

"""平滑化フィルター

array([[0.11111111, 0.11111111, 0.11111111],

[0.11111111, 0.11111111, 0.11111111],

[0.11111111, 0.11111111, 0.11111111]])

"""

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

img_ke1=cv2.filter2D(img,-1,kernel)#ビット深度　負の値をしておくと良い,kernel

cv2.imshow("img_ke1",img_ke1)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

kernel2=np.zeros((3,3))

kernel2[0,0]=1

kernel2[1,0]=2

kernel2[2,0]=1

kernel2[0,2]=-1

kernel2[1,2]=-2

kernel2[2,2]=-1

"""横方向のエッジを検出するフィルター（sobelフィルターは縦方向）

array([[ 1., 0., -1.],

[ 2., 0., -2.],

[ 1., 0., -1.]])

"""

img_ke2=cv2.filter2D(img,-1,kernel2)

cv2.imshow("img",img)

cv2.imshow("img_ke1",img_ke1)

cv2.imshow("img_ke2",img_ke2)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の平滑化ブラー処理

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")

img_blur=cv2.blur(img,(3,3))

cv2.imshow("img",img)

cv2.imshow("img_blur",img_blur)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の平滑化ガウシアンブラー処理

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")

img_ga=cv2.GaussianBlur(img,(9,9),2)#範囲が広いので、かなりボケボケ

cv2.imshow("img",img)

cv2.imshow("img_blur",img_blur)

cv2.imshow("img_ga",img_ga)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の平滑化メディアンフィルター

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")

img_me=cv2.medianBlur(img,5)#5x5の中の最頻値で全部を塗りつぶしてしまうので、かなりボケボケ

cv2.imshow("img",img)

cv2.imshow("img_blur",img_blur)

cv2.imshow("img_ga",img_ga)

cv2.imshow("img_me",img_me)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の平滑化バイラテラルフィルタ

#輝度変化が激しいところはほっといて、緩やかな部分だけ平滑化をする

#エッジを残しながら、ノイズを除去することができる。

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")

img_bi=cv2.bilateralFilter(img,20,30,20)#窓の大きさ20,エッジを保存するためのシグマ,ガウシアンブラーでも渡したシグマ

cv2.imshow("img",img)

cv2.imshow("img_bi",img_bi)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#画像の微分

①傾き=[f(x+dx)-f(x)]/dx

しかし、画像ではdx=constなので

②傾き=隣の画素値-自分の画素値

でよい

# In[ ]:

#エッジの検出 Sobel と　Laplacian

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

# Sobel フィルター

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

img_sobelx=cv2.Sobel(img,cv2.CV_32F,1,0,ksize=3) # ビット深度 1,0 x方向の微分

img_sobely=cv2.Sobel(img,cv2.CV_32F,0,1,ksize=3) # ビット深度 0,1 y方向の微分

cv2.imshow("img_sobelx",img_sobelx)

cv2.imshow("img_sobely",img_sobely)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

# Laplacian　フィルター

#方向性がない。二次微分なので、細かいエッジも検出してしまう。

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

img_lap=cv2.Laplacian(img,cv2.CV_32F) # ビット深度

cv2.imshow("img_lap",img_lap)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#ガウシアンの後にLaplacianする

#ぼかしてからエッジを検出するのでエッジが太く検出される

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

img_ga=cv2.GaussianBlur(img,(21,21),2)

img_lap=cv2.Laplacian(img,cv2.CV_32F)

img_ga_lap=cv2.Laplacian(img_ga,cv2.CV_32F)

cv2.imshow("img",img)

cv2.imshow("img_ga",img_ga)

cv2.imshow("img_lap",img_lap)

cv2.imshow("img_ga_lap",img_ga_lap)

cv2.waitKey(0)

cv2.destroyAllWindows()

#エッジの検出　Canny

#Laplacianのような輝度変化の細かいエッジ検出を抑制してくれる

①ガウシアンでぼかす（ノイズを除去する）

②Sobelフィルター x方向微分,y方向微分　を得る

　２乗和（いわゆる強度のこと）を採用する

③極大点を探す＝エッジ

　除去：エッジではないノイズ（右肩上がり）、グラデーション（微分値が小さい）

④２段階の閾値処理でエッジを残す

　１）閾値１以上の大きなエッジは残す

　２）閾値１よりは小さいが、閾値２以上でエッジにつながっている場合は細かいエッジとして残す

# In[ ]:

#エッジの検出　Cannyを実装する

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Lena.jpg",0)

img_canny=cv2.Canny(img,10,180)#低い閾値,高い閾値

img_canny2=cv2.Canny(img,120,150)#低い閾値,高い閾値

cv2.imshow("img_canny",img_canny)

cv2.imshow("img_canny2",img_canny2)

cv2.waitKey(0)

cv2.destroyAllWindows()

#直線　円の検出

直線は２つのパラメータで決まる

y=ax+b　が一般的だが

ρ：原点から直線までの距離

θ：原点を通る直線の法線とx軸とのなす角

とすると

y=-(cosθ/sinθ)x + (ρ/sinθ)

でもいい

でも、この方法はθが小さいとき yが発散してしまうので使えない。

べつの方法としベクトルを使ってみる

# In[ ]:

#直線の検出

import cv2

import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/road.jpg")

img_gray=cv2.imread(r"C:\Users\omoiy\data/src/road.jpg",0)

img_canny=cv2.Canny(img_gray,300,400)

cv2.imshow("img",img)

cv2.imshow("img_gray",img_gray)

cv2.imshow("img_canny",img_canny)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

lines=cv2.HoughLines(img_canny,1,np.pi/180,100)#1はρの刻み幅,θの刻み幅,集計表の閾値

# In[ ]:

for i in lines[:]:

rho = i[0][0]

theta = i[0][1]

a = np.cos(theta)

b = np.sin(theta)

x0 = rho*a

y0 = rho*b

x1 = int(x0+1000*(-b))

y1 = int(y0+1000*(a))

x2 = int(x0-1000*(-b))

y2 = int(x0-1000*(a))

cv2.line(img,(x1,y1),(x2,y2),(255,0,0),1)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#円の検出

import cv2

img2=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg")

img2_gray=cv2.imread(r"C:\Users\omoiy\data/src/grapes.jpg",0)

cv2.imshow("img",img2)

cv2.imshow("img_gray",img2_gray)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

get_ipython().set_next_input('circles=cv2.HoughCircles');get_ipython().run_line_magic('pinfo', 'cv2.HoughCircles')

# In[ ]:

circles=cv2.HoughCircles(img2_gray,cv2.HOUGH_GRADIENT,dp=1,minDist=1,param1=20,param2=35,minRadius=1,maxRadius=30)

# In[ ]:

for i in circles[0]:

cv2.circle(img2,(i[0],i[1]),i[2],(255,0,0),1)

cv2.imshow("img",img2)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#モルフォロジー演算

モノの形についての演算（黒の中に白の図形があるとき）

収縮 erode ：白が小さくなる。モノとモノを分離したいとき

膨張 dilate：白が大きくなる。モノとモノを連結したいとき

黒画像中に白いノイズがある場合

オープニング：収縮→膨張　白いノイズを小さくして、ノイズが消えてから、再びサイズを戻す。

クロージング：膨張→収縮　ノイズの大きさはそのまま。変化なし

# In[ ]:

import cv2

import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/floor.jpg",0)#グレースケール

#モルフォロジー演算をするためには２値化画像が必要になる

ret,img_th=cv2.threshold(img,110,255,cv2.THRESH_BINARY)

cv2.imshow("img",img)

cv2.imshow("img_th",img_th)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

kernel=np.ones((3,3),dtype=np.uint8) #着目画素の大きさを定義する

img_d=cv2.dilate(img_th,kernel)#膨張　着目画素に白画素があったら自分も白にする

img_e=cv2.erode(img_th,kernel)#収縮　着目画素に黒画素があったら自分も黒にする

#cv2.imshow("img",img)

#cv2.imshow("img_th",img_th)

cv2.imshow("img_dilate",img_d) #白が増える

cv2.imshow("img_erode",img_e) #黒が増える　

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#クロージング　（膨張と比較する）

img_c=cv2.morphologyEx(img_th,cv2.MORPH_CLOSE,kernel)

cv2.imshow("img_dilate",img_d) #膨張のみ　白が増える

cv2.imshow("img_clising",img_c) #膨張→収縮膨張で白飛びした穴を収縮で黒く埋めていく。

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#インペイント

#画像の中の落書きを消す

#周囲の画像を使って消していく

import cv2

import numpy as np

img=cv2.imread(r"C:\Users\omoiy\data/src/Bus.jpg") #落書き入りの元画像

img_mask=cv2.imread(r"C:/Users/omoiy/data/src/Mask.jpg",0)#落書き部分を抜き出した画像グレースケールで

cv2.imshow("img",img)

cv2.imshow("img_mask",img_mask)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#img_mask グレースケールを二値化する

thresh=1 #閾値

ret,img_bi=cv2.threshold(img_mask,thresh,255,cv2.THRESH_BINARY)

cv2.imshow("img_binary",img_bi)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#マスクした部分の周辺画像を拾って、マスク内に繰り返し何回も侵入させていく。

img_dst=cv2.inpaint(img,img_bi,3,cv2.INPAINT_NS)#ナビエストークス

cv2.imshow("img",img)

cv2.imshow("img_dst",img_dst) #うまく落書きが消えた

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#特徴抽出

#Harirsのコーナー検出

情報量：フラット＜エッジ＜コーナー

フラット： n個の固有ベクトルの固有値に大小がない。ほぼ均一

エッジ： n個の固有ベクトルのうち１つの固有値が大きくなる

コーナー： n個の固有ベクトルのうち２つの固有値が大きくなる

#そのほか

ORB（早い）, KAZE , AKAZEがお手軽で良い

#商用利用不可

SIFT:徴量128次元

SURF:SIFTを高速化

# In[ ]:

#オリジナルデータを読み込む

import cv2

import numpy as np

import copy

img=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg")#オリジナル画像

img_gray=cv2.imread(r"C:\Users\omoiy\data/src/buildings.jpg",0)#グレースケール画像

cv2.imshow("img",img)

cv2.imshow("img_gray",img_gray)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#harrisのコーナー検出をやってみる

import cv2

import numpy as np

import copy

img_harris=copy.deepcopy(img) #特徴点が元画像に上書きされてしまうので、imgのディープコピーをimg_harrisとしてとっておく

img_dst=cv2.cornerHarris(img_gray,2,3,0.04)#コーナー検出の範囲サイズ,ソーベルフィルターの大きさ,0.04～0.05がいいらしい

img_dst

"""２つの固有値を掛け算した＝値が大きいと固有値が２つあるということ

array([[ 4.5360382e-12, 4.5360382e-12, 1.1455559e-12, ...,

3.5410072e-10, 1.2930142e-10, -5.0405020e-11],

[ 4.5360382e-12, 4.5360382e-12, 1.1455559e-12, ...,

3.5410072e-10, 1.2930142e-10, -5.0405020e-11],

[ 4.2316191e-09, 4.2316191e-09, 3.0776899e-09, ...,

-5.2589849e-10, 3.0621861e-10, 2.3705888e-09],

"""

#harrisデータimg_dstの内、5%以上であれば、特徴点とみなすことにする

img_harris[img_dst > 0.05*img_dst.max()]=[0,0,255]#BGR 特徴点を赤でマーキングする ,

cv2.imshow("img_harris",img_harris) #コーナーが検出されている

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

# kaze（ケイズ）のコーナー検出をやってみる

import cv2

import numpy as np

import copy

img_kaze=copy.deepcopy(img) #特徴点が元画像に上書きされてしまうので、imgのディープコピーをとっておく

kaze=cv2.KAZE_create() #特徴抽出器のインスタンスkazeを生成しておく

kp1=kaze.detect(img,None) #特徴点を探してkp1に代入する

img_kaze=cv2.drawKeypoints(img_kaze,kp1,None)#特徴点kp1を描く

cv2.imshow("img_kaze",img_kaze)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

# accerate kaze（アクセレイト　ケイズ）のコーナー検出をやってみる

import cv2

import numpy as np

import copy

img_akaze=copy.deepcopy(img) #特徴点が元画像に上書きされてしまうので、imgのディープコピーをとっておく

akaze=cv2.AKAZE_create() #特徴抽出器のインスタンスkazeを生成しておく

kp1=akaze.detect(img,None) #特徴点を探してkp1に代入する

img_akaze=cv2.drawKeypoints(img_akaze,kp1,None)#特徴点kp1を描く

cv2.imshow("img_akaze",img_akaze)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

# orb（オーブ）のコーナー検出をやってみる

import cv2

import numpy as np

import copy

img_orb=copy.deepcopy(img)

orb=cv2.ORB_create()#インスタンスを生成する

kp2=orb.detect(img_orb)

img_orb=cv2.drawKeypoints(img_orb,kp2,None)

cv2.imshow("img_orb",img_orb)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[ ]:

#コーナー検出を比較する

import cv2

import numpy as np

import copy

cv2.imshow("img_harris",img_harris)

cv2.imshow("img_kaze",img_kaze)

cv2.imshow("img_akaze",img_akaze)

cv2.imshow("img_orb",img_orb)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[4]:

#顏検出

import cv2

#ハールファイル　特徴検出器：すでにopencvに入っている

HAAR_FILE="C:/Users/omoiy/Anaconda3/pkgs/opencv3-3.1.0-py35_0/Library/etc/haarcascades/haarcascade_frontalface_default.xml"

cascade=cv2.CascadeClassifier(HAAR_FILE)#分類検出器のインスタンスを作成する

img=cv2.imread(r"C:/Users/omoiy/data/src/Solvay_conference_1927.jpg")

img_gray=cv2.imread(r"C:/Users/omoiy/data/src/Solvay_conference_1927.jpg",0)

cv2.imshow("img",img)

cv2.imshow("img_gray",img_gray)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[8]:

face=cascade.detectMultiScale(img_gray)

face

"""　座標x,座標y,幅w,高さh

array([[1061, 877, 37, 37],

[ 115, 570, 53, 53],

[ 421, 568, 60, 60],

"""

for x,y,w,h in face:

cv2.rectangle(img,(x,y),(x+w,y+h),(0,0,255),1)　#顔を四角で囲む

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[21]:

#ブロブの検出

import cv2 ,copy

img=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png")

img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png",0)

cv2.imshow("img",img)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[23]:

ret,img_bi=cv2.threshold(img_gray,100,255,cv2.THRESH_BINARY) #グレースケールを二値化

cv2.imshow("img_bi",img_bi)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[34]:

nLabels,labelImage,stats,centroids=cv2.connectedComponentsWithStats(img_bi) #ブロブの検出

nLabels # 5 ：ブロブが５個検出された　背景も１個として検出される

labelImage

"""ラベルのIDが　ふられる

array([[0, 0, 0, ..., 0, 0, 0],←背景

[0, 0, 0, ..., 0, 0, 0],

"""

stats

"""あるブロブの最小のx 最小のy　幅w　高さh 面積s

array([[ 0, 0, 1672, 1078, 1578760],←背景

[ 818, 88, 365, 311, 56799],

[ 256, 143, 150, 150, 17656],

[ 163, 471, 336, 363, 89208],

[ 1048, 574, 302, 288, 59993]], dtype=int32)

"""

img_blob=copy.deepcopy(img)

h,w=img_gray.shape

color=[[255,0,255],[0,255,0],[0,0,255],[255,255,0]]#塗る色のリストが必要

for y in range(h):

for x in range(w):

if labelImage[y,x]>0:#背景のlabel Imageは0なので、それ以外の時、色を塗る

img_blob[y,x]=color[labelImage[y,x]-1]

for i in range(1,nLabels):#背景(0)は除く

xc=int(centroids[i][0])

yc=int(centroids[i][1])

font=cv2.FONT_HERSHEY_COMPLEX

scale=1

color=(255,255,255)

cv2.putText(img_blob,str(stats[i][-1]),(xc,yc),font,scale,color)

# In[35]:

cv2.imshow("img_blob",img_blob)

cv2.waitKey(0)

cv2.destroyAllWindows()

# In[36]:

#輪郭検出

import cv2

img=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png")

img_gray=cv2.imread(r"C:\Users\omoiy\data/src/Blob.png",0) #グレースケール

ret,img_bi=cv2.threshold(img_gray,100,255,cv2.THRESH_BINARY) #二値化

# In[40]:

img_con,contours,hierarchy=cv2.findContours(img_bi,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)#３角形の中の３角形まで検出する,最低限の輪郭を検出

img_contour=cv2.drawContours(img,contours,-1,(255,0,0),5)#全ての輪郭を描く（-1) , 色 , 太さ

# In[41]:

cv2.imshow("img",img)

cv2.imshow("img_gray",img_gray)

cv2.imshow("img_contour",img_contour)

cv2.waitKey(0)

cv2.destroyAllWindows()

Raspberry Pi 3 Model B+とOpenCVで　すきまを測定したい #1

こんにちは　かずまなぶです。(‘ω’)

モノとモノの隙間を測定するときに、ものさしとかノギスとかを使いますが、画像で測定できないかなと思い、押し入れに眠っているRasbery pi3 B+とOpenCVと3.5インチの小型タッチパネルを使って、ハンディな測定器を作れないか検討しはじめました。

手順は下記の通り考えています。

手順

Rasbery piのOSインストーラーをwindows端末からwebにアクセスしてゲット。
OSインストーラをマイクロUSBにコピーし、Rasberypiに指して起動してOSをインストール
初期設定：IP addr 固定 , ネットワーク接続 , カメラ有効化 , SSH有効化　
OpenCVに必要なライブラリなどをインストールする
OpenCVをインストールする
カメラを接続して、写真を撮る
撮った写真をOpenCVで画像処理して輪郭検出
「実スケールの基準物体」と「輪郭検出した画像のエッジ間ピクセル数」との校正曲線を作成する。
上記輪郭検出によるエッジ間距離を校正曲線によって実スケールに変換する。
検出したエッジ間距離を表示する。
番外：タッチパネルを使ってみる
番外：SSHを使ってみる

事前準備が長いのですが、やっていきましょう。つまずいたらコメント欄から助けてください。(*’▽’)

１．Rasbery piのOSをwindows端末からwebにアクセスしてゲット。

https://www.raspberrypi.org/downloads/noobs/

ここから　Rasbianのインストーラをダウンロードする

まずは、上記webサイトからラズパイ用のOSであるRasbianのインストーラをダウンロードしましょう。今回はNOOBSというRasbian+αのインストーラを使います。

NOOBS　「ダウンロードZIPをダウンロード」ボタンを押します。NOOBS Liteの方ではありませんので注意です。1.6GB 10分弱くらいかかりました。　→ダウンロード開始

２．OSインストーラをマイクロUSBにコピーして、Rasberypiに指して起動

ダウンロードしたファイル　NOOBS_v3_0_0.zip　を解凍してマイクロUSBにコピーして、ラズパイに挿します。

ラズパイを起動するとウィザードが立ち上がるので、NOOBSをインストールします。

３．初期設定：IP addr 固定 , ネットワーク接続 , カメラ有効化 , SSH有効化

この時点ではwifiを切断しておくこと。

①SSHの有効化（外部端末での接続設定）
メニュー＞ラズパイの設定>インターフェイス＞SSH有効＞OK

ついでに一緒にカメラ有効にもチェックを入れておきましょう。

②IPアドレスの固定
メニュー＞wirelessアイコンを右クリック＞Wireless & Network Preferences
Configure＞SSID
Automatically configure empty options＞チェックを外す

IPv4 = 192.168.1.81/24 →81のところは好きな数字で良い
Router = 192.168.1.1
DNS Servers = 192.168.1.1

③wifiの接続
wifi＞選択＞パスワードを打つ

④固定アドレスになっていることを確認する
ip addr →　inet 192.168.1.81

これでSSHからの接続ができる（はずなんですが！！できませんでした！）

⑤Puttyをwindows端末にインストールして、192.168.1.81にSSHでアクセスする。

→できませんでした。time outになります！！助けてください！

４．OpenCVに必要なライブラリなどをインストールする

SSHができなくても、何ら問題はないのでOpenCV関連をインストールして行きましょう。

インストール済みのパッケージをアップデートする。

# on tarminal
sudo apt-get update
sudo apt-get upgrade

# on tarminal

sudo apt-get update

sudo apt-get upgrade

何回か繰り返さないと完全にアップデートできませんでした。

私は　アップデート２回→アップグレード１回で終わりました。１回目は結構時間がかかります。

cmake関係のインストール

　（コンパイラに依存しないビルドの自動化）
sudo apt-get install build-essential cmake pkg-config

画像の入出力用のパッケージをインストール

sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

1	sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

動画の入出力用のパッケージをインストール

sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
sudo apt-get install libxvidcore-dev libx264
↑エラー発生　E: パッケージ libx264 が見つかりません

GTKをインストール（OpenCV のhighguiモジュールに必要）

sudo apt-get install libgtk2.0-dev

OpenCVの行列演算パッケージをインストール

sudo apt-get install libatlas-base-dev gfortran

Python 2.7とPython 3のヘッダファイルをインストール

sudo apt-get install python2.7-dev python3-dev
↓
python2.7-dev はすでに最新バージョン (2.7.13-2+deb9u3) です。
python3-dev はすでに最新バージョン (3.5.3-1) です。

５．OpenCVをインストールする

OpenCVのソースコードをダウンロードして、解凍する

wget -O opencv.zip https://github.com/Itseez/opencv/archive/3.1.0.zip
unzip opencv.zip

OpenCVの追加機能のソースコードをダウンロードして、解凍する

wget -O opencv_contrib.zip https://github.com/Itseez/opencv_contrib/archive/3.1.0.zip
unzip opencv_contrib

解凍したソースコードを下記ディレクトリの中に入れる（まとめておく）

ディレクトリ：/home/pi/Library/opencv/

pipをインストール

wget https://bootstrap.pypa.io/get-pip.py
sudo python3 get-pip.py

virtualenvとvirtualenvwrapperをインストール

sudo pip install virtualenv virtualenvwrapper
sudo rm -rf ~/.cache/pip
↑なんか消す

vimをインストール

sudo apt-get install vim

vimで /home/pi/.bashrcを開く

[a]キーで行末に追記モード
下記8行を行末に追加する。
escapeキーで追記モードを抜けて :wqでファイルに保存する。

慣れてないと、なんでこんな操作方法にしたのか、意味不明に思います。

#virtualenv and virtualenvwrapper

export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3.5
export VIRTUALENVWRAPPER_VIRTUALENV=/usr/local/bin/virtualenv
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS=’–no-site-packages’
source /usr/local/bin/virtualenvwrapper.sh

ここまで

今編集した　/home/pi/.bashrcを実行

source ~/.bashrc

一旦リブートしておく

sudo reboot

※2019.3.24現在、以下の仮想環境作成が動作しなくなりました。

替わりに、この時点で再度ターミナルを開いて下記のコマンドを打つと、OpenCVがインストールされました。（注：でもやってはだめです。）

sudo apt-get install python-opencv

しかし、この方法ではpython2のほうに古いopenCVが入ってしまい、python3でインポートしようとしてもエラーになります！！

解決策；

ひとまず仮想環境の構築はあきらめます。

作成したディレクトリ　/home/pi/Library/opencv/のさらに下、

解凍したopencv-3.1.0に入ります。

下記のコードでターミナルから操作しましょう。

cd opencv-3.1.0
mkdir build-python3
cd build-python3

そして、

cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D INSTALL_PYTHON_EXAMPLES=ON \
-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.1.0/modules \
-D BUILD_EXAMPLES=ON \
-D BUILD_opencv_python2=ON \
-D BUILD_opencv_python3=ON \
-D WITH_FFMPEG=ON \
-D ENABLE_PRECOMPILED_HEADERS=OFF ..

そしてビルドします

make

このとき、makeの後ろにはなにもつけません。-j4をつけて CPUをフルでまわすと、とんでもない灼熱になり、ハングアップしてしまいます。

なにもつけなければ、１コア使用することになり、全部で４コアありますから２５％のCPU使用量です。８時間くらいかかりました・・・

　－ｊ２をつけて、2コアの50%でもよかったかもしれません。

続いて、インストールします
sudo make install

そして共有ライブラリの更新
sudo ldconfig

確認のために python3からimport cv2しましょう。エラーが出なければOKです。

超重要：このあと、openCVでカメラを起動しようにもできませんでした。

シェルコマンドではraspistillとかいうやつで起動できるのですが、cv2.VideoCapture(0)が機能しません。

ここではラズパイ専用カメラをしようしているので、一般的なwebカメラとして認識できるように下記のコードを実行することが必要でした。

注意点としては最後の部分は　「ぶい　よん　える　に」　です。

「ぶい　よん　いち　に」　だと思って奮闘してしまいました。

sudo modprobe bcm2835-v4l2

最後に、テストコードを記載しておきます。これで動けばOKです。

import numpy as np
import cv2

cap = cv2.VideoCapture(0)

while(True):
    ret, frame = cap.read()
    cv2.imshow('frame', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

import numpy as np

import cv2

cap = cv2.VideoCapture(0)

while(True):

ret, frame = cap.read()

cv2.imshow('frame', frame)

if cv2.waitKey(1) & 0xFF == ord('q'):

break

cap.release()

cv2.destroyAllWindows()

以上より、これ以降の記事は捨てます。

仮想環境を作成する　名称：cv-python3の場合

~~mkvirtualenv cv-python3 -p python3~~

作成した仮想環境に入る

~~worken cv-python3 -p python3~~
↓
~~成功すると(cv-python3) pi@raspberrypi:~ $ になる~~

仮想環境から抜けるとき（まだやらなくていい）

~~deactivate~~

作成した仮想環境を削除する（まだやらなくていい）

~~rmvirtualenv~~

numpyをインストール（仮想環境）

~~pip install numpy~~

OpcenCVをコンパイルしてインストールする（仮想環境）

~~workon cv-python3~~
~~cd opencv-3.1.0~~
~~mkdir build-python3~~
~~cd build-python3~~

~~cmake -D CMAKE_BUILD_TYPE=RELEASE \~~
~~-D CMAKE_INSTALL_PREFIX=/usr/local \~~
~~-D INSTALL_PYTHON_EXAMPLES=ON \~~
~~-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.1.0/modules \~~
~~-D BUILD_EXAMPLES=ON \~~
~~-D BUILD_opencv_python2=ON \~~
~~-D BUILD_opencv_python3=ON \~~
~~-D WITH_FFMPEG=ON \~~
~~-D ENABLE_PRECOMPILED_HEADERS=OFF ..~~

~~ビルドする~~

~~make~~

~~インストール~~
~~sudo make install~~

~~共有ライブラリの更新~~
~~sudo ldconfig~~

ファイル名をわかりやすいように変更する

~~cd /usr/local/lib/python3.5/site-packages/~~
~~sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so~~

共有ライブラリから仮想環境の共有ライブラリにリンクさせる

~~cd ~/.virtualenvs/cv-python3/lib/python3.5/site-packages/~~
~~ln -s /usr/local/lib/python3.5/site-packages/cv2.so cv2.so~~

OpenCVの起動をテストする

~~workon cv-python3~~
~~python3~~

~~import cv2~~
~~cv2.version~~
↓
~~‘3.1.0’~~

ここでいったん休憩しましょう。いやー長すぎですよね！次回はOpenCVを使って輪郭検出をやっていきましょう。

2024年11月
月	火	水	木	金	土	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

ステップ１：静止画像ファイルを読み込んで出力する

ステップ２動画ファイルを読み込んで出力する→リアルタイムキャプチャーする

ステップ３ リアルタイムキャプチャー と リアルタイム背景差分処理

カメラ

インストール

その他のライブラリをインストール

エラー

画像処理

結果

グラフ化

検出画像

メインスクリプト

グラフ作成スクリプト

bcm2835-v4l2 の自動化

ファイル書き込み禁止を解除する

本題：Opencvで顔認識をやってみる

落とし穴

思い出しました

弱点

念の為、試運転のコードを貼っておきます。

インストール済みのパッケージをアップデートする。

cmake関係のインストール

画像の入出力用のパッケージをインストール

動画の入出力用のパッケージをインストール

GTKをインストール（OpenCV のhighguiモジュールに必要）

OpenCVの行列演算パッケージをインストール

Python 2.7とPython 3のヘッダファイルをインストール

OpenCVのソースコードをダウンロードして、解凍する

OpenCVの追加機能のソースコードをダウンロードして、解凍する

解凍したソースコードを下記ディレクトリの中に入れる（まとめておく）

pipをインストール

virtualenvとvirtualenvwrapperをインストール

vimをインストール

vimで /home/pi/.bashrcを開く

ここまで

今編集した /home/pi/.bashrcを実行

一旦リブートしておく

仮想環境を作成する 名称：cv-python3の場合

作成した仮想環境に入る

仮想環境から抜けるとき（まだやらなくていい）

作成した仮想環境を削除する（まだやらなくていい）

numpyをインストール（仮想環境）

OpcenCVをコンパイルしてインストールする（仮想環境）

ビルドする

ファイル名をわかりやすいように変更する

共有ライブラリから仮想環境の共有ライブラリにリンクさせる

OpenCVの起動をテストする

ステップ３　リアルタイムキャプチャー　と　リアルタイム背景差分処理

bcm2835-v4l2　の自動化

今編集した　/home/pi/.bashrcを実行

仮想環境を作成する　名称：cv-python3の場合