From 206bfcf2db45906c8ac2077b738a43c8fca9f494 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Thu, 11 Sep 2025 14:53:33 +0200 Subject: [PATCH] SCRIPTS - added script to look at images offline to improve setttings for alc --- scripts/alc_bkg_comp.ipynb | 804 +++++++++++++++++++++++++++++++++++++ 1 file changed, 804 insertions(+) create mode 100644 scripts/alc_bkg_comp.ipynb diff --git a/scripts/alc_bkg_comp.ipynb b/scripts/alc_bkg_comp.ipynb new file mode 100644 index 00000000..e8ce5627 --- /dev/null +++ b/scripts/alc_bkg_comp.ipynb @@ -0,0 +1,804 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2025-09-09T06:54:20.171830792Z", + "start_time": "2025-09-03T09:37:36.977231Z" + } + }, + "source": [ + "import cv2\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns" + ], + "outputs": [], + "execution_count": 47 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-03T09:20:49.172543Z", + "start_time": "2025-09-03T09:20:49.169238Z" + } + }, + "cell_type": "code", + "source": "threshold = 5", + "id": "19360e6dda22efb5", + "outputs": [], + "execution_count": 30 + }, + { + "metadata": { + "jupyter": { + "is_executing": true + } + }, + "cell_type": "code", + "source": [ + "bkg = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/bkg1_50_50.jpg\")\n", + "curr_img = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/1002_0_1_50_50_curr_image.tiff\")" + ], + "id": "9fac6cc561e58b70", + "outputs": [], + "execution_count": null + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-05T11:27:26.501898Z", + "start_time": "2025-09-05T11:27:26.496995Z" + } + }, + "cell_type": "code", + "source": [ + "def flatfield_correction(raw_image, flat_image, dark_image=None):\n", + " \"\"\"\n", + " Apply flat-field correction to remove uneven illumination\n", + "\n", + " Args:\n", + " raw_image: Your actual image with crystal\n", + " flat_image: Image of uniform illumination (no sample)\n", + " dark_image: Dark frame (camera with no light), optional\n", + " \"\"\"\n", + " # Convert to float for calculations\n", + " raw = raw_image.astype(np.float32)\n", + " flat = flat_image.astype(np.float32)\n", + "\n", + " if dark_image is not None:\n", + " dark = dark_image.astype(np.float32)\n", + " # Subtract dark frame from both\n", + " raw_corrected = raw - dark\n", + " flat_corrected = flat - dark\n", + " else:\n", + " raw_corrected = raw\n", + " flat_corrected = flat\n", + "\n", + " # Avoid division by zero\n", + " flat_corrected[flat_corrected == 0] = 1\n", + "\n", + " # Apply correction\n", + " mean_flat = np.mean(flat_corrected)\n", + " corrected = (raw_corrected / flat_corrected) * mean_flat\n", + "\n", + " # Convert back to original dtype\n", + " return np.clip(corrected, 0, 255).astype(raw_image.dtype)" + ], + "id": "114345da7d31b16d", + "outputs": [], + "execution_count": 139 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-05T11:43:24.969687Z", + "start_time": "2025-09-05T11:43:24.954049Z" + } + }, + "cell_type": "code", + "source": [ + "def create_ring_mask(image, center=None, inner_radius=50, outer_radius=100):\n", + " \"\"\"\n", + " Create a mask to exclude a ring region\n", + "\n", + " Args:\n", + " image_shape: (height, width) of your image\n", + " center: (cx, cy) center of ring, None for image center\n", + " inner_radius: Inner radius of ring to mask out\n", + " outer_radius: Outer radius of ring to mask out\n", + "\n", + " Returns:\n", + " mask: Binary mask (0 = exclude ring, 255 = use for correction)\n", + " \"\"\"\n", + "\n", + " if len(image.shape) == 3:\n", + " h, w, _ = image.shape\n", + " else:\n", + " h, w = image.shape\n", + "\n", + "\n", + " if center is None:\n", + " center = (w // 2, h // 2)\n", + "\n", + " # Create coordinate arrays\n", + " cx, cy = center\n", + "\n", + " w = int(w)\n", + " h = int(h)\n", + "\n", + "\n", + " x = np.arange(w)\n", + " y = np.arange(h)\n", + " X, Y = np.meshgrid(x, y)\n", + "\n", + " # Calculate distances from center\n", + " distances = np.sqrt((X - cx)**2 + (Y - cy)**2)\n", + "\n", + "\n", + " # Create mask: exclude the ring region\n", + " mask = np.ones((h, w), dtype=np.uint8) * 255\n", + " ring_region = (distances >= inner_radius) & (distances <= outer_radius)\n", + " mask[ring_region] = 0\n", + "\n", + " return mask\n", + "\n", + "def flatfield_correction_with_mask(raw_image, flat_image, mask, dark_image=None):\n", + " \"\"\"\n", + " Apply flat-field correction with mask to exclude certain regions\n", + "\n", + " Args:\n", + " raw_image: Your camera image\n", + " flat_image: Flat-field reference\n", + " mask: Binary mask (0 = ignore, 255 = use)\n", + " dark_image: Dark frame (optional)\n", + " \"\"\"\n", + " # Convert to float\n", + " raw = raw_image.astype(np.float32)\n", + " flat = flat_image.astype(np.float32)\n", + "\n", + " if dark_image is not None:\n", + " dark = dark_image.astype(np.float32)\n", + " raw_corrected = raw - dark\n", + " flat_corrected = flat - dark\n", + " else:\n", + " raw_corrected = raw\n", + " flat_corrected = flat\n", + "\n", + " # Apply mask to flat field - only use unmasked regions for correction\n", + " mask_float = mask.astype(np.float32) / 255.0\n", + "\n", + " # Calculate mean only from unmasked regions\n", + " if len(flat_corrected.shape) == 3:\n", + " # Color image\n", + " mean_flat = []\n", + " for channel in range(flat_corrected.shape[2]):\n", + " masked_flat = flat_corrected[:,:,channel] * mask_float\n", + " valid_pixels = masked_flat[mask > 0]\n", + " mean_flat.append(np.mean(valid_pixels) if len(valid_pixels) > 0 else 1.0)\n", + " mean_flat = np.array(mean_flat).reshape(1, 1, -1)\n", + " else:\n", + " # Grayscale\n", + " masked_flat = flat_corrected * mask_float\n", + " valid_pixels = masked_flat[mask > 0]\n", + " mean_flat = np.mean(valid_pixels) if len(valid_pixels) > 0 else 1.0\n", + "\n", + " # Avoid division by zero\n", + " flat_corrected[flat_corrected <= 0] = 1\n", + "\n", + " # Apply correction\n", + " corrected = (raw_corrected / flat_corrected) * mean_flat\n", + "\n", + " # In masked regions, keep original values\n", + " mask_3d = mask_float\n", + " if len(corrected.shape) == 3:\n", + " mask_3d = np.stack([mask_float] * corrected.shape[2], axis=2)\n", + "\n", + " # Blend: use corrected where mask=1, original where mask=0\n", + " final_result = corrected * mask_3d + raw_corrected * (1 - mask_3d)\n", + "\n", + " return np.clip(final_result, 0, 255).astype(np.uint8)\n", + "\n", + "def create_interactive_ring_mask(image):\n", + " \"\"\"\n", + " Interactively create a ring mask by clicking on the image\n", + " Click center, then inner radius point, then outer radius point\n", + " \"\"\"\n", + " points = []\n", + "\n", + " def mouse_callback(event, x, y, flags, param):\n", + " if event == cv2.EVENT_LBUTTONDOWN:\n", + " points.append((x, y))\n", + " cv2.circle(image, (x, y), 3, (0, 255, 0), -1)\n", + " cv2.imshow('Select Ring', image)\n", + "\n", + " if len(points) == 1:\n", + " print(\"Click on inner radius of ring\")\n", + " elif len(points) == 2:\n", + " print(\"Click on outer radius of ring\")\n", + "\n", + " cv2.imshow('Select Ring', image)\n", + " print(\"Click on center of ring\")\n", + " cv2.setMouseCallback('Select Ring', mouse_callback)\n", + " cv2.waitKey(0)\n", + " cv2.destroyAllWindows()\n", + "\n", + " if len(points) == 3:\n", + " center = points[0]\n", + " inner_radius = np.sqrt((points[1][0] - center[0])**2 + (points[1][1] - center[1])**2)\n", + " outer_radius = np.sqrt((points[2][0] - center[0])**2 + (points[2][1] - center[1])**2)\n", + "\n", + " mask = create_ring_mask(image.shape, center, inner_radius, outer_radius)\n", + " return mask\n", + " else:\n", + " print(\"Need 3 points!\")\n", + " return None\n" + ], + "id": "a1ae8c16d1cb31f7", + "outputs": [], + "execution_count": 154 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-08T14:23:06.438502Z", + "start_time": "2025-09-08T14:23:02.773985Z" + } + }, + "cell_type": "code", + "source": [ + "min_contour_area = 4\n", + "mask = create_ring_mask(curr_img, inner_radius=1000,outer_radius=2000)\n", + "diff_image = cv2.absdiff(curr_img, bkg)\n", + "diff_image = cv2.cvtColor(diff_image, cv2.COLOR_RGB2GRAY)\n", + "thresh_value, binary_image = cv2.threshold(diff_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n", + "thresh_value, thresh_normal = cv2.threshold(diff_image, 50, 255, cv2.THRESH_BINARY)\n", + "ff = flatfield_correction(curr_img, bkg, dark_image=None)\n", + "ff = cv2.cvtColor(ff, cv2.COLOR_RGB2GRAY)\n", + "ff_masked = flatfield_correction_with_mask(curr_img, bkg, mask, dark_image=None)\n", + "ff_masked = cv2.cvtColor(ff_masked, cv2.COLOR_RGB2GRAY)\n", + "thresh_value, thresh_mask = cv2.threshold(ff_masked, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)\n", + "kernel = np.ones((3,3), np.uint8)\n", + "thresh = cv2.morphologyEx(thresh, cv2.MORPH_CLOSE, kernel)\n", + "thresh = cv2.morphologyEx(thresh, cv2.MORPH_OPEN, kernel)\n", + "\n", + "contours, _ = cv2.findContours(thresh_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + "valid_contours = [cnt for cnt in contours if cv2.contourArea(cnt) > min_contour_area]\n", + "\n", + "largest_contour = max(valid_contours, key=cv2.contourArea)\n", + "\n", + "# Step 6: Find leftmost point\n", + "leftmost_point = tuple(largest_contour[largest_contour[:,:,0].argmin()][0])\n", + "print(leftmost_point)\n", + "\n", + "leftmost_point = None\n", + "\n", + "for contour in contours:\n", + " # Loop through each point in the current contour\n", + " for point in contour:\n", + " x, y = point[0] # Point is a nested array [ [x, y] ]\n", + "\n", + " # Check if this is the leftmost point\n", + " if leftmost_point is None or x < leftmost_point[0]:\n", + " leftmost_point = (x, y)\n", + " plot_contour = contour\n", + "print(leftmost_point)\n", + "\n", + "c_img = cv2.drawContours(thresh, contours, -1, (0, 255, 0), 1)\n", + "plt.subplot(2, 2, 1)\n", + "plt.imshow(diff_image)\n", + "plt.subplot(2, 2, 2)\n", + "plt.imshow(thresh_normal)\n", + "#plt.subplot(2, 2, 4)\n", + "#plt.imshow(ff_masked)\n", + "\n", + "\n", + "result_image = cv2.cvtColor(thresh, cv2.COLOR_GRAY2BGR) if len(thresh.shape) == 2 else thresh.copy()\n", + "\n", + "# Draw contour\n", + "result_image = cv2.drawContours(result_image, [largest_contour], -1, (0, 255, 0), 2)\n", + "\n", + "# Mark leftmost point\n", + "result_image = cv2.circle(result_image, leftmost_point, 100, (0, 0, 255), -1)\n", + "result_image = cv2.putText(result_image, f'Leftmost: {leftmost_point}',\n", + " (leftmost_point[0] + 10, leftmost_point[1] - 10),\n", + " cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 2)\n", + "\n", + "print(f'Leftmost point: {leftmost_point}')\n", + "\n", + "plt.subplot(2, 2, 3)\n", + "plt.imshow(binary_image)\n" + ], + "id": "a5363e8d3c71448", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(np.int32(24), np.int32(979))\n", + "(np.int32(24), np.int32(979))\n", + "Leftmost point: (np.int32(24), np.int32(979))\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 354, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 354 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-08T14:02:01.581369Z", + "start_time": "2025-09-08T14:01:56.983788Z" + } + }, + "cell_type": "code", + "source": [ + "# Load image and convert\n", + "img = cv2.imread('/home/leonarski_f/aaredaq/daq/src/aaredaq/991_0_1_50_50_curr_image.tiff', cv2.IMREAD_COLOR)\n", + "#img = cv2.imread('/home/leonarski_f/aaredaq/daq/src/aaredaq/0_280_100_50_curr_image_colour.jpg', cv2.IMREAD_COLOR)\n", + "\n", + "bkg = cv2.imread('/home/leonarski_f/aaredaq/daq/src/aaredaq/bkg1_50_50.jpg')\n", + "# Convert to grayscale & enhance\n", + "gray_bkg = cv2.cvtColor(bkg, cv2.COLOR_BGR2GRAY)\n", + "gray = cv2.subtract(gray, gray_bkg)\n", + "gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n", + "gray = cv2.GaussianBlur(gray, (5, 5), 0)\n", + "gray = cv2.equalizeHist(gray)\n", + "\n", + "# Mask out camera-case ring\n", + "#gray = cv2.subtract(gray, gray_bkg)\n", + "mask = np.zeros_like(gray, dtype=np.uint8)\n", + "h, w = gray.shape\n", + "radius = min(h, w)//2 - 20\n", + "center = (w//2, h//2)\n", + "\n", + "norm=gray\n", + "print(radius)\n", + "\n", + "#norm = flatfield_correction_with_mask(gray, gray_bkg, mask)\n", + "\n", + "#radius = 500#radius#-factor\n", + "print(gray.shape)\n", + "# # gray = cv2.bitwise_and(gray, gray, mask=mask)\n", + "# # x, y = center[0] - radius, center[1] - radius\n", + "# gray_cropped = gray[y:y+2*radius, x:x+2*radius]\n", + "# #gray_bkg_cropped = gray[y:y+2*radius, x:x+2*radius]\n", + "# #cv2.circle(mask, center, radius, 93, -1)\n", + "# print(gray_cropped.shape)\n", + "#\n", + "# #masked = cv2.bitwise_and(gray, gray, mask=mask)\n", + "# #norm = gray_cropped\n", + "# masked=gray_cropped\n", + "# background= cv2.medianBlur(masked, 51)\n", + "#\n", + "# norm = cv2.subtract(masked, background)\n", + "#norm = cv2.absdiff(masked,gray_bkg)\n", + "kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (25,25))\n", + "tophat = cv2.morphologyEx(norm, cv2.MORPH_TOPHAT, kernel)\n", + "\n", + "enhanced = cv2.addWeighted(norm, 0.7, tophat, 0.3, 0)\n", + "# Adaptive thresholding\n", + "thresh = cv2.adaptiveThreshold(enhanced, 255, cv2.ADAPTIVE_THRESH_MEAN_C,\n", + " cv2.THRESH_BINARY_INV, 41, 2)\n", + "\n", + "# Find contours\n", + "contours, _ = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)\n", + "\n", + "best_point = None\n", + "min_x = w + 1\n", + "\n", + "print(len(contours))\n", + "for cnt in contours:\n", + " x,y,wc,hc = cv2.boundingRect(cnt)\n", + "\n", + " # Skip very large contours (likely mask boundary)\n", + " if cv2.contourArea(cnt) > 0.2 * h * w:\n", + " print(\"Skipping contour with area\", cv2.contourArea(cnt))\n", + " continue\n", + "\n", + " # Compute distance of contour centroid from image center\n", + " M = cv2.moments(cnt)\n", + " if M[\"m00\"] != 0:\n", + " cx = int(M[\"m10\"]/M[\"m00\"])\n", + " cy = int(M[\"m01\"]/M[\"m00\"])\n", + " dist = np.sqrt((cx-center[0])**2 + (cy-center[1])**2)\n", + " # If centroid is near mask radius, skip (mask edge)\n", + " #if abs(dist - radius) < 60:\n", + " # print(\"Skipping contour near mask radius\")\n", + " # continue\n", + "\n", + " # Skip vertical pin\n", + " if hc > 3*wc:\n", + " print(\"Skipping vertical pin\")\n", + " continue\n", + "\n", + " leftmost = tuple(cnt[cnt[:, :, 0].argmin()][0])\n", + " if leftmost[0] < min_x:\n", + " min_x = leftmost[0]\n", + " best_point = leftmost\n", + "\n", + "# Draw result\n", + "if best_point is not None:\n", + " print(f\"best_point = {best_point}\")\n", + " #cv2.circle(thresh, best_point, 100, (0, 0, 255), -1)\n", + " print(radius)\n", + " corrected_point = (best_point[0]+factor, best_point[1] +factor)\n", + " print(f\"corrected_point {corrected_point}\")\n", + " cv2.circle(img, corrected_point, 100, (0, 0, 255), -1)\n", + " print(\"Loop tip (leftmost point):\", best_point)\n", + "else:\n", + " print(\"No suitable contour found\")\n", + "\n", + "plt.figure(figsize=(10,8))\n", + "plt.figure(figsize=(14,10))\n", + "plt.subplot(2,4,1); plt.title(\"Original\"); plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))#; plt.axis(\"off\")\n", + "plt.subplot(2,4,2); plt.title(\"Cropped\"); plt.imshow(gray_cropped, cmap=\"gray\"); plt.axis(\"off\")\n", + "plt.subplot(2,4,3); plt.title(\"Background\"); plt.imshow(norm, cmap=\"gray\"); plt.axis(\"off\")\n", + "plt.subplot(2,4,4); plt.title(\"Top-hat\"); plt.imshow(tophat, cmap=\"gray\"); plt.axis(\"off\")\n", + "plt.subplot(2,4,5); plt.title(\"Enhanced\"); plt.imshow(enhanced, cmap=\"gray\"); plt.axis(\"off\")\n", + "plt.subplot(2,4,6); plt.title(\"Threshold\"); plt.imshow(thresh, cmap=\"gray\")#; plt.axis(\"off\")\n", + "plt.subplot(2,4,7); plt.title(\"image with contours\"); #plt.imshow(img)#; plt.axis(\"off\")\n", + "contour_vis = cv2.cvtColor(masked, cv2.COLOR_GRAY2BGR)\n", + "cv2.drawContours(contour_vis, contours, -1, (0,255,0), 1)\n", + "cv2.circle(contour_vis, best_point, 100, (0, 0, 255), -1)\n", + "plt.imshow(contour_vis)\n", + "plt.show()\n", + "\n", + "cv2.imwrite('masked.tiff', enhanced)\n", + "cv2.imwrite('thresh.tiff', thresh)" + ], + "id": "d98c070865b11f36", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1003\n", + "(2046, 2046)\n", + "10291\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping contour with area 2054203.5\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "Skipping vertical pin\n", + "best_point = (np.int32(0), np.int32(1421))\n", + "1003\n", + "corrected_point (np.int32(250), np.int32(1671))\n", + "Loop tip (leftmost point): (np.int32(0), np.int32(1421))\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 350, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 350 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-08T11:21:42.726663Z", + "start_time": "2025-09-08T11:21:41.711795Z" + } + }, + "cell_type": "code", + "source": [ + "x#bkg_old = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/alc_test_images/bkg280_020925.jpg\")\n", + "#bkg_new = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/alc_test_images/bkg280_03092025.jpg\")\n", + "bkg_old = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/bkg280_50_50_old.jpg\")\n", + "bkg_new = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/bkg280_50_50.jpg\")\n", + "#$bkg_newest = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/bkg280.jpg\")\n", + "grey_old = cv2.cvtColor(bkg_old, cv2.COLOR_RGB2GRAY)\n", + "grey_new = cv2.cvtColor(bkg_new, cv2.COLOR_RGB2GRAY)\n", + "#grey_newest = cv2.cvtColor(bkg_newest, cv2.COLOR_RGB2GRAY)\n", + "diff_image = cv2.absdiff(grey_old, grey_new)\n", + "_, thresh_diff = cv2.threshold(diff_image, threshold, 255, cv2.THRESH_BINARY)\n", + "\n", + "\n", + "# Simple subtraction (may result in negative values)\n", + "diff_simple = cv2.subtract(bkg_new, bkg_old)\n", + "\n", + "# Weighted difference for motion detection\n", + "diff_weighted = cv2.addWeighted(bkg_new, 0.5, bkg_old, -0.5, 128)\n", + "\n", + "# Using numpy for difference\n", + "diff_numpy = np.abs(bkg_new.astype(np.int16) - bkg_old.astype(np.int16)).astype(np.uint8)\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.imshow(bkg_old)\n", + "plt.subplot(1,2,2)\n", + "plt.imshow(bkg_new)" + ], + "id": "5c26fa11f85e6483", + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 275, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 275 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-08T08:13:17.148953Z", + "start_time": "2025-09-08T08:13:17.046977Z" + } + }, + "cell_type": "code", + "source": [ + "bkg_old_np = bkg_old.astype(np.float32)\n", + "bkg_old_np_normalized = bkg_old.astype(np.float32) / 255.0\n", + "bkg_new_np = bkg_old.astype(np.float32)\n", + "bkg_new_np_normalized = bkg_old.astype(np.float32) / 255.0\n", + "diff_np=bkg_old_np-bkg_new_np\n", + "diff_np_normalized=bkg_old_np_normalized-bkg_new_np_normalized" + ], + "id": "95a0ac65d0013e8", + "outputs": [], + "execution_count": 196 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-08T08:14:30.738697Z", + "start_time": "2025-09-08T08:14:30.671257Z" + } + }, + "cell_type": "code", + "source": [ + "print(\"mean: \", np.mean(grey_old.astype(np.float32)-grey_new.astype(np.float32)))\n", + "print(\"std: \", np.std(grey_old.astype(np.float32)-grey_new.astype(np.float32)))\n", + "diff_abs = np.abs(grey_old.astype(np.float32)-grey_new.astype(np.float32))\n", + "print(np.percentile(diff_abs, 99))" + ], + "id": "83aae96e9df6c807", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: -6.184164\n", + "std: 5.93317\n", + "21.0\n" + ] + } + ], + "execution_count": 200 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": [ + "threshold_old = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/alc_test_images/bkg280_020925.jpg\")\n", + "threshold_new = cv2.imread(\"/home/leonarski_f/aaredaq/daq/src/aaredaq/alc_test_images/bkg280_03092025.jpg\")" + ], + "id": "258a3d679516f15c" + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-05T13:33:03.863166Z", + "start_time": "2025-09-05T13:33:03.839938Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from scipy import ndimage\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Example showing the difference\n", + "image = np.random.rand(50, 50) * 100\n", + "# Add a bright spot\n", + "image[20:30, 35:45] = 200\n", + "\n", + "# Without thresholding - all pixels contribute\n", + "com_no_threshold = ndimage.center_of_mass(image)\n", + "print(f\"No threshold COM: ({com_no_threshold[1]:.2f}, {com_no_threshold[0]:.2f})\")\n", + "\n", + "# With thresholding - only bright pixels contribute\n", + "threshold = 150\n", + "thresholded = image.copy()\n", + "thresholded[thresholded < threshold] = 0\n", + "com_with_threshold = ndimage.center_of_mass(thresholded)\n", + "print(f\"With threshold COM: ({com_with_threshold[1]:.2f}, {com_with_threshold[0]:.2f})\")\n" + ], + "id": "d70801a606268e76", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "No threshold COM: (26.11, 24.33)\n", + "With threshold COM: (39.50, 24.50)\n" + ] + } + ], + "execution_count": 189 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-05T13:33:18.254639Z", + "start_time": "2025-09-05T13:33:18.248074Z" + } + }, + "cell_type": "code", + "source": [ + "def center_of_mass_with_threshold(image, threshold):\n", + " \"\"\"\n", + " Apply threshold before center of mass calculation\n", + " \"\"\"\n", + " # Create binary mask\n", + " binary = (image >= threshold).astype(float)\n", + "\n", + " # Calculate center of mass on thresholded image\n", + " com = ndimage.center_of_mass(binary)\n", + "\n", + " # Return as (x, y) coordinates\n", + " return (com[1], com[0]) if com[0] is not np.nan else None\n" + ], + "id": "1ba37750a7b66b23", + "outputs": [], + "execution_count": 190 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-09-05T13:33:27.236834Z", + "start_time": "2025-09-05T13:33:27.231958Z" + } + }, + "cell_type": "code", + "source": [ + "def weighted_center_of_mass_threshold(image, threshold):\n", + " \"\"\"\n", + " Keep original intensities above threshold, zero below\n", + " \"\"\"\n", + " weighted_image = image.copy()\n", + " weighted_image[weighted_image < threshold] = 0\n", + "\n", + " com = ndimage.center_of_mass(weighted_image)\n", + " return (com[1], com[0]) if com[0] is not np.nan else None\n" + ], + "id": "59452341d64bc800", + "outputs": [], + "execution_count": 191 + }, + { + "metadata": {}, + "cell_type": "code", + "outputs": [], + "execution_count": null, + "source": "", + "id": "8cf8041e736e5a43" + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}