画像処理の実際のプログラミングコードを紹介！学習法も一緒に解説

import cv2

# 画像の読み込み
image_path = "sample.jpg"  # 画像ファイルパスを指定
image = cv2.imread(image_path)

# 画像の表示
cv2.imshow("Image", image)
cv2.waitKey(0)  # 何かキーを押すまで待機
cv2.destroyAllWindows()  # ウィンドウを閉じる

# 画像の保存
output_path = "output.jpg"  # 保存する画像ファイルのパスを指定してください
cv2.imwrite(output_path, image)

print("画像の読み込み、表示、保存が完了しました。")

import cv2
import numpy as np

# 画像の読み込み
image_path = "sample.jpg"  # 画像ファイルパスを指定
image = cv2.imread(image_path)

# 画像のピクセル操作（例: 画像を灰色に変換）
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 画像のフィルタリング（例: ガウシアンフィルタを適用）
filtered_image = cv2.GaussianBlur(gray_image, (5, 5), 0)

# エッジ検出（例: Cannyエッジ検出器を適用）
edges = cv2.Canny(filtered_image, 100, 200)

# 結果を表示
cv2.imshow("Original Image", image)
cv2.imshow("Gray Image", gray_image)
cv2.imshow("Filtered Image", filtered_image)
cv2.imshow("Edges", edges)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

# 画像の読み込み
image_path = "input_image.jpg"  # 画像ファイルパスを指定
image = cv2.imread(image_path)

# グレースケール変換
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# ヒストグラム均等化
equalized_image = cv2.equalizeHist(gray_image)

# 二値化
_, binary_image = cv2.threshold(equalized_image, 128, 255, cv2.THRESH_BINARY)

# 結果を表示
cv2.imshow("Original Image", image)
cv2.imshow("Grayscale Image", gray_image)
cv2.imshow("Equalized Image", equalized_image)
cv2.imshow("Binary Image", binary_image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2
import numpy as np

# 画像の読み込み
image_path = "sample.jpg"  # 画像ファイルパスを指定
image = cv2.imread(image_path)

# 画像の水平反転（NumPyを使用）
flipped_image = np.fliplr(image)

# オリジナル画像の表示
cv2.imshow("Original Image", image)
cv2.waitKey(0)

# 水平反転した画像の表示
cv2.imshow("Flipped Image", flipped_image)
cv2.waitKey(0)

cv2.destroyAllWindows()

from PIL import Image

# 画像の読み込み
image_path = "sample.jpg"  # 画像ファイルパス指定
original_image = Image.open(image_path)

# 画像の表示（オリジナル）
original_image.show()

# 画像のリサイズ
width, height = original_image.size
resized_image = original_image.resize((width // 2, height // 2))  # 幅と高さを半分にリサイズ

# 画像の表示（リサイズ後）
resized_image.show()

# 画像の回転（90度回転）
rotated_image = original_image.rotate(90)

# 画像の表示（回転後）
rotated_image.show()

# 画像の保存
resized_image.save("resized_image.jpg")
rotated_image.save("rotated_image.jpg")

print("画像の処理と保存が完了しました。")

import cv2

# 2つの画像を読み込む
image1 = cv2.imread("image1.jpg", cv2.IMREAD_GRAYSCALE)
image2 = cv2.imread("image2.jpg", cv2.IMREAD_GRAYSCALE)

# ORB（Oriented FAST and Rotated BRIEF）ディスクリプタを作成
orb = cv2.ORB_create()

# 画像から特徴点とディスクリプタを抽出
keypoints1, descriptors1 = orb.detectAndCompute(image1, None)
keypoints2, descriptors2 = orb.detectAndCompute(image2, None)

# ブルートフォースマッチャーを使用して特徴点をマッチング
bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
matches = bf.match(descriptors1, descriptors2)

# マッチングされた特徴点を距離でソート
matches = sorted(matches, key=lambda x: x.distance)

# マッチングされた特徴点を描画
matching_result = cv2.drawMatches(image1, keypoints1, image2, keypoints2,
　　　　 matches[:10], None, flags=cv2.DrawMatchesFlags_NOT_DRAW_SINGLE_POINTS)

# マッチング結果を表示
cv2.imshow("Matching Result", matching_result)
cv2.waitKey(0)
cv2.destroyAllWindows()

import cv2

# Haar Cascade分類器の読み込み（顔検出用）
face_cascade = cv2.CascadeClassifier
　　　　　　　　　　　　　(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# 画像の読み込み
image_path = "face_detection.jpg"  # 画像ファイルのパスを指定してください
image = cv2.imread(image_path)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 顔の検出
faces = face_cascade.detectMultiScale
　　　　　　　　　　　　　　　(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

# 検出した顔に矩形を描画
for (x, y, w, h) in faces:
    cv2.rectangle(image, (x, y), (x+w, y+h), (255, 0, 0), 2)

# 検出結果を表示
cv2.imshow("Face Detection", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

import numpy as np
import cv2

# チェスボードのサイズ
chessboard_size = (9, 6)  # 内部コーナーの数（横方向×縦方向）

# チェスボードの内部コーナーの座標を保存するリスト
object_points = []
image_points = []

# チェスボードパターンの3D座標を計算
objp = np.zeros((chessboard_size[0] * chessboard_size[1], 3), np.float32)
objp[:, :2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.reshape(-1, 2)

# 画像からチェスボードの内部コーナーを検出
images = []  # チェスボードパターンが含まれる画像のリスト
for i in range(1, 11):  # 画像の枚数に合わせてループを調整
    image_path = f"chessboard{i}.jpg"  # チェスボードパターンが含まれる画像ファイルのパス
    image = cv2.imread(image_path)
    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # チェスボードの内部コーナーを検出
    ret, corners = cv2.findChessboardCorners(gray, chessboard_size, None)

    # 内部コーナーが検出された場合、座標を追加
    if ret:
        object_points.append(objp)
        image_points.append(corners)
        images.append(image)

# カメラキャリブレーションを実行
ret, mtx, dist, rvecs, tvecs = cv2.calibrateCamera
　　　　　　　　　　　　　　　　(object_points, image_points, gray.shape[::-1], None, None)

# 歪み補正を行った画像を表示
for i in range(len(images)):
    undistorted_image = cv2.undistort(images[i], mtx, dist)
    cv2.imshow(f"Undistorted Image {i+1}", undistorted_image)

cv2.waitKey(0)
cv2.destroyAllWindows()

import numpy as np
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

# サンプルデータを生成（適切なデータを用意する必要があります）
# 例: データは行がサンプル、列が特徴量である2次元のデータを考えます
# samples = np.array([...]) 

# データの標準化
scaler = StandardScaler()
samples_scaled = scaler.fit_transform(samples)

# PCAの適用（適切な主成分数を選択する必要があります）
pca = PCA(n_components=2)  # 2つの主成分を抽出
pca_result = pca.fit_transform(samples_scaled)

# 異常スコアの計算（ここでは簡単に各サンプルのユークリッド距離を異常スコアとして使用）
anomaly_scores = np.linalg.norm(samples_scaled - pca.inverse_transform(pca_result)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　, axis=1)

# 閾値の設定（適切な閾値を設定してください）
threshold = 2.5

# 異常を検出
anomalies = anomaly_scores > threshold

# 結果の表示
print("異常検知結果:")
print(anomalies)

import numpy as np
from sklearn import svm
import matplotlib.pyplot as plt

# サンプルデータの生成（正常データ）
np.random.seed(0)
normal_data = np.random.randn(100, 2) * 2

# 異常データの生成（異常データ）
np.random.seed(42)
anomaly_data = np.random.uniform(low=-10, high=10, size=(10, 2))

# データの結合
data = np.vstack([normal_data, anomaly_data])
labels = np.hstack([np.zeros(len(normal_data)), np.ones(len(anomaly_data))])

# SVMの訓練
clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.1)  # nuは外れ値の割合を指定
clf.fit(data)

# プロット
xx, yy = np.meshgrid(np.linspace(-15, 15, 500), np.linspace(-15, 15, 500))
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.Blues_r)
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors='orange')

plt.scatter(data[:, 0], data[:, 1], color='white')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('SVMによる異常検知')
plt.show()

# 新しいサンプルの判定（例）
new_samples = np.array([[1, 1], [8, 8], [0, 10]])
predictions = clf.predict(new_samples)
print("新しいサンプルの異常判定:", predictions)

import numpy as np
from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt

# サンプルデータの生成（正常データ）
np.random.seed(0)
normal_data = np.random.randn(1000, 20)  # 20次元の正常データ

# 異常データの生成（異常データ）
np.random.seed(42)
anomaly_data = np.random.uniform(low=-10, high=10, size=(100, 20))  # 20次元の異常データ

# データの結合
data = np.vstack([normal_data, anomaly_data])

# 正常データのラベルは0、異常データのラベルは1とする
labels = np.hstack([np.zeros(len(normal_data)), np.ones(len(anomaly_data))])

# データの分割
x_train, x_test, y_train, y_test = train_test_split(data, labels, test_size=0.2,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 random_state=42)

# オートエンコーダの構築
input_layer = Input(shape=(20,))
encoded = Dense(10, activation='relu')(input_layer)  # 中間層の次元は適宜調整可能
decoded = Dense(20, activation='sigmoid')(encoded)
autoencoder = Model(input_layer, decoded)

autoencoder.compile(optimizer='adam', loss='mean_squared_error')

# オートエンコーダの訓練
autoencoder.fit(x_train, x_train, epochs=50, batch_size=32, shuffle=True, 
　　　　　　　　　　　　　　　　　　　　　　　　　　validation_data=(x_test, x_test))

# テストデータを用いた再構築誤差の計算
reconstructed_data = autoencoder.predict(x_test)
reconstruction_errors = np.mean(np.square(reconstructed_data - x_test), axis=1)

# 再構築誤差をプロット
plt.figure(figsize=(12, 6))
plt.hist(reconstruction_errors, bins=50)
plt.xlabel('Reconstruction Error')
plt.ylabel('Frequency')
plt.title('Reconstruction Error Distribution')
plt.show()

# 異常判定の閾値を設定（例：再構築誤差の上位5%の値を閾値とする）
threshold = np.percentile(reconstruction_errors, 95)

# テストデータの異常判定
predictions = (reconstruction_errors > threshold).astype(int)
print("異常判定結果:", predictions)