2023-01-16 09:35:16 +01:00
{
"cells": [
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": 7,
"id": "eee0d1c0",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"import cv2 as cv\n",
"import numpy as np\n",
"import sklearn.svm\n",
"import sklearn.metrics\n",
"import matplotlib.pyplot as plt\n",
"%matplotlib inline\n",
"import os\n",
2023-01-30 13:54:58 +01:00
"import random\n",
"import zipfile\n"
2023-01-16 09:35:16 +01:00
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": 8,
"id": "8d43d9cb",
2023-01-16 09:35:16 +01:00
"metadata": {},
2023-01-30 13:54:58 +01:00
"outputs": [],
2023-01-16 09:35:16 +01:00
"source": [
2023-01-30 13:54:58 +01:00
"with zipfile.ZipFile('datasets/glasses.zip', 'r') as zip_ref:\n",
" zip_ref.extractall('.')"
2023-01-16 09:35:16 +01:00
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": 9,
"id": "ff47b069",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
2023-01-30 13:54:58 +01:00
"ename": "FileNotFoundError",
"evalue": "[WinError 3] System nie może odnaleźć określonej ścieżki: 'datasets/glasses/with'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mFileNotFoundError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_22952\\4086357420.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[0mdataset_dir\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"datasets/glasses\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mimages_0\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{dataset_dir}/with\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 3\u001b[0m \u001b[0mimages_0\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34mf\"{dataset_dir}/with/{x}\"\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mimages_0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mimages_1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlistdir\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf\"{dataset_dir}/without\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mimages_1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34mf\"{dataset_dir}/without/{x}\"\u001b[0m \u001b[1;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mimages_1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mFileNotFoundError\u001b[0m: [WinError 3] System nie może odnaleźć określonej ścieżki: 'datasets/glasses/with'"
2023-01-16 09:35:16 +01:00
]
}
],
"source": [
"dataset_dir = \"datasets/glasses\"\n",
"images_0 = os.listdir(f\"{dataset_dir}/with\")\n",
"images_0 = [f\"{dataset_dir}/with/{x}\" for x in images_0]\n",
"images_1 = os.listdir(f\"{dataset_dir}/without\")\n",
"images_1 = [f\"{dataset_dir}/without/{x}\" for x in images_1]\n",
"images = images_0 + images_1\n",
"random.seed(1337)\n",
"random.shuffle(images)\n",
"\n",
"train_data = []\n",
"test_data = []\n",
"train_labels = []\n",
"test_labels = []\n",
"\n",
"splitval = int((1-0.2)*len(images))\n",
"\n",
"for x in images[:splitval]:\n",
" train_data.append(cv.imread(x, cv.IMREAD_COLOR))\n",
" train_labels.append(x.split(\"/\")[2])\n",
" \n",
"for x in images[splitval:]:\n",
" test_data.append(cv.imread(x, cv.IMREAD_COLOR))\n",
" test_labels.append(x.split(\"/\")[2])\n",
" \n",
"d_labels = {\"with\": 0, \"without\": 1}\n",
" \n",
"train_labels = np.array([d_labels[x] for x in train_labels])\n",
"test_labels = np.array([d_labels[x] for x in test_labels])\n",
"\n",
"print(f\"Train data: {len(train_data)}, test data: {len(test_data)}\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "d24b53df",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"data": {
2023-01-30 13:54:58 +01:00
"image/png": "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
2023-01-16 09:35:16 +01:00
"text/plain": [
"<Figure size 1000x200 with 5 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.figure(figsize=(10,2))\n",
"for i in range(5):\n",
" plt.subplot(151 + i)\n",
" plt.imshow(train_data[i][:,:,::-1]);"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "d890ce1a",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"hp_win_size = (96, 32)\n",
"hp_block_size = (8, 8)\n",
"hp_block_stride = (8, 8)\n",
"hp_cell_size = (4, 4)\n",
"hp_n_bins = 9\n",
"hp_deriv_aperture = 0\n",
"hp_win_sigma = 4.0\n",
"hp_histogram_norm_type = 1\n",
"hp_l2_hys_threshold = 0.2\n",
"hp_gamma_correction = True\n",
"hp_n_levels = 64\n",
"hp_signed_gradient = True\n",
"\n",
"hog_descriptor = cv.HOGDescriptor(\n",
" hp_win_size, hp_block_size, hp_block_stride, hp_cell_size, \n",
" hp_n_bins, hp_deriv_aperture, hp_win_sigma, \n",
" hp_histogram_norm_type, hp_l2_hys_threshold, \n",
" hp_gamma_correction, hp_n_levels, hp_signed_gradient)\n",
"\n",
"train_hog = np.vstack([hog_descriptor.compute(x).ravel() for x in train_data])\n",
"test_hog = np.vstack([hog_descriptor.compute(x).ravel() for x in test_data])"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "51d48fa1",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"model = cv.ml.SVM_create()\n",
"model.setGamma(0.02)\n",
"model.setC(2.5)\n",
"model.setKernel(cv.ml.SVM_RBF)\n",
"model.setType(cv.ml.SVM_C_SVC)"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "49da552a",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"model.train(np.array(train_hog), cv.ml.ROW_SAMPLE, train_labels);"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "8b36012b",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ACC: 95.30 %\n"
]
}
],
"source": [
"predictions = model.predict(test_hog)[1].ravel()\n",
"accuracy = (test_labels == predictions).mean()\n",
"print(f\"ACC: {accuracy * 100:.2f} %\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "60558a32",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ACC: 95.30 %\n"
]
}
],
"source": [
"model = sklearn.svm.SVC(C=2.5, gamma=0.02, kernel='rbf')\n",
"model.fit(train_hog, train_labels)\n",
"\n",
"predictions = model.predict(test_hog)\n",
"accuracy = (test_labels == predictions).mean()\n",
"print(f\"ACC: {accuracy * 100:.2f} %\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "4eb3fd67",
2023-01-16 09:35:16 +01:00
"metadata": {},
2023-01-30 13:54:58 +01:00
"outputs": [],
2023-01-16 09:35:16 +01:00
"source": [
2023-01-30 13:54:58 +01:00
"with zipfile.ZipFile('inria-person-sub.zip', 'r') as zip_ref:\n",
" zip_ref.extractall('.')"
2023-01-16 09:35:16 +01:00
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "e1c807bb",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Train data: 1457, test data: 560\n"
]
}
],
"source": [
"dataset_dir = \"datasets/INRIAPerson\"\n",
"\n",
"images_train_0 = os.listdir(f\"{dataset_dir}/train_64x128_H96/negPatches\")\n",
"images_train_0 = [f\"{dataset_dir}/train_64x128_H96/negPatches/{x}\" for x in images_train_0]\n",
"images_train_1 = os.listdir(f\"{dataset_dir}/train_64x128_H96/posPatches\")\n",
"images_train_1 = [f\"{dataset_dir}/train_64x128_H96/posPatches/{x}\" for x in images_train_1]\n",
"\n",
"images_test_0 = os.listdir(f\"{dataset_dir}/test_64x128_H96/negPatches\")\n",
"images_test_0 = [f\"{dataset_dir}/test_64x128_H96/negPatches/{x}\" for x in images_test_0]\n",
"images_test_1 = os.listdir(f\"{dataset_dir}/test_64x128_H96/posPatches\")\n",
"images_test_1 = [f\"{dataset_dir}/test_64x128_H96/posPatches/{x}\" for x in images_test_1]\n",
"\n",
"train_data = []\n",
"test_data = []\n",
"train_labels = []\n",
"test_labels = []\n",
"\n",
"for x in images_train_0:\n",
" img = cv.imread(x, cv.IMREAD_COLOR)\n",
" if img is not None:\n",
" train_data.append(img)\n",
" train_labels.append(0)\n",
"\n",
"for x in images_train_1:\n",
" img = cv.imread(x, cv.IMREAD_COLOR)\n",
" if img is not None:\n",
" train_data.append(img)\n",
" train_labels.append(1)\n",
" \n",
"for x in images_test_0:\n",
" img = cv.imread(x, cv.IMREAD_COLOR)\n",
" if img is not None:\n",
" test_data.append(img)\n",
" test_labels.append(0)\n",
"\n",
"for x in images_test_1:\n",
" img = cv.imread(x, cv.IMREAD_COLOR)\n",
" if img is not None:\n",
" test_data.append(img)\n",
" test_labels.append(1)\n",
"\n",
"print(f\"Train data: {len(train_data)}, test data: {len(test_data)}\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "16a9c764",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"data": {
2023-01-30 13:54:58 +01:00
"image/png": "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
2023-01-16 09:35:16 +01:00
"text/plain": [
"<Figure size 1000x200 with 6 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plt.figure(figsize=(10,2))\n",
"for i in range(3):\n",
" plt.subplot(161 + i)\n",
" plt.imshow(train_data[i][:,:,::-1]);\n",
"for i in range(3):\n",
" plt.subplot(164 + i)\n",
" plt.imshow(train_data[-(i+1)][:,:,::-1]);"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "d30d8124",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"hp_win_size = (64, 128)\n",
"hp_block_size = (16, 16)\n",
"hp_block_stride = (8, 8)\n",
"hp_cell_size = (8, 8)\n",
"hp_n_bins = 9\n",
"hp_deriv_aperture = 1\n",
"hp_win_sigma = -1\n",
"hp_histogram_norm_type = 0\n",
"hp_l2_hys_threshold = 0.2\n",
"hp_gamma_correction = True\n",
"hp_n_levels = 64\n",
"hp_signed_gradient = False\n",
"\n",
"hog_descriptor = cv.HOGDescriptor(\n",
" hp_win_size, hp_block_size, hp_block_stride, hp_cell_size, \n",
" hp_n_bins, hp_deriv_aperture, hp_win_sigma, \n",
" hp_histogram_norm_type, hp_l2_hys_threshold, \n",
" hp_gamma_correction, hp_n_levels, hp_signed_gradient)\n",
"\n",
"train_hog = np.vstack([hog_descriptor.compute(x).ravel() for x in train_data])\n",
"test_hog = np.vstack([hog_descriptor.compute(x).ravel() for x in test_data])"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "b5573a14",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"model = cv.ml.SVM_create()\n",
"model.setGamma(0)\n",
"model.setC(0.01)\n",
"model.setKernel(cv.ml.SVM_LINEAR)\n",
"model.setType(cv.ml.SVM_C_SVC)\n",
"model.setTermCriteria((cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 1000, 1e-3))"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "b0a346d2",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [],
"source": [
"model.train(np.array(train_hog), cv.ml.ROW_SAMPLE, np.array(train_labels));"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "0af58f2a",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"ACC: 96.96 %\n"
]
}
],
"source": [
"predictions = model.predict(test_hog)[1].ravel()\n",
"accuracy = (test_labels == predictions).mean()\n",
"print(f\"ACC: {accuracy * 100:.2f} %\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "e8ca1b8d",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Accuracy: 96.96 %\n",
"Precision: 93.55 %\n",
"Recall: 88.78 %\n"
]
}
],
"source": [
"model2 = sklearn.svm.SVC(C=0.01, gamma='auto', kernel='linear', max_iter=1000)\n",
"model2.fit(train_hog, train_labels)\n",
"\n",
"predictions = model2.predict(test_hog)\n",
"accuracy = (test_labels == predictions).mean()\n",
"print(f\"Accuracy: {sklearn.metrics.accuracy_score(test_labels, predictions) * 100:.2f} %\")\n",
"print(f\"Precision: {sklearn.metrics.precision_score(test_labels, predictions) * 100:.2f} %\")\n",
"print(f\"Recall: {sklearn.metrics.recall_score(test_labels, predictions) * 100:.2f} %\")"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "44e186c1",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
2023-01-30 13:54:58 +01:00
"data": {
"image/png": "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
"text/plain": [
"<Figure size 600x600 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
2023-01-16 09:35:16 +01:00
}
],
"source": [
2023-01-30 13:54:58 +01:00
"image = cv.imread(\"pedestrians.jpg\", cv.IMREAD_COLOR)\n",
2023-01-16 09:35:16 +01:00
"scale = 600 / image.shape[0]\n",
"image = cv.resize(image, None, fx=scale, fy=scale)\n",
"\n",
"support_vectors = model.getSupportVectors()\n",
"rho, _, _ = model.getDecisionFunction(0)\n",
"detector = np.zeros(support_vectors.shape[1] + 1, dtype=support_vectors.dtype)\n",
"detector[:-1] = -support_vectors[:]\n",
"detector[-1] = rho\n",
"\n",
"hog_descriptor.setSVMDetector(detector)\n",
"\n",
"locations, weights = hog_descriptor.detectMultiScale(\n",
" image, winStride=(8, 8), padding=(32, 32), scale=1.05,\n",
2023-01-30 13:54:58 +01:00
" hitThreshold=1.0)\n",
2023-01-16 09:35:16 +01:00
"\n",
"for location, weight in zip(locations, weights):\n",
" x1, y1, w, h = location\n",
" x2, y2 = x1 + w, y1 + h\n",
" cv.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), thickness=3, lineType=cv.LINE_AA)\n",
2023-01-30 13:54:58 +01:00
" #cv.putText(image, f\"{weight[0]:.2f}\", (x1,y1), cv.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2, cv.LINE_AA)\n",
2023-01-16 09:35:16 +01:00
"\n",
"plt.figure(figsize=(6,6))\n",
"plt.imshow(image[:,:,::-1]);"
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "dc5f6442",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
2023-01-30 13:54:58 +01:00
"data": {
"image/png": "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
"text/plain": [
"<Figure size 600x600 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
2023-01-16 09:35:16 +01:00
}
],
"source": [
2023-01-30 13:54:58 +01:00
"image = cv.imread(\"pedestrians.jpg\", cv.IMREAD_COLOR)\n",
"\n",
2023-01-16 09:35:16 +01:00
"\n",
"hog_dflt_descriptor = cv.HOGDescriptor(\n",
" hp_win_size, hp_block_size, hp_block_stride, hp_cell_size, \n",
" hp_n_bins, hp_deriv_aperture, hp_win_sigma, \n",
" hp_histogram_norm_type, hp_l2_hys_threshold, \n",
" hp_gamma_correction, hp_n_levels, hp_signed_gradient)\n",
"\n",
"detector_dflt = cv.HOGDescriptor_getDefaultPeopleDetector()\n",
"hog_dflt_descriptor.setSVMDetector(detector_dflt)\n",
"\n",
"locations, weights = hog_dflt_descriptor.detectMultiScale(\n",
" image, winStride=(8, 8), padding=(32, 32), scale=1.05,\n",
2023-01-30 13:54:58 +01:00
" hitThreshold=1.0)\n",
2023-01-16 09:35:16 +01:00
"\n",
"for location, weight in zip(locations, weights):\n",
" x1, y1, w, h = location\n",
" x2, y2 = x1 + w, y1 + h\n",
" cv.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), thickness=3, lineType=cv.LINE_AA)\n",
2023-01-30 13:54:58 +01:00
" #cv.putText(image, f\"{weight[0]:.2f}\", (x1,y1), cv.FONT_HERSHEY_SIMPLEX, 1, (0,0,255), 2, cv.LINE_AA)\n",
2023-01-16 09:35:16 +01:00
"\n",
"plt.figure(figsize=(6,6))\n",
"plt.imshow(image[:,:,::-1]);"
]
},
{
2023-01-30 13:54:58 +01:00
"cell_type": "code",
"execution_count": null,
"id": "b8bfa09b",
2023-01-16 09:35:16 +01:00
"metadata": {},
2023-01-30 13:54:58 +01:00
"outputs": [
{
"data": {
"text/plain": [
"((257, 309), (372, 540))"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
2023-01-16 09:35:16 +01:00
"source": [
2023-01-30 13:54:58 +01:00
"(x1, y1), (x2, y2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "17d77e0d",
"metadata": {},
"outputs": [
{
"ename": "AttributeError",
"evalue": "'NoneType' object has no attribute 'shape'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_22952\\55986056.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[1;31m# to the loaded image, with the\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 16\u001b[0m \u001b[1;31m# shape and return type\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 17\u001b[1;33m \u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0muint8\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 18\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 19\u001b[0m \u001b[1;31m# specify the background and foreground model\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'shape'"
]
}
],
"source": [
"# Python program to illustrate\n",
"# foreground extraction using\n",
"# GrabCut algorithm\n",
2023-01-16 09:35:16 +01:00
"\n",
2023-01-30 13:54:58 +01:00
"# organize imports\n",
"import numpy as np\n",
"import cv2 as cv\n",
"from matplotlib import pyplot as plt\n",
2023-01-16 09:35:16 +01:00
"\n",
2023-01-30 13:54:58 +01:00
"# path to input image specified and\n",
"# image is loaded with imread command\n",
"image = cv.imread(\"messi5.jpg\")\n",
"\n",
"# create a simple mask image similar\n",
"# to the loaded image, with the\n",
"# shape and return type\n",
"mask = np.zeros(image.shape[:2], np.uint8)\n",
"\n",
"# specify the background and foreground model\n",
"# using numpy the array is constructed of 1 row\n",
"# and 65 columns, and all array elements are 0\n",
"# Data type for the array is np.float64 (default)\n",
"backgroundModel = np.zeros((1, 65), np.float64)\n",
"foregroundModel = np.zeros((1, 65), np.float64)\n",
"\n",
"# define the Region of Interest (ROI)\n",
"# as the coordinates of the rectangle\n",
"# where the values are entered as\n",
"# (startingPoint_x, startingPoint_y, width, height)\n",
"# these coordinates are according to the input image\n",
"# it may vary for different images\n",
"rectangle = (80, 40, 460, 330)\n",
"\n",
"# apply the grabcut algorithm with appropriate\n",
"# values as parameters, number of iterations = 3\n",
"# cv2.GC_INIT_WITH_RECT is used because\n",
"# of the rectangle mode is used\n",
"cv.grabCut(image, mask, rectangle,\n",
" backgroundModel, foregroundModel,\n",
" 3, cv.GC_INIT_WITH_RECT)\n",
"\n",
"# In the new mask image, pixels will\n",
"# be marked with four flags\n",
"# four flags denote the background / foreground\n",
"# mask is changed, all the 0 and 2 pixels\n",
"# are converted to the background\n",
"# mask is changed, all the 1 and 3 pixels\n",
"# are now the part of the foreground\n",
"# the return type is also mentioned,\n",
"# this gives us the final mask\n",
"mask2 = np.where((mask == 2)|(mask == 0), 0, 1).astype('uint8')\n",
"\n",
"# The final mask is multiplied with\n",
"# the input image to give the segmented image.\n",
"image = image * mask2[:, :, np.newaxis]\n",
"\n",
"# output segmented image with colorbar\n",
"plt.imshow(image[:,:,::-1])\n",
"plt.colorbar()\n",
"plt.show()\n"
2023-01-16 09:35:16 +01:00
]
},
{
2023-01-30 13:54:58 +01:00
"cell_type": "code",
"execution_count": null,
"id": "d2797ab7",
2023-01-16 09:35:16 +01:00
"metadata": {},
2023-01-30 13:54:58 +01:00
"outputs": [],
2023-01-16 09:35:16 +01:00
"source": [
2023-01-30 13:54:58 +01:00
"x1, y1, x2, y2 = 60, 55, 480, 340"
2023-01-16 09:35:16 +01:00
]
},
{
"cell_type": "code",
2023-01-30 13:54:58 +01:00
"execution_count": null,
"id": "ff0f08aa",
2023-01-16 09:35:16 +01:00
"metadata": {},
"outputs": [
{
"data": {
2023-01-30 13:54:58 +01:00
"text/plain": [
"<matplotlib.image.AxesImage at 0x26ad5e46dc0>"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAFmCAYAAABHt2EEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9z69tW3IVDI6IOefa597nTIMxlcYf2DLIlpBxA4wqbSSLFla5QWHoIJAQnZJAblkuhLDcsZFlCxoUjQIkdwrTQPAP0MB0EJKFSoWoDkLIDYSh5CQ/48TO9+49e60ZEdUYEXOtfe/L9AMMme/zWU/nnXt+7b1+zB8jRowYIREReDlejpfj5Xg5Xo6X4+X4Ojr0a30CL8fL8XK8HC/Hy/FyvBzvHi8A5eV4OV6Ol+PleDlejq+74wWgvBwvx8vxcrwcL8fL8XV3vACUl+PleDlejpfj5Xg5vu6OF4DycrwcL8fL8XK8HC/H193xAlBejpfj5Xg5Xo6X4+X4ujteAMrL8XK8HC/Hy/FyvBxfd8cLQHk5Xo6X4+V4OV6Ol+Pr7ngBKC/Hy/FyvBwvx8vxcnzdHS8A5eV4OV6Ol+PleDlejq+742sKUP7u3/27+I7v+A48PT3he7/3e/Ev/sW/+FqezsvxcrwcL8fL8XK8HF8nx9cMoPzjf/yP8aM/+qP4iZ/4Cfzrf/2v8QM/8AP4oR/6IfzyL//y1+qUXo6X4+V4OV6Ol+Pl+Do55GvVLPDzn/88/sgf+SP4e3/v763v/cE/+Afxwz/8w/jZn/3Zr8UpvRwvx8vxcrwcL8fL8XVy9K/Fm+77jn/1r/4V/tpf+2sP3//BH/xB/OIv/uJ7v3+/33G/39fX7o5f+7Vfw+/6Xb8LIvI//Xxfjpfj5Xg5Xo6X4+X4Hz8iAl/+8pfxrd/6rVD96kmcrwlA+dVf/VWYGT73uc89fP9zn/scvvCFL7z3+z/7sz+Ln/qpn/pfdXovx8vxcrwcL8fL8XL8Tzz+43/8j/i9v/f3ftXf+ZoAlDreZT8i4mMZkR//8R/Hj/3Yj62vf/3Xfx3f9m3fhj/yPX8QT7cndFEogAjHdIN5YLeJN2/vuM8db5933PcDHgGbjgi+V72fiEBVoSporcPdARWIKs9H+TsIhagiRCCiULmgPwm4OzQAVWA0QVe+bhPBrXe0Jui94YNtg6ogAvAIHOY4jJ/3wzDDcRyG+3HAzHAcB9wMKh193LDdbuhjQxsKqGDbNnzms6/wTd/U8Y2/0/HZz068/izwwQfANzwBt37g1g2jB7QJRAXhANzh0+ARcAFmABF5TeKPzwZAICDSIBAIAIQBgvwq4AAg9SzPv6p7LCJgRlHOX8xXV+Tr1Lcz8yhyHScfx5atP4BorL+V0PxZQBRQBK85AnYE7DDM3bHfDfc3E/dnx/0j4PnDho++FPjyfx340pcmPvzQMO08JQdg7vBwTHfMcMwALByHGwz8nYgARODuMAQgQHhAIWvsOQKB8/qu4/HdzGt93ep6Pc6x2RSqDdobtA+o9hzLAyqKyHtY0YqqwowXdcyDF5bPK8LXe6kq3B3uPN8mks+jXk/WuUsAcxrngOoSt/FaHWa2Xg8ARBXOq4dA4Ij1M84ZzfdoaK1h9JEfDaM3tKYYoth6x8h52pTjx9wRbjDknJoGC+dzEUVrG9A6eu/Q1tGQf1/jlAsE5rHj+fkZb5/fYN93HHPCMKGiaL2jbQPQhrF19NGhWvcaCOUa0VrDq9sHuD29wtP2Ctu2Ydue0HTwmWk+TxW4Bcwm5nHH/vyMN28+xIcf/jo+/PUvYz/e4rjfkRP3YZ0UEWytozfF1hW30XHbBrbW0BR5LwEVwWFc/ywC+5x4nhPP+8Tb5x1v7zv248A0PotpBrNAuAP5HGtOqypaEyACo53bSABwBMwNNg2wWOOpxo6KAiLoXTF6Q28N22gY2tCboreWM1vg4XAEDjNYANMcEQJzIELgAFpr6K2jqaI1hQfvJwIwM9icmD4xzTkfzeA5/i3HXc3JgK81SoP3treOPga20fnRO26jYxsDr169wqvXN7zaNozR0dsG7Q2jdWjTfC3OId6TiX2fmNMwzfMjYMHMgENx2ATQEAJEjuX6uN/v8HnA3dGUc2VsG3o999GwNcHr3vC0bdiaQlQw3XCY4/k4cD8mjmnYp3HtcsF0YFrgsICZwy0QARw2YW65zArcDt6TMaCq3A9EoDnWuircJpoATQJbbxijo2njWhSB+/2O//e/+v/gM5/5zMes54/H1wSgfPM3fzNaa++xJV/84hffY1UA4Ha74Xa7vff9D25PePX0hFyXEBGYNnFMR0hgjIbDNW8kYNNQy34guKoCgAgCsYBLzaRa1EVlfZ9bq6zXgUgOnnMzbgoIYg303hTbIEAZ2tB7gwjBSTgAq3Pg96bl5meGcF8L9XWDbgl+tCnG2HC7bXi6dTxthu0meHoCXr9SvL4Fbl2wtQN9OJryGtwDPvnW7pwgAYCz8rzHdZ+irlyCt6cAQN17529E/q3gPF0RQLSeEQBwkbm8SW7M+bsXoHLeb97f+m49K6kz0yu4FUgkuAR/R+GAA2GBpg5rAm0AZ1UHmgEdkNExN8G+dbwaCu+GQyKfDWAeMOGi2cLRItA8MMMhrgQwEdwkERDRvGeCkBpjBNOSz7vu8xXIXUFL3QhB3ieiGv67NWhr/Ny5kKp0iApUO1prl7FczxDQ1rgg1sJc4zc0zwVomr+TH63AyAU0LsBxPVfU2CYEcTcgOM4i/0ZVHq4NOEGUKsG/QHITb2i9Y4yOMRq2BCpb63jqDV0bVAIigaaNYMQDFo79ODB64HDDzHEuBQocgCLn/jm/EYFww5wT0yY3sLonUN7nznPiPee5tdYgygBARPheImhNF7iDcM62BJVSE0NqXihE+Ux77xhjQx8D7hPeJgQtTzxwud05hgQhihAFpMEvY0lFMAGENM7FIFhuUKgB0h3dAxYCiBGQtobDA26GMM/35fNvuSFFBG69P8xZQ8DMMNuEHwUKPK8fGeCds9uda54GXyPWawnHTgGrAp8Qrh85Tlrr6J3AhoBWc10GQcHoMHOYW4IuPltP4KU1B8LzI8dirj2tKUYnoO2Nz7nl87/dbnh6esJt27BtA2Pc0FtDH4NzDwQZ7raCzd4IUI7JgFTmhEZguqNLA0wzZEOCKYI+BMG/tJbr5LnmhV/m0AqgkXufQJVLe+8dHgJBg4ijC+DRYBGYBhzmmJPA1D0gUzkHInIODI40bRynqhlAdGiCEiigQQB12wjk+GwIUFR8netvdnxNAMq2bfje7/1e/MIv/AL+9J/+0+v7v/ALv4A/9af+1Cd+nd4UW1NoPpSAQxWAGA7n92pxDa9BeH4AyHCHQMIiF3DVhb5FBHBgzslIPMFOADD1NbA1cU2IwEWgGgiRnDyM+oY2tNpoIjJ2zM0rHOZkgPZjnhuDWb5HBgXhiDB4GBqIShVAywhJ1gLPy4vcKCABwvTcJKbD5uTEtYCHYAYA9QUyIIGQ6yYSFzARkIf3iBURI4FGHQQPxW6geIP183oUKieoUM3XyPvqCUbODZ4/0wVsnBtDnWwksAswPncCFLJGjpgKPwJxBGICMIEYgdf6TwDVwIj607yORFqRy0hTgTvQNAFTAApGdy687cBa3otr4uKYv7PO/B1wUv/muBYoctPxWGNVW31wgdbWz43+EuVc2RlVAoW1SCjvqajmZi+LpVHVtYdeGbAILmIFHB051mpM5IP1evQZqbo7WoHOy/VemaPAldnUFShoRsm9aYJ0BgBN8v6LoIXCxCEuQOdCDAMiLN/fOFbNITYJEmqsZtTqZrBjx7Hv2Pcdcx4IOO9PPjtBoKuiZbStQYYr+Vz0vDPNHXCD2wE3hfuAXa85f8+NrMOcxwJGqgQqx3HeJ8QJ0Os1igUQFEMx0Y33p4kwiFtgSDETNJgHWZJa+94ByaGOEEFoIMJyLEqyBQoJR28nm7wYFDPMpjB1HMcBIMjU5hhZ49zI8HAy815pcxSasXB+dgaXZjU+OEe7CkYTsmrJ6rTeUCPW0TKwcMw5sR8
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"image = cv.imread(\"messi5.jpg\")\n",
"# output segmented image with colorbar\n",
"cv.rectangle(image, (x1, y1), (x2, y2), (0, 255, 0), thickness=3, lineType=cv.LINE_AA)\n",
"plt.imshow(image[:,:,::-1])"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "96d757f0",
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(342, 548, 3)"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"image.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bae92c85",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAGOCAYAAADPb5pdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZxlR3nY/3+q6mx377699+wzGgmhkYTQiiy0sEiIL2CQYmGTOEBk/7BZHP1AwQHHiXBsFGMb+BoC3x/+ElazJLEJYDAggpEAIZAGtG+zr70vdz9bVf3+uEPHYzBIdIthNPXmdXjNvfec23V7zqiffuqpp4S11uI4juM4jrMK8kQPwHEcx3Gck58LKBzHcRzHWTUXUDiO4ziOs2ouoHAcx3EcZ9VcQOE4juM4zqq5gMJxHMdxnFVzAYXjOI7jOKvmAgrHcRzHcVbNO9EDcBzHcZyngziOSdN01e8TBAFRFK3BiH6xXEDhOI7jOKsUxzFbNpWZntWrfq/x8XH27dt30gUVLqBwHMdxnFVK05TpWc2+nZuoVn7+aoJmy7Dl/AOkaeoCCsdxHMc5VVUrclUBxcns1PzUjuM4jvMU0Nas+ngybr31Vi688EIqlQqjo6O8/OUv57HHHjvunNe85jUIIY47LrnkkuPOSZKEN73pTQwPD1MqlXjZy17G4cOHn9RYXEDhOI7jOGvEYFd9PBm33347b3jDG7jrrru47bbbyPOcq6++mk6nc9x5L3rRi5iamlo5vvzlLx/3+k033cTnPvc5PvOZz/Dtb3+bdrvNS17yErR+4jUhbsrDcRzHcU5SX/nKV457/JGPfITR0VF27tzJ5ZdfvvJ8GIaMj4//xPdoNBp8+MMf5hOf+AQveMELAPjkJz/Jhg0b+PrXv84111zzhMbiMhSO4ziOs0bMGvwPoNlsHnckSfKEvn6j0QCgXq8f9/w3v/lNRkdHOf300/nt3/5tZmdnV17buXMnWZZx9dVXrzw3OTnJjh07uPPOO5/wZ3cBheM4juOsEW3tqg+ADRs2UKvVVo5bb731Z35tay1vfvObueyyy9ixY8fK89deey1//dd/zTe+8Q3+4i/+grvvvpvnPe95K0HK9PQ0QRAwODh43PuNjY0xPT39hD+7m/JwHMdxnF8yhw4dolqtrjwOw/BnXvPGN76R+++/n29/+9vHPf/KV75y5c87duzgggsuYNOmTXzpS1/iuuuu+2ffz1qLEOIJj9llKBzHcRxnjaxVUWa1Wj3u+FkBxZve9Ca+8IUv8A//8A+sX7/+p547MTHBpk2b2LVrF9BvpJWmKUtLS8edNzs7y9jY2BP+7C6gcBzHcZw1YrDoVRxPdpWHtZY3vvGN/O3f/i3f+MY32LJly8+8ZmFhgUOHDjExMQHA+eefj+/73HbbbSvnTE1N8eCDD3LppZc+4bG4KQ/HcRzHWSM/z9LPf3r9k/GGN7yBT33qU3z+85+nUqms1DzUajUKhQLtdptbbrmF66+/nomJCfbv38/b3/52hoeHecUrXrFy7o033shb3vIWhoaGqNfr3HzzzZx99tkrqz6eCBdQOI7jOM5J6oMf/CAAV1555XHPf+QjH+E1r3kNSikeeOABPv7xj7O8vMzExARXXXUVn/3sZ6lUKivnv+c978HzPG644QZ6vR7Pf/7z+ehHP4pS6gmPRVhrf/5QynEcx3Ecms0mtVqNxx8Zo7KK1tutluH0M2doNBrHFWWeDFyGwnEcx3HWiDl2rOb6k5UrynQcx3EcZ9VchsJxHMdx1siPVmus5vqTlQsoHMdxHGeNaNs/VnP9ycpNeTiO4ziOs2ouQ+E4juM4a+RULsp0AYXjOI7jrBGDQPPE97/4SdefrNyUh+M4juM4q+YyFI7jOI6zRoztH6u5/mTlAgrHcRzHWSN6lVMeq7n2RHMBheM4juOskVM5oHA1FI7jOI7jrJrLUDiO4zjOGjFWYOwqVnms4toTzQUUjuM4jrNG3JSH4ziO4zjOKrgMheM4juOsEY1Er+J3db2GY/lFcwGF4ziO46wRu8oaCnsS11C4KQ/HcRzHcVbNZSgcx3EcZ42cykWZLqBwHMdxnDWirUTbVdRQnMStt92Uh+M4juM4q+YyFI7jOI6zRgwCs4rf1Q0nb4rCBRSO4ziOs0ZcDYXjOI7jOKu2+hqKkzdD4WooHMdxHMdZNZehcBzHcZw10q+hWMXmYG7Kw3Ecx3Ecs8rW2ydzUaab8nAcx3EcZ9VchsJxHMdx1sipXJTpAgrHcRzHWSMGecr2oXBTHo7jOI7jrJrLUDiO4zjOGtFWoFexBflqrj3RXEDhOI7jOGtEr3KVh3ZTHo7jOI7jnMpchsJxHMdx1oixErOKVR7GrfJwHMdxHOdUnvJwAYXjOI7jrBHD6gorzdoN5RfO1VA4juM4jrNqLkPhOI7jOGtk9Y2tTt7f811A4TiO4zhrZPWtt0/egOLkHbnjOI7jOL80XIbCcRzHcdaIQWBYTVGm65TpOI7jOKc8N+VxgnzgAx9gy5YtRFHE+eefz7e+9a0TORzHcRzHcX5OJyyg+OxnP8tNN93EH/zBH/DDH/6Q5z73uVx77bUcPHjwRA3JcRzHcVblR42tVnOcrE7YyN/97ndz44038lu/9VuceeaZvPe972XDhg188IMfPFFDchzHcZxVMVas+jhZnZAaijRN2blzJ//+3//7456/+uqrufPOO3/s/CRJSJJk5bExhsXFRYaGhhDi5P3mO47jOE89ay2tVovJyUmkPHkzAL/sTkhAMT8/j9aasbGx454fGxtjenr6x86/9dZbecc73vGLGp7jOI7zNHTo0CHWr1//lH4Ns8ppi5O5sdUJHfk/zS5Ya39ixuFtb3sbjUZj5XB1Fo7jOM6TValUnvKv8aPdRldznKxOSIZieHgYpdSPZSNmZ2d/LGsBEIYhYRj+oobnOI7jPA39IqbINQK9il4Sq7n2RDshoVAQBJx//vncdtttxz1/2223cemll56IITmO4ziOswonrLHVm9/8Zn7zN3+TCy64gOc85zl86EMf4uDBg/zO7/zOiRqS4ziO46zKaqct3JTHz+GVr3wlCwsL/NEf/RFTU1Ps2LGDL3/5y2zatOlEDclxHMdxVkWzumkLvXZD+YU7oa23X//61/P617/+RA7BcRzHcZw14PbycBzHcZw14qY8HMdxHMdZNbc5mOM4juM4ziq4DIXjOI7jrBGLwKyiKNOexH0oXEDhOI7jOGvETXk4juM4juOsgstQOI7jOM4aWe0W5Cfz9uUuQ+E4juM4a0Qf2210NceTceutt3LhhRdSqVQYHR3l5S9/OY899thx51hrueWWW5icnKRQKHDllVfy0EMPHXdOkiS86U1vYnh4mFKpxMte9jIOHz78pMbiAgrHcRzHWSM/ylCs5ngybr/9dt7whjdw1113cdttt5HnOVdffTWdTmflnHe96128+93v5v3vfz9333034+PjvPCFL6TVaq2cc9NNN/G5z32Oz3zmM3z729+m3W7zkpe8BK2feO9OYa21T2r0vwSazSa1Wu1ED8NxHMc5iTQaDarV6lPy3j/6ufR73/5VwrL/c79P0s74y8s+/3OPdW5ujtHRUW6//XYuv/xyrLVMTk5y00038fu///v9r5EkjI2N8ad/+qe87nWvo9FoMDIywic+8Qle+cpXAnD06FE2bNjAl7/8Za655pon9LVdhsJxHMdx1ohBrvpYjUajAUC9Xgdg3759TE9Pc/XVV6+cE4YhV1xxBXfeeScAO3fuJMuy486ZnJxkx44dK+c8Ea4o03Ecx3HWiLYCvYrCyh9d22w2j3s+DEPCMPyp11prefOb38xll13Gjh07AJiengZgbGzsuHPHxsY4cODAyjlBEDA4OPhj5/zo+ifCZSgcx3Ec55fMhg0bqNVqK8ett976M6954xvfyP3338+nP/3pH3tNiOODHGvtjz33Tz2Rc/4xl6FwHMdxnDWyVstGDx06dFwNxc/KTrzpTW/iC1/4AnfccQfr169feX58fBzoZyEmJiZWnp+dnV3JWoyPj5OmKUtLS8d
2023-01-16 09:35:16 +01:00
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
2023-01-30 13:54:58 +01:00
"data": {
"text/plain": [
"(<matplotlib.image.AxesImage at 0x26ad58cf400>,\n",
" <matplotlib.colorbar.Colorbar at 0x26acc8d3820>,\n",
" None)"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
2023-01-16 09:35:16 +01:00
}
],
"source": [
"import numpy as np\n",
"import cv2 as cv\n",
"from matplotlib import pyplot as plt\n",
2023-01-30 13:54:58 +01:00
"img = cv.imread('messi5.jpg')\n",
"mask = np.zeros(img.shape[:2],np.uint8)\n",
2023-01-16 09:35:16 +01:00
"bgdModel = np.zeros((1,65),np.float64)\n",
"fgdModel = np.zeros((1,65),np.float64)\n",
2023-01-30 13:54:58 +01:00
"rect = (50,50,450,290)\n",
"cv.grabCut(img,mask,rect,bgdModel,fgdModel,5,cv.GC_INIT_WITH_RECT)\n",
"mask2 = np.where((mask==2)|(mask==0),0,1).astype('uint8')\n",
"img = img*mask2[:,:,np.newaxis]\n",
"plt.imshow(img[:,:,::-1]),plt.colorbar(),plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d44e5a24",
"metadata": {},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAGOCAYAAADPb5pdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA9C0lEQVR4nO3df3xV9Z3v+/fKr50Qki0hZO/sEjKpBqsmMm2wQEYFRILpACLeAaXHgbmMV4cfp7nA0CKdY+qxiXKvYHu5pdfWBz9Lw5mpqKciJRxKaCZDB3KkAloKY4TEJkQw7Pww7J3sve4fyD5uASFZK2w2+/Wcx/fxYK/1XSufvYaaD5/vd32/hmmapgAAACyIi3QAAAAg+pFQAAAAy0goAACAZSQUAADAMhIKAABgGQkFAACwjIQCAABYRkIBAAAsS4h0AAAA3AzOnz8vv99v+T5JSUlKTk62IaLri4QCAACLzp8/r7zcwWppDVi+l9vtVkNDQ9QlFSQUAABY5Pf71dIaUEN9rtLT+j+boL0jqLyik/L7/SQUAADEqvS0OEsJRTSLzW8NAMAACJhBy60vKisrdc899ygtLU1ZWVmaMWOGjh07FtZn3rx5MgwjrI0dOzasj8/n0+LFi5WZmanU1FRNnz5dTU1NfYqFhAIAAJsEZVpufVFTU6OFCxdq//79qq6uVm9vr0pKStTV1RXW76GHHlJzc3Oo7dixI+x8WVmZtm/frqqqKtXW1qqzs1NTp05VIHDtc0IY8gAAIErt3Lkz7PP69euVlZWl+vp63X///aHjDodDbrf7svfwer169dVXtXnzZj344IOSpC1btignJ0e7d+/WlClTrikWKhQAANgkaMP/SVJ7e3tY8/l81/TzvV6vJCkjIyPs+N69e5WVlaWRI0fqySefVGtra+hcfX29enp6VFJSEjrm8XhUUFCgurq6a/7uJBQAANgkYJqWmyTl5OTI6XSGWmVl5VV/tmmaWrJkie69914VFBSEjpeWluoXv/iF9uzZo5deekkHDhzQAw88EEpSWlpalJSUpCFDhoTdz+VyqaWl5Zq/O0MeAADcYBobG5Wenh767HA4rnrNokWL9O6776q2tjbs+OzZs0N/Ligo0OjRo5Wbm6u33npLM2fOvOL9TNOUYRjXHDMVCgAAbGLXpMz09PSwdrWEYvHixXrzzTf129/+VsOHD//SvtnZ2crNzdXx48clXVhIy+/3q62tLaxfa2urXC7XNX93EgoAAGwSlKmAhdbXtzxM09SiRYv02muvac+ePcrLy7vqNWfPnlVjY6Oys7MlSUVFRUpMTFR1dXWoT3Nzs44cOaLi4uJrjoUhDwAAbNKfVz+/eH1fLFy4UFu3btUbb7yhtLS00JwHp9OplJQUdXZ2qry8XI8++qiys7P14Ycf6plnnlFmZqYeeeSRUN/58+dr6dKlGjp0qDIyMrRs2TIVFhaG3vq4FiQUAABEqXXr1kmSJkyYEHZ8/fr1mjdvnuLj43X48GFt2rRJ586dU3Z2tiZOnKht27YpLS0t1H/NmjVKSEjQrFmz1N3drUmTJmnDhg2Kj4+/5lgM0zT7n0oBAAC1t7fL6XTqT++7lGZh6e2OjqBG3nFaXq83bFJmNKBCAQCATYKfNSvXRysmZQIAAMuoUAAAYJOLb2tYuT5akVAAAGCTgHmhWbk+WjHkAQAALKNCAQCATWJ5UiYJBQAANgnKUEDXvv/F5a6PVgx5AAAAy6hQAABgk6B5oVm5PlqRUAAAYJOAxSEPK9dGGgkFAAA2ieWEgjkUAADAMioUAADYJGgaCpoW3vKwcG2kkVAAAGAThjwAAAAsoEIBAIBNAopTwMK/1QM2xnK9kVAAAGAT0+IcCjOK51Aw5AEAACyjQgEAgE1ieVImCQUAADYJmHEKmBbmUETx0tsMeQAAAMuoUAAAYJOgDAUt/Fs9qOgtUZBQAABgE+ZQAAAAy6zPoYjeCgVzKAAAgGVUKAAAsMmFORQWNgdjyAMAAAQtLr0dzZMyGfIAAACWUaEAAMAmsTwpk4QCAACbBBUXs+tQMOQBAAAso0IBAIBNAqahgIUtyK1cG2kkFAAA2CRg8S2PAEMeAAAgllGhAADAJkEzTkELb3kEecsDAADE8pAHCQUAADYJytrEyqB9oVx3zKEAAACWUaEAAMAm1he2it5/55NQAABgE+tLb0dvQhG9kQMAgBsGFQoAAGwSlKGgrEzKZKVMAABiHkMeEfKTn/xEeXl5Sk5OVlFRkX73u99FMhwAANBPEUsotm3bprKyMq1cuVLvvPOO7rvvPpWWlurUqVORCgkAAEsuLmxlpUWriEW+evVqzZ8/X3//93+vO+64Qy+//LJycnK0bt26SIUEAIAlQdOw3KJVROZQ+P1+1dfX63vf+17Y8ZKSEtXV1V3S3+fzyefzhT4Hg0F98sknGjp0qAwjeh8+AGDgmaapjo4OeTwexcVFbwXgRheRhOLMmTMKBAJyuVxhx10ul1paWi7pX1lZqR/84AfXKzwAwE2osbFRw4cPH9CfEbQ4bBHNC1tFNPIvVhdM07xsxWHFihXyer2hxjwLAEBfpaWlDfjPuLjbqJUWrSJSocjMzFR8fPwl1YjW1tZLqhaS5HA45HA4rld4AICb0PUYIg/IUMDCWhJWro20iKRCSUlJKioqUnV1ddjx6upqFRcXRyIkAABgQcQWtlqyZImeeOIJjR49WuPGjdMrr7yiU6dO6emnn45USAAAWGJ12IIhj36YPXu2zp49q+eee07Nzc0qKCjQjh07lJubG6mQAACwJCBrwxYB+0K57iK69PaCBQu0YMGCSIYAAABswF4eAADYhCEPAABgGZuDAQAAWECFAgAAm5gyFLQwKdOM4nUoSCgAALAJQx4AAAAWUKEAAMAmVrcgj+bty6lQAABgk8Bnu41aaX1RWVmpe+65R2lpacrKytKMGTN07NixsD6maaq8vFwej0cpKSmaMGGCjh49GtbH5/Np8eLFyszMVGpqqqZPn66mpqY+xUJCAQCATS5WKKy0vqipqdHChQu1f/9+VVdXq7e3VyUlJerq6gr1WbVqlVavXq21a9fqwIEDcrvdmjx5sjo6OkJ9ysrKtH37dlVVVam2tladnZ2aOnWqAoFrX7vTME3T7FP0N4D29nY5nc5IhwEAiCJer1fp6ekDcu+Lv5f+c+3DcgxO7Pd9fJ09+vG9b/Q71o8//lhZWVmqqanR/fffL9M05fF4VFZWpu9+97sXfobPJ5fLpRdffFFPPfWUvF6vhg0bps2bN2v27NmSpD//+c/KycnRjh07NGXKlGv62VQoAACwSVBxlpsVXq9XkpSRkSFJamhoUEtLi0pKSkJ9HA6Hxo8fr7q6OklSfX29enp6wvp4PB4VFBSE+lwLJmUCAGCTgGkoYGFi5cVr29vbw447HA45HI4vvdY0TS1ZskT33nuvCgoKJEktLS2SJJfLFdbX5XLp5MmToT5JSUkaMmTIJX0uXn8tqFAAAHCDycnJkdPpDLXKysqrXrNo0SK9++67+uUvf3nJOcMIT3JM07zk2BddS5/Po0IBAIBN7HpttLGxMWwOxdWqE4sXL9abb76pffv2afjw4aHjbrdb0oUqRHZ2duh4a2trqGrhdrvl9/vV1tYWVqVobW1VcXHxNcdOhQIAAJuYn+022t9mfrZSZnp6eli7UkJhmqYWLVqk1157TXv27FFeXl7Y+by8PLndblVXV4eO+f1+1dTUhJKFoqIiJSYmhvVpbm7WkSNH+pRQUKEAACBKLVy4UFu3btUbb7yhtLS00JwHp9OplJQUGYahsrIyVVRUKD8/X/n5+aqoqNCgQYM0Z86cUN/58+dr6dKlGjp0qDIyMrRs2TIVFhbqwQcfvOZYSCgAALBJQIYCFjb46uu169atkyRNmDAh7Pj69es1b948SdLy5cvV3d2tBQsWqK2tTWPGjNGuXbuUlpYW6r9mzRolJCRo1qxZ6u7u1qRJk7RhwwbFx8dfcyysQwEAiAnXYx2Kv9s7S0mDk/p9H3+nX+sn/LcBjXWgMIcCAABYxpAHAAA2uTi50sr
"text/plain": [
"<Figure size 640x480 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"(<matplotlib.image.AxesImage at 0x26ad560f400>,\n",
" <matplotlib.colorbar.Colorbar at 0x26ad560a820>,\n",
" None)"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# newmask is the mask image I manually labelled\n",
"newmask = cv.imread('messi5_mask.png',0)\n",
"# wherever it is marked white (sure foreground), change mask=1\n",
"# wherever it is marked black (sure background), change mask=0\n",
"mask[newmask == 0] = 0\n",
"mask[newmask == 255] = 1\n",
"mask, bgdModel, fgdModel = cv.grabCut(img,mask,None,bgdModel,fgdModel,5,cv.GC_INIT_WITH_MASK)\n",
"mask = np.where((mask==2)|(mask==0),0,1).astype('uint8')\n",
"img = img*mask[:,:,np.newaxis]\n",
"plt.imshow(img),plt.colorbar(),plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e4e74c0d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e234eb0",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"===============================================================================\n",
"Interactive Image Segmentation using GrabCut algorithm.\n",
"This sample shows interactive image segmentation using grabcut algorithm.\n",
"USAGE:\n",
" python grabcut.py <filename>\n",
"README FIRST:\n",
" Two windows will show up, one for input and one for output.\n",
" At first, in input window, draw a rectangle around the object using the\n",
"right mouse button. Then press 'n' to segment the object (once or a few times)\n",
"For any finer touch-ups, you can press any of the keys below and draw lines on\n",
"the areas you want. Then again press 'n' to update the output.\n",
"Key '0' - To select areas of sure background\n",
"Key '1' - To select areas of sure foreground\n",
"Key '2' - To select areas of probable background\n",
"Key '3' - To select areas of probable foreground\n",
"Key 'n' - To update the segmentation\n",
"Key 'r' - To reset the setup\n",
"Key 's' - To save the results\n",
"===============================================================================\n",
"\n",
"No input image given, so loading default image, lena.jpg \n",
"\n",
"Correct Usage: python grabcut.py <filename> \n",
"\n"
]
},
{
"ename": "error",
"evalue": "OpenCV(4.5.5) D:\\a\\opencv-python\\opencv-python\\opencv\\modules\\core\\src\\utils\\samples.cpp:64: error: (-2:Unspecified error) OpenCV samples: Can't find required data file: messi5.jpg in function 'cv::samples::findFile'\n",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31merror\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_22952\\674526088.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m 170\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0m__name__\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m'__main__'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 171\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0m__doc__\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 172\u001b[1;33m \u001b[0mApp\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 173\u001b[0m \u001b[0mcv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mdestroyAllWindows\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;32m~\\AppData\\Local\\Temp\\ipykernel_22952\\674526088.py\u001b[0m in \u001b[0;36mrun\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 98\u001b[0m \u001b[0mfilename\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'messi5.jpg'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 99\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 100\u001b[1;33m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mcv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mcv\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msamples\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfindFile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfilename\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 101\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcopy\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# a copy of original image\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 102\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmask\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimg\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0muint8\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# mask initialized to PR_BG\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31merror\u001b[0m: OpenCV(4.5.5) D:\\a\\opencv-python\\opencv-python\\opencv\\modules\\core\\src\\utils\\samples.cpp:64: error: (-2:Unspecified error) OpenCV samples: Can't find required data file: messi5.jpg in function 'cv::samples::findFile'\n"
]
}
],
"source": [
"#!/usr/bin/env python\n",
"'''\n",
"===============================================================================\n",
"Interactive Image Segmentation using GrabCut algorithm.\n",
"This sample shows interactive image segmentation using grabcut algorithm.\n",
"USAGE:\n",
" python grabcut.py <filename>\n",
"README FIRST:\n",
" Two windows will show up, one for input and one for output.\n",
" At first, in input window, draw a rectangle around the object using the\n",
"right mouse button. Then press 'n' to segment the object (once or a few times)\n",
"For any finer touch-ups, you can press any of the keys below and draw lines on\n",
"the areas you want. Then again press 'n' to update the output.\n",
"Key '0' - To select areas of sure background\n",
"Key '1' - To select areas of sure foreground\n",
"Key '2' - To select areas of probable background\n",
"Key '3' - To select areas of probable foreground\n",
"Key 'n' - To update the segmentation\n",
"Key 'r' - To reset the setup\n",
"Key 's' - To save the results\n",
"===============================================================================\n",
"'''\n",
2023-01-16 09:35:16 +01:00
"\n",
"\n",
2023-01-30 13:54:58 +01:00
"import numpy as np\n",
"import cv2 as cv\n",
2023-01-16 09:35:16 +01:00
"\n",
2023-01-30 13:54:58 +01:00
"import sys\n",
"\n",
"class App():\n",
" BLUE = [255,0,0] # rectangle color\n",
" RED = [0,0,255] # PR BG\n",
" GREEN = [0,255,0] # PR FG\n",
" BLACK = [0,0,0] # sure BG\n",
" WHITE = [255,255,255] # sure FG\n",
"\n",
" DRAW_BG = {'color' : BLACK, 'val' : 0}\n",
" DRAW_FG = {'color' : WHITE, 'val' : 1}\n",
" DRAW_PR_BG = {'color' : RED, 'val' : 2}\n",
" DRAW_PR_FG = {'color' : GREEN, 'val' : 3}\n",
"\n",
" # setting up flags\n",
" rect = (0,0,1,1)\n",
" drawing = False # flag for drawing curves\n",
" rectangle = False # flag for drawing rect\n",
" rect_over = False # flag to check if rect drawn\n",
" rect_or_mask = 100 # flag for selecting rect or mask mode\n",
" value = DRAW_FG # drawing initialized to FG\n",
" thickness = 3 # brush thickness\n",
"\n",
" def onmouse(self, event, x, y, flags, param):\n",
" # Draw Rectangle\n",
" if event == cv.EVENT_RBUTTONDOWN:\n",
" self.rectangle = True\n",
" self.ix, self.iy = x,y\n",
"\n",
" elif event == cv.EVENT_MOUSEMOVE:\n",
" if self.rectangle == True:\n",
" self.img = self.img2.copy()\n",
" cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2)\n",
" self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y))\n",
" self.rect_or_mask = 0\n",
"\n",
" elif event == cv.EVENT_RBUTTONUP:\n",
" self.rectangle = False\n",
" self.rect_over = True\n",
" cv.rectangle(self.img, (self.ix, self.iy), (x, y), self.BLUE, 2)\n",
" self.rect = (min(self.ix, x), min(self.iy, y), abs(self.ix - x), abs(self.iy - y))\n",
" self.rect_or_mask = 0\n",
" print(\" Now press the key 'n' a few times until no further change \\n\")\n",
"\n",
" # draw touchup curves\n",
2023-01-16 09:35:16 +01:00
"\n",
" if event == cv.EVENT_LBUTTONDOWN:\n",
2023-01-30 13:54:58 +01:00
" if self.rect_over == False:\n",
" print(\"first draw rectangle \\n\")\n",
" else:\n",
" self.drawing = True\n",
" cv.circle(self.img, (x,y), self.thickness, self.value['color'], -1)\n",
" cv.circle(self.mask, (x,y), self.thickness, self.value['val'], -1)\n",
"\n",
" elif event == cv.EVENT_MOUSEMOVE:\n",
" if self.drawing == True:\n",
" cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1)\n",
" cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1)\n",
"\n",
" elif event == cv.EVENT_LBUTTONUP:\n",
" if self.drawing == True:\n",
" self.drawing = False\n",
" cv.circle(self.img, (x, y), self.thickness, self.value['color'], -1)\n",
" cv.circle(self.mask, (x, y), self.thickness, self.value['val'], -1)\n",
"\n",
" def run(self):\n",
" # Loading images\n",
"\n",
" print(\"No input image given, so loading default image, lena.jpg \\n\")\n",
" print(\"Correct Usage: python grabcut.py <filename> \\n\")\n",
" filename = 'messi5.jpg'\n",
"\n",
" self.img = cv.imread(cv.samples.findFile(filename))\n",
" self.img2 = self.img.copy() # a copy of original image\n",
" self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG\n",
" self.output = np.zeros(self.img.shape, np.uint8) # output image to be shown\n",
"\n",
" # input and output windows\n",
" cv.namedWindow('output')\n",
" cv.namedWindow('input')\n",
" cv.setMouseCallback('input', self.onmouse)\n",
" cv.moveWindow('input', self.img.shape[1]+10,90)\n",
"\n",
" print(\" Instructions: \\n\")\n",
" print(\" Draw a rectangle around the object using right mouse button \\n\")\n",
"\n",
" while(1):\n",
"\n",
" cv.imshow('output', self.output)\n",
" cv.imshow('input', self.img)\n",
" k = cv.waitKey(1)\n",
"\n",
" # key bindings\n",
" if k == 27: # esc to exit\n",
" break\n",
" elif k == ord('0'): # BG drawing\n",
" print(\" mark background regions with left mouse button \\n\")\n",
" self.value = self.DRAW_BG\n",
" elif k == ord('1'): # FG drawing\n",
" print(\" mark foreground regions with left mouse button \\n\")\n",
" self.value = self.DRAW_FG\n",
" elif k == ord('2'): # PR_BG drawing\n",
" self.value = self.DRAW_PR_BG\n",
" elif k == ord('3'): # PR_FG drawing\n",
" self.value = self.DRAW_PR_FG\n",
" elif k == ord('s'): # save image\n",
" bar = np.zeros((self.img.shape[0], 5, 3), np.uint8)\n",
" res = np.hstack((self.img2, bar, self.img, bar, self.output))\n",
" cv.imwrite('grabcut_output.png', res)\n",
" print(\" Result saved as image \\n\")\n",
" elif k == ord('r'): # reset everything\n",
" print(\"resetting \\n\")\n",
" self.rect = (0,0,1,1)\n",
" self.drawing = False\n",
" self.rectangle = False\n",
" self.rect_or_mask = 100\n",
" self.rect_over = False\n",
" self.value = self.DRAW_FG\n",
" self.img = self.img2.copy()\n",
" self.mask = np.zeros(self.img.shape[:2], dtype = np.uint8) # mask initialized to PR_BG\n",
" self.output = np.zeros(self.img.shape, np.uint8) # output image to be shown\n",
" elif k == ord('n'): # segment the image\n",
" print(\"\"\" For finer touchups, mark foreground and background after pressing keys 0-3\n",
" and again press 'n' \\n\"\"\")\n",
" try:\n",
" bgdmodel = np.zeros((1, 65), np.float64)\n",
" fgdmodel = np.zeros((1, 65), np.float64)\n",
" if (self.rect_or_mask == 0): # grabcut with rect\n",
" cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_RECT)\n",
" self.rect_or_mask = 1\n",
" elif (self.rect_or_mask == 1): # grabcut with mask\n",
" cv.grabCut(self.img2, self.mask, self.rect, bgdmodel, fgdmodel, 1, cv.GC_INIT_WITH_MASK)\n",
" except:\n",
" import traceback\n",
" traceback.print_exc()\n",
"\n",
" mask2 = np.where((self.mask==1) + (self.mask==3), 255, 0).astype('uint8')\n",
" self.output = cv.bitwise_and(self.img2, self.img2, mask=mask2)\n",
"\n",
" print('Done')\n",
"\n",
"\n",
"if __name__ == '__main__':\n",
" print(__doc__)\n",
" App().run()\n",
" cv.destroyAllWindows()"
2023-01-16 09:35:16 +01:00
]
2023-01-30 13:54:58 +01:00
},
{
"cell_type": "code",
"execution_count": null,
"id": "694f4ea2",
"metadata": {},
"outputs": [],
"source": []
2023-01-16 09:35:16 +01:00
}
],
"metadata": {
"kernelspec": {
"display_name": "widzenie_komputerowe",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
2023-01-30 13:54:58 +01:00
"version": "3.7.12"
2023-01-16 09:35:16 +01:00
},
"vscode": {
"interpreter": {
"hash": "6ac7fc53e11b5e853f03d2492fedb08fce658edca143f79fa3d2748d3b63b777"
}
2023-01-30 13:54:58 +01:00
}
2023-01-16 09:35:16 +01:00
},
"nbformat": 4,
"nbformat_minor": 5
}
