OSCR

DRIFT-EM enables direct wafer retrieval of ultrathin serial sections for large-volume electron microscopy.

Code ↔ Paper

3 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 3 matches
  1. [1] § STAR★Methods › Method details › Computational pipeline › Automatic ROI detection ↔ detect_rectangles.py, lines 15–67 · score 0.84 · capture subtle edges, Sobel operators, low threshold, gradients, kernels, magnitude
  2. [2] § STAR★Methods › Method details › Computational pipeline › Automatic ROI detection ↔ detect_rectangles.py, lines 15–67 · score 0.72 · external contour, dilated edges, kernel, subtracted, binary, detection
  3. [3] § STAR★Methods › Method details › Computational pipeline › Nearest-neighbor ordering ↔ generate_and_fuse.py, lines 274–324 · score 0.50 · nearest neighbor algorithm, travel, distance

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 663 lines · 28 KB · no license · 2 matches

  1. #!/usr/bin/env python3
  2. import cv2
  3. import numpy as np
  4. import argparse
  5. import random # For selecting random contours
  6. from scipy.optimize import minimize # For advanced optimization
  7. import datetime # For timestamped output filenames
  8. import os # For path operations
  9. import pandas as pd # For creating Excel files
  11. # Set fixed random seed for reproducibility
  12. random.seed(42) # Always use the same random seed for consistent results
  13. np.random.seed(42)
  15. def process_image(image_path):
  16. """
  17. Process an image to detect contours with edge subtraction method using Sobel.
  19. Args:
  20. image_path (str): Path to the input image
  22. Returns:
  23. tuple: (image, binary, contours, edges, binary_minus_edges)
  24. """
  25. # Read the image
  26. image = cv2.imread(image_path)
  28. # Convert to grayscale if it's not already
  29. if len(image.shape) == 3:
  30. gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
  31. else:
  32. gray = image.copy()
  34. # Fixed threshold at value 86 (for improved rectangle detection)
  35. _, binary = cv2.threshold(gray, 86, 255, cv2.THRESH_BINARY_INV)
  37. # Apply contrast enhancement to emphasize gradients
  38. clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
  39. gray_enhanced = clahe.apply(gray)
  41. # Apply Sobel operators with large kernel size
  42. sobelx = cv2.Sobel(gray_enhanced, cv2.CV_64F, 1, 0, ksize=5)
  43. sobely = cv2.Sobel(gray_enhanced, cv2.CV_64F, 0, 1, ksize=5)
  45. # Calculate magnitude
  46. magnitude = np.sqrt(sobelx**2 + sobely**2)
  48. # Normalize to 0-255 range
  49. magnitude = cv2.normalize(magnitude, None, 0, 255, cv2.NORM_MINMAX, dtype=cv2.CV_8U)
  51. # Apply a low threshold to capture subtle edges
  52. _, edges = cv2.threshold(magnitude, 20, 255, cv2.THRESH_BINARY)
  54. # Apply three iterations of dilation with a 4x4 kernel
  55. kernel = np.ones((4, 4), np.uint8)
  56. dilated_edges = edges.copy()
  57. for _ in range(3):
  58. dilated_edges = cv2.dilate(dilated_edges, kernel, iterations=1)
  60. # Use the dilated edges for subtraction
  61. binary_minus_edges = cv2.bitwise_and(binary, binary, mask=cv2.bitwise_not(dilated_edges))
  63. # Find only external contours using the binary_minus_edges image
  64. contours, _ = cv2.findContours(binary_minus_edges.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
  66. # Return the dilated edges instead of the original edges
  67. return image, binary_minus_edges, contours, dilated_edges, binary_minus_edges
  69. def optimize_rectangle_for_contour(image, contour, target_width=36, target_height=24, occupied_mask=None):
  70. # Store the grayscale image for optimization
  71. # We will optimize to find the darkest region (lowest pixel values)
  72. gray_for_opt = image.copy()
  74. # Create a binary mask from the contour
  75. x, y, w, h = cv2.boundingRect(contour)
  76. mask = np.zeros((h, w), dtype=np.uint8)
  78. # Shift contour to the local coordinates of the bounding rectangle
  79. shifted_contour = contour - np.array([x, y])
  81. # Draw the contour on the mask
  82. cv2.drawContours(mask, [shifted_contour], 0, 255, -1) # Fill the contour
  84. # Calculate moments from the binary mask
  85. M = cv2.moments(mask)
  87. if M["m00"] != 0:
  88. # Get center of mass in local coordinates
  89. local_cx = int(M["m10"] / M["m00"])
  90. local_cy = int(M["m01"] / M["m00"])
  92. # Convert to global coordinates
  93. cx = x + local_cx
  94. cy = y + local_cy
  96. # Calculate initial angle from moments (more accurate orientation)
  97. # Using central moments to get principal axes orientation
  98. mu20 = M["mu20"] / M["m00"]
  99. mu02 = M["mu02"] / M["m00"]
  100. mu11 = M["mu11"] / M["m00"]
  102. # Calculate the orientation angle in degrees
  103. if mu20 != mu02:
  104. moments_angle = 0.5 * np.degrees(np.arctan2(2 * mu11, mu20 - mu02))
  105. # Normalize to 0-180 range
  106. moments_angle = moments_angle % 180
  107. else:
  108. moments_angle = 0 # Default to horizontal
  109. else:
  110. # Fallback to bounding rect center (should rarely happen)
  111. cx, cy = x + w//2, y + h//2
  112. moments_angle = 0 # Default to horizontal
  114. # Choose initial angle (prefer moments if available)
  115. initial_angle = moments_angle
  117. # Normalize angle to 0-180 range for consistency
  118. initial_angle = initial_angle % 180
  120. # Cache for optimization - prevents recreating the image on every iteration
  121. h, w = gray_for_opt.shape[:2]
  123. def rect_cost_components(params):
  124. """
  125. Calculate the individual cost components for a rectangle.
  127. Args:
  128. params: [center_x, center_y, angle_radians]
  130. Returns:
  131. tuple: (brightness_cost, angle_penalty_cost, overlap_penalty)
  132. """
  133. cx, cy, angle_rad = params
  134. angle_deg = np.degrees(angle_rad)
  136. # Constrain to image boundaries
  137. cx = np.clip(cx, 0, w-1)
  138. cy = np.clip(cy, 0, h-1)
  140. # Create a rotated rectangle
  141. rect = ((cx, cy), (target_width, target_height), angle_deg)
  142. box = cv2.boxPoints(rect)
  143. box = box.astype(np.int32)
  145. # Check for overlap with existing rectangles using the occupied mask
  146. overlap_penalty = 0.0
  147. if occupied_mask is not None:
  148. # Create a mask for this candidate rectangle
  149. current_rect_mask = np.zeros((h, w), dtype=np.uint8)
  150. cv2.fillPoly(current_rect_mask, [box], 1)
  152. # Check if this rectangle overlaps with any existing rectangles
  153. # by comparing with the occupied mask
  154. overlap = np.logical_and(current_rect_mask, occupied_mask).sum()
  156. # If there's any overlap, apply a very large penalty
  157. if overlap > 0:
  158. overlap_penalty = np.sum(overlap)
  160. # Create a mask for this rectangle for brightness calculation
  161. mask = np.zeros((h, w), dtype=np.uint8)
  162. cv2.fillPoly(mask, [box], 255)
  164. # Extract region using the mask and calculate the sum of pixel values
  165. # This will measure the total "brightness" inside the rectangle
  166. # For a grayscale image, lower values mean darker pixels
  167. masked_region = cv2.bitwise_and(gray_for_opt, gray_for_opt, mask=mask)
  169. # Count non-zero pixels (where mask is applied)
  170. non_zero_count = cv2.countNonZero(mask)
  172. # Default to high cost if no pixels in mask
  173. if non_zero_count == 0:
  174. return float('inf'), 0.0, float('inf')
  176. brightness = np.sum(masked_region) / non_zero_count
  178. current_angle = angle_deg % 180
  179. contour_angle = initial_angle % 180
  181. # Calculate angle deviation cost (penalty for rotating too far from initial angle)
  182. # Handle the discontinuity at 0/180 degrees
  183. angle_diff = min(
  184. abs(current_angle - contour_angle), # Regular difference
  185. abs(current_angle - (contour_angle + 180) % 180), # Wrap around one way
  186. abs((current_angle + 180) % 180 - contour_angle) # Wrap around other way
  187. )
  189. angle_penalty = angle_diff * 0.75
  191. return float(brightness), float(angle_penalty), float(overlap_penalty)
  193. def rect_overlap_cost(params):
  194. """
  195. Cost function for optimization: sum of pixel values inside the rectangle
  196. (to be minimized). Lower pixel values (darker) are better.
  198. Args:
  199. params: [center_x, center_y, angle_radians]
  201. Returns:
  202. float: Sum of pixel values (lower is better, indicating darker area)
  203. """
  204. brightness, angle_penalty, overlap_penalty = rect_cost_components(params)
  206. # Combine the costs - brightness is our main term, angle penalty is secondary
  207. combined_cost = brightness + angle_penalty + overlap_penalty
  209. return combined_cost
  211. # Initial parameters [x, y, angle_radians]
  212. initial_params = [cx, cy, np.radians(initial_angle)]
  213. # Bounds for the parameters:
  214. # x: can move ±5 pixels from center
  215. # y: can move ±5 pixels from center
  216. # angle: can rotate ±90 degrees from initial angle
  217. bounds = [
  218. (max(0, cx - 5), min(w-1, cx + 5)),
  219. (max(0, cy - 5), min(h-1, cy + 5)),
  220. (np.radians(initial_angle - 90), np.radians(initial_angle + 90))
  221. ]
  222. print(bounds)
  224. # Use the minimize function for optimization
  225. result = minimize(
  226. rect_overlap_cost,
  227. initial_params,
  228. method='L-BFGS-B', # Works well with bounds
  229. bounds=bounds,
  230. options={'maxiter': 100}
  231. )
  233. # Get the optimized parameters
  234. opt_cx, opt_cy, opt_angle_rad = result.x
  235. opt_angle_deg = np.degrees(opt_angle_rad) % 180
  237. # Calculate the final cost for reporting
  238. final_cost = rect_overlap_cost([opt_cx, opt_cy, opt_angle_rad])
  240. return {
  241. 'center_x': int(opt_cx),
  242. 'center_y': int(opt_cy),
  243. 'angle': opt_angle_deg,
  244. 'width': target_width,
  245. 'height': target_height,
  246. 'score': final_cost,
  247. 'success': result.success
  248. }
  250. def save_debug_image(image_path, min_area=0, max_area=float('inf'), num_rects=5, save_excel=True):
  251. """
  252. Save high-resolution debug images showing:
  253. A) Original image with optimized 24x36 rectangles
  254. B) Detected contours with random colors (contours outside size limits are shown in gray)
  255. C) Edge detection image (Sobel)
  256. D) Binary minus edges (the processed image used for detection)
  258. Args:
  259. image_path (str): Path to the input image
  260. min_area (int): Minimum contour area to highlight in color
  261. max_area (int): Maximum contour area to highlight in color
  262. num_rects (int): Number of random contours to optimize and display
  263. save_excel (bool): Whether to save contour data to Excel file
  265. Returns:
  266. str: Path to the saved debug image
  267. """
  268. # Generate timestamp for unique filename
  269. timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
  271. # Get input file name without extension
  272. base_name = os.path.splitext(os.path.basename(image_path))[0]
  274. # Create output path with timestamp in current directory
  275. output_path = f"debug_{base_name}_{timestamp}.tiff"
  277. print(f"Processing debug image for {image_path}...")
  278. print(f"Output will be saved to {output_path}")
  281. # Process image with edge subtraction and Sobel method
  282. print(f"Steps 1-5: Processing image using edge subtraction with Sobel...")
  284. # Use edge subtraction method
  285. image, binary, contours, edges, binary_minus_edges = process_image(image_path)
  287. # Save contour data to Excel if requested
  288. if save_excel:
  289. print("Saving contour data to Excel file...")
  290. contour_data = []
  292. for i, cnt in enumerate(contours):
  293. # Calculate contour area
  294. area = cv2.contourArea(cnt)
  296. # Calculate center of mass using moments
  297. M = cv2.moments(cnt)
  298. if M["m00"] != 0:
  299. cx = int(M["m10"] / M["m00"])
  300. cy = int(M["m01"] / M["m00"])
  301. else:
  302. # Fallback to bounding rect center if moments calculation fails
  303. x, y, w, h = cv2.boundingRect(cnt)
  304. cx, cy = x + w//2, y + h//2
  306. # Calculate bounding rectangle dimensions
  307. x, y, w, h = cv2.boundingRect(cnt)
  309. # Calculate rectangle fit quality
  310. # Get the minimum area rectangle that fits the contour
  311. rect = cv2.minAreaRect(cnt)
  312. rect_width, rect_height = rect[1]
  314. # Make sure width is the smaller dimension and height is the larger one
  315. if rect_width > rect_height:
  316. rect_width, rect_height = rect_height, rect_width
  318. # Calculate area of the min area rectangle
  319. rect_area = rect_width * rect_height
  321. # Calculate fill ratio (how well the contour fills the rectangle)
  322. # Higher ratio means better rectangle fit
  323. fill_ratio = area / rect_area if rect_area > 0 else 0
  325. # Calculate aspect ratio of the rectangle (height/width)
  326. aspect_ratio = rect_height / rect_width if rect_width > 0 else 0
  328. # Calculate how well the contour fits a 9x20 rectangle
  329. # Target aspect ratio is 20/9 = 2.22
  330. target_aspect_ratio = 20.0 / 9.0
  332. # Calculate aspect ratio fit score (lower is better)
  333. aspect_ratio_fit = abs(aspect_ratio - target_aspect_ratio)
  335. # Calculate size fit (how close is the contour to the target size)
  336. target_area = 9 * 20
  337. # Avoid division by zero
  338. if area == 0:
  339. area_ratio = 0 # If area is zero, it's a poor fit
  340. else:
  341. area_ratio = min(area / target_area, target_area / area) # Between 0 and 1, higher is better
  343. # Combined 9x20 fit score (higher is better)
  344. # Weigh aspect ratio fit more heavily
  345. rect_9x20_fit = (0.7 * (1 - aspect_ratio_fit / 3.0)) + (0.3 * area_ratio)
  347. # Clamp the score between 0 and 1
  348. rect_9x20_fit = max(0, min(1, rect_9x20_fit))
  350. # Add data to the list
  351. contour_data.append({
  352. 'Contour_ID': i,
  353. 'Area': area,
  354. 'Center_X': cx,
  355. 'Center_Y': cy,
  356. 'Bounding_Box_X': x,
  357. 'Bounding_Box_Y': y,
  358. 'Bounding_Box_Width': w,
  359. 'Bounding_Box_Height': h,
  360. 'Min_Rect_Width': round(rect_width, 2),
  361. 'Min_Rect_Height': round(rect_height, 2),
  362. 'Min_Rect_Area': round(rect_area, 2),
  363. 'Rectangle_Fill_Ratio': round(fill_ratio, 4),
  364. 'Aspect_Ratio': round(aspect_ratio, 4),
  365. 'Rect_9x20_Fit_Score': round(rect_9x20_fit, 4)
  366. })
  368. # Create DataFrame and save to Excel
  369. df = pd.DataFrame(contour_data)
  371. # Sort by 9x20 rectangle fit score (highest first)
  372. df = df.sort_values(by='Rect_9x20_Fit_Score', ascending=False)
  374. df.to_excel('d.xlsx', index=False)
  375. print(f"Saved data for {len(contours)} contours to d.xlsx (sorted by 9x20 rectangle fit)")
  377. # Create a copy of the original image for panel A
  378. panel_a_image = image.copy()
  380. # Create a 2x2 grid
  381. print("Step 6: Creating composite image grid...")
  382. # Get dimensions from the input image
  383. img_height, img_width = image.shape[:2]
  385. # Set fixed output dimensions for debug view
  386. height, width = binary.shape # Standard debug size for all panels
  387. scale_factor = 1 # Scale factor for output resolution
  388. combined_height = height * 2 * scale_factor
  389. combined_width = width * 2 * scale_factor
  390. combined = np.zeros((combined_height, combined_width, 3), dtype=np.uint8)
  392. # Convert grayscale images to BGR for visualization
  393. print("Step 7: Converting images for visualization...")
  394. edges_bgr = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
  395. binary_minus_edges_bgr = cv2.cvtColor(binary_minus_edges, cv2.COLOR_GRAY2BGR)
  397. # Ensure panel_a_image is in BGR format if it's grayscale
  398. if len(panel_a_image.shape) == 2 or panel_a_image.shape[2] == 1:
  399. panel_a_image = cv2.cvtColor(panel_a_image, cv2.COLOR_GRAY2BGR)
  401. # No need to resize if scale_factor is 1
  402. print("Step 8: Preparing images for visualization...")
  404. # Create contour visualization image
  405. print("Step 9a: Creating contour visualization image with size filtering...")
  406. contour_image = image.copy()
  408. # Count valid contours (within size limits)
  409. valid_contours = 0
  410. valid_contour_list = []
  412. # Generate a random color for each contour
  413. for i, contour in enumerate(contours):
  414. # Get contour area
  415. area = cv2.contourArea(contour)
  417. # Check if contour is within size limits
  418. if min_area <= area <= max_area:
  419. # Valid contour - use a random bright color
  420. color = np.random.randint(0, 255, size=3).tolist()
  422. # Ensure the color has at least one bright channel for visibility
  423. max_channel = max(color)
  424. if max_channel < 150: # If all channels are dim
  425. bright_channel = np.random.randint(0, 3) # Choose a random channel to make bright
  426. color[bright_channel] = 255 # Make that channel bright
  428. valid_contours += 1
  429. valid_contour_list.append((contour, color))
  430. else:
  431. # Invalid contour - use gray
  432. color = [120, 120, 120] # Gray color for contours outside size limits
  434. # Draw contour outline slightly thicker for better visibility
  435. cv2.drawContours(contour_image, [contour], -1, color, 2)
  437. # Optimize and draw rectangles if we have valid contours
  438. if valid_contour_list:
  439. # Create a list of contours to optimize, picking contours with highest 9x20 fit score
  440. valid_contours_with_score = []
  442. for contour, color in valid_contour_list:
  443. # Calculate how well this contour fits a 9x20 rectangle
  444. # Get the minimum area rectangle
  445. rect = cv2.minAreaRect(contour)
  446. rect_width, rect_height = rect[1]
  448. # Make sure width is the smaller dimension
  449. if rect_width > rect_height:
  450. rect_width, rect_height = rect_height, rect_width
  452. # Calculate aspect ratio
  453. aspect_ratio = rect_height / rect_width if rect_width > 0 else 0
  455. # Target aspect ratio for 9x20
  456. target_aspect_ratio = 20.0 / 9.0
  458. # Aspect ratio fit score (lower is better)
  459. aspect_ratio_fit = abs(aspect_ratio - target_aspect_ratio)
  461. # Calculate area
  462. area = cv2.contourArea(contour)
  463. target_area = 9 * 20
  464. # Avoid division by zero
  465. if area == 0:
  466. area_ratio = 0 # If area is zero, it's a poor fit
  467. else:
  468. area_ratio = min(area / target_area, target_area / area) # Between 0 and 1, higher is better
  470. # Combined fit score (higher is better)
  471. fit_score = (0.7 * (1 - aspect_ratio_fit / 3.0)) + (0.3 * area_ratio)
  472. fit_score = max(0, min(1, fit_score))
  474. valid_contours_with_score.append((contour, color, fit_score))
  476. # Sort by fit score (highest first)
  477. valid_contours_with_score.sort(key=lambda x: x[2], reverse=True)
  479. # Select top contours (up to num_rects)
  480. num_to_optimize = min(num_rects, len(valid_contours_with_score))
  481. contours_to_optimize = [(c, color) for c, color, _ in valid_contours_with_score[:num_to_optimize]]
  483. # Log that optimization is being performed
  484. print(f"Optimizing {num_to_optimize} rectangles (sorted by 9x20 fit)...")
  486. # Create a transparent overlay for the optimized rectangles
  487. overlay = panel_a_image.copy()
  489. # Draw the original contours in blue
  490. for contour, _ in contours_to_optimize:
  491. cv2.drawContours(overlay, [contour], 0, (255, 0, 0), 1) # Thin blue line
  493. # Create a mask to keep track of occupied areas
  494. h, w = image.shape[:2]
  495. occupied_mask = np.zeros((h, w), dtype=np.uint8)
  497. # Keep track of optimized rectangles (for visualization)
  498. optimized_rectangles = []
  500. # Now optimize each contour and draw the rectangles
  501. for i, (contour, _) in enumerate(contours_to_optimize):
  502. # Show progress in console
  503. print(f" Optimizing rectangle {i+1}/{num_to_optimize}...")
  505. # Optimize the rectangle placement, passing the occupied mask to avoid overlap
  506. opt_rect = optimize_rectangle_for_contour(image, contour, occupied_mask=occupied_mask)
  508. # Only use rectangles where optimization succeeded (not infinite cost)
  509. if opt_rect['score'] < float('inf'):
  510. # Add this rectangle to our list of optimized rectangles
  511. optimized_rectangles.append(opt_rect)
  513. # Update the occupied mask with this rectangle
  514. rect_center = (opt_rect['center_x'], opt_rect['center_y'])
  515. rect_size = (opt_rect['width'], opt_rect['height'])
  516. rect_angle = opt_rect['angle']
  518. # Create box points for the rectangle
  519. rect_box = cv2.boxPoints((rect_center, rect_size, rect_angle))
  520. rect_box = rect_box.astype(np.int32)
  522. # Add this rectangle to the occupied mask
  523. cv2.fillPoly(occupied_mask, [rect_box], 1)
  525. # Draw the optimized rectangle
  526. center = (opt_rect['center_x'], opt_rect['center_y'])
  527. size = (opt_rect['width'], opt_rect['height'])
  528. angle = opt_rect['angle']
  530. # Create the rotated rectangle points
  531. rect = (center, size, angle)
  532. box = cv2.boxPoints(rect)
  533. box = box.astype(np.int32)
  535. # Draw with a thin green line
  536. cv2.drawContours(overlay, [box], 0, (0, 255, 0), 1) # Thin green line
  538. # Log the optimization result
  539. print(f" Rectangle at ({center[0]}, {center[1]}), angle: {angle:.1f}°, score: {opt_rect['score']:.0f}")
  540. else:
  541. print("failure")
  542. # Apply the overlay with transparency
  543. alpha = 0.6 # 60% opacity (more visible than before)
  544. cv2.addWeighted(overlay, alpha, panel_a_image, 1 - alpha, 0, panel_a_image)
  546. print(f" Drew {num_to_optimize} optimized rectangles with semi-transparency")
  548. # Save optimized rectangles to a .magc file with values multiplied by 10
  549. if optimized_rectangles:
  550. print("Saving optimized rectangles to .magc file...")
  551. # Create a .magc file using the base name of the input image
  552. magc_output_path = f"{base_name}_{timestamp}.magc"
  554. with open(magc_output_path, 'w') as f:
  555. # Write the header with the number of sections
  556. f.write("[sections]\n")
  557. f.write(f"number = {len(optimized_rectangles)}\n\n")
  559. # Write each section
  560. for i, rect in enumerate(optimized_rectangles):
  561. # Extract rectangle information
  562. center_x = rect['center_x'] * 10 # Multiply by 10 as requested
  563. center_y = rect['center_y'] * 10 # Multiply by 10 as requested
  564. width_here = rect['width'] * 10 # Multiply by 10 as requested
  565. height_here = rect['height'] * 10 # Multiply by 10 as requested
  566. angle = rect['angle']
  568. # Calculate the corner points of the rectangle
  569. rect_points = cv2.boxPoints(((rect['center_x'], rect['center_y']),
  570. (rect['width'], rect['height']),
  571. rect['angle']))
  572. rect_points = rect_points.astype(np.float32)
  574. # Multiply the points by 10 for the .magc file
  575. rect_points *= 10
  577. # Format the polygon string
  578. polygon_str = ",".join([f"{p[0]:.1f},{p[1]:.1f}" for p in rect_points])
  580. # Calculate area (width * height * 10^2 since both dimensions are multiplied by 10)
  581. area = width_here * height_here
  583. # Write the section
  584. f.write(f"[section.{i:04d}]\n")
  585. f.write(f"polygon = {polygon_str}\n")
  586. f.write(f"center = {center_x:.2f},{center_y:.2f}\n")
  587. f.write(f"area = {area:.1f}\n")
  588. f.write(f"angle = {angle}\n\n")
  590. print(f"Saved {len(optimized_rectangles)} rectangles to {magc_output_path} with values multiplied by 10")
  592. # Ensure contour_image is in BGR format if it's grayscale
  593. if len(contour_image.shape) == 2 or contour_image.shape[2] == 1:
  594. contour_image = cv2.cvtColor(contour_image, cv2.COLOR_GRAY2BGR)
  596. # Place each image in the grid
  597. print("Step 9b: Arranging images in grid...")
  599. combined[0:height, 0:width] = panel_a_image # A) Original with optimized rectangles
  600. combined[0:height, width:width*2] = contour_image # B) Detected Contours
  601. combined[height:height*2, 0:width] = edges_bgr # C) Edge detection
  602. combined[height:height*2, width:width*2] = binary_minus_edges_bgr # D) Binary minus Edges
  604. # Add text labels
  605. print("Step 10: Adding text labels...")
  606. font = cv2.FONT_HERSHEY_SIMPLEX
  607. font_scale = 0.5 # Smaller font scale for fixed-size debug view
  608. font_thickness = 1
  609. cv2.putText(combined, "A) Optimized 24x36 Rectangles", (10, 20), font, font_scale, (0, 255, 255), font_thickness)
  610. cv2.putText(combined, "B) Detected Contours", (width + 10, 20), font, font_scale, (0, 255, 255), font_thickness)
  611. cv2.putText(combined, "C) Edge Detection (Sobel)", (10, height + 20), font, font_scale, (0, 255, 255), font_thickness)
  612. cv2.putText(combined, "D) Binary minus Edges", (width + 10, height + 20), font, font_scale, (0, 255, 255), font_thickness)
  614. # Add contour count as text overlay
  615. total_contours = len(contours)
  616. cv2.putText(combined, f"Total Contours: {total_contours} (Valid: {valid_contours})",
  617. (10, combined_height - 10), cv2.FONT_HERSHEY_SIMPLEX,
  618. 0.5, (255, 255, 255), 1)
  620. # Add size thresholds and method info
  621. cv2.putText(combined, f"Size range: {min_area}-{max_area}",
  622. (10, combined_height - 30), cv2.FONT_HERSHEY_SIMPLEX,
  623. 0.5, (255, 255, 255), 1)
  625. # Add timestamp to the image
  626. cv2.putText(combined, f"Time: {timestamp}",
  627. (combined_width // 2, combined_height - 10), cv2.FONT_HERSHEY_SIMPLEX,
  628. 0.5, (255, 255, 255), 1)
  630. cv2.putText(combined, "Method: Edge Subtraction (Sobel)",
  631. (combined_width // 2, combined_height - 30), cv2.FONT_HERSHEY_SIMPLEX,
  632. 0.5, (255, 255, 255), 1)
  635. # Save the debug image as TIFF
  636. print("Step 12: Writing output TIFF image...")
  637. cv2.imwrite(output_path, combined) # TIFF format preserves full quality
  638. print(f"Debug image saved to {output_path}")
  639. print("Debug image processing completed successfully!")
  641. return output_path
  643. if __name__ == "__main__":
  644. parser = argparse.ArgumentParser(description='Generate debug image visualization')
  645. parser.add_argument('--image_path', default="5x_gregc_ORG_10p.tif", help='Path to the input image')
  646. parser.add_argument('--min-area', type=int, default=1, help='Minimum contour area')
  647. parser.add_argument('--max-area', type=int, default=400, help='Maximum contour area')
  648. parser.add_argument('--num-rects', type=int, default=5000,
  649. help='Number of random contours to optimize (default: 5)')
  650. parser.add_argument('--random-seed', type=int, default=42,
  651. help='Random seed for consistent contour selection (default: 42)')
  652. parser.add_argument('--excel', action='store_true', default=True,
  653. help='Save contour data to Excel file (default: True)')
  655. args = parser.parse_args()
  656. random.seed(args.random_seed)
  657. # Save debug image with automatic timestamped filename
  658. output_path = save_debug_image(
  659. args.image_path,
  660. args.min_area,
  661. args.max_area,
  662. args.num_rects,
  663. args.excel)

detect_rectangles.py at commit 69ba659, no license · at the source

Overview

Authors: Nelson Medina1,2,3, Joseph V. Gogola2,3,4, Kevin Boergens2,5, Fuming Yang6, Yaron Meirovitch6, Jeff W. Lichtman6, Narayanan Kasthuri2,3, Gregg Wildenberg2,3
ORCID iDs: Gregg Wildenberg
  1. MRC Laboratory of Molecular Biology, Cambridge Biomedical Campus, Cambridge CB2 0QH, MA, UK
  2. Department of Neurobiology, The University of Chicago, Chicago IL 60637, USA
  3. Argonne National Laboratory, Biosciences Division, Lemont IL 60439, USA
  4. Department of Medicine, The University of Chicago, Chicago IL 60637, USA
  5. Department of Physics, University of Illinois Chicago, Chicago IL 60607, USA
  6. Department of Molecular and Cellular Biology, Harvard University, Cambridge MA 02138, USA
Institutions: Argonne National Laboratory (United States); MRC Laboratory of Molecular Biology (United Kingdom); University of Chicago (United States); University of Illinois Chicago (United States); Harvard University (United States)
Journal: Cell reports methods, volume 6, issue 6, article 101429
Dates: received 5 December 2025; accepted 6 April 2026; published online 5 May 2026; in print June 2026
Type: Brief report · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1016/j.crmeth.2026.101429 · PMID 42086049 · PMCID PMC13282653 · OpenAlex W7160299588
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: histology / microscopy (modality), methods / tools (subfield)
Methods: fMRI & imaging
Keywords: connectomics, large-volume serial electron microscopy, vEM, ultramicrotomy, brain mapping
MeSH: Microtomy*, Volume Electron Microscopy*, Animals, Software (* major topic)
Topic: Advanced Electron Microscopy Techniques and Applications (Structural Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NIH (1U01NS136401–01, U01NS132158); UMass (R01 R01NS133654); UM1 (UM1NS132250); NSF Neuro Nex (#2014862)
Citations: not cited yet (Europe PMC); 29 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repositories

Its files are read in the Code ↔ Paper reader above, with 3 matches between paragraphs and lines of code.

Zenodo 19380076

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Materials availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
1 file
At the source: doi.org/10.5281/zenodo.19380076

figshare 31836088

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 2 files
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
At the source: doi.org/10.6084/m9.figshare.31836088

Zenodo 19372693

License: MIT
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (3 files), Matplotlib (1 file), NetworkX (1 file), NumPy (1 file), OpenCV (1 file), scikit-image (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
5 files
At the source: doi.org/10.5281/zenodo.19372693

Zenodo 19380050

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Data and code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (3 files), OpenCV (2 files), Pillow (2 files), NetworkX (1 file), pandas (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
3 files
At the source: doi.org/10.5281/zenodo.19380050

boergens/DRIFT-EM

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: 69ba659c31935c04e3b1dd5ba318204e9df42122, 3 November 2025
Languages: Python (3)
Size: 8 files, 3 scripts
Software Heritage: not archived
Found in: the text, “Automatic ROI detection”
Holds: environment (requirements.txt)
Not found: README, license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (3 files), OpenCV (2 files), Pillow (2 files), NetworkX (1 file), pandas (1 file), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
3 files
At the source: github.com/boergens/DRIFT-EM

templiert/MagC

License: GPL-3.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: e1a89cf12cbfe61f1b2a4e844483dbf8a2b1a749, 21 October 2019
Languages: Python (28), Shell (1)
Size: 35 files, 29 scripts
Software Heritage: not archived
Found in: the text, “Automatic ROI detection”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: ImageJ / Fiji (21 files), NumPy (4 files), Matplotlib (2 files), Pillow (2 files), scikit-image (2 files), SciPy (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
31 files
At the source: github.com/templiert/MagC

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 6 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 38 scripts, each with its path and the digest of its content;
  • 3 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

Datasets cited

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1016/j.crmeth.2026.101429.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 5 keywords, 4 MeSH terms, 4 funders, 28 references.

Cite

This paper

Medina, N., Gogola, J. V., Boergens, K., Yang, F., Meirovitch, Y., Lichtman, J. W., Kasthuri, N., & Wildenberg, G. (2026). DRIFT-EM enables direct wafer retrieval of ultrathin serial sections for large-volume electron microscopy. Cell reports methods, 6(6), 101429. https://doi.org/10.1016/j.crmeth.2026.101429

BibTeX

@article{medina2026drift,
author = {Medina, Nelson and Gogola, Joseph V. and Boergens, Kevin and Yang, Fuming and Meirovitch, Yaron and Lichtman, Jeff W. and Kasthuri, Narayanan and Wildenberg, Gregg},
title = {{DRIFT-EM enables direct wafer retrieval of ultrathin serial sections for large-volume electron microscopy}},
journal = {Cell reports methods},
year = {2026},
month = may,
volume = {6},
number = {6},
pages = {101429},
publisher = {Elsevier},
issn = {2667-2375},
doi = {10.1016/j.crmeth.2026.101429},
url = {https://doi.org/10.1016/j.crmeth.2026.101429},
pmid = {42086049},
pmcid = {PMC13282653}
}

RIS

TY - JOUR
AU - Medina, Nelson
AU - Gogola, Joseph V.
AU - Boergens, Kevin
AU - Yang, Fuming
AU - Meirovitch, Yaron
AU - Lichtman, Jeff W.
AU - Kasthuri, Narayanan
AU - Wildenberg, Gregg
TI - DRIFT-EM enables direct wafer retrieval of ultrathin serial sections for large-volume electron microscopy
T2 - Cell reports methods
J2 - Cell Rep Methods
PY - 2026
DA - 2026/05/05
VL - 6
IS - 6
SP - 101429
SN - 2667-2375
PB - Elsevier
DO - 10.1016/j.crmeth.2026.101429
UR - https://doi.org/10.1016/j.crmeth.2026.101429
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.crmeth.2026.101429",
"type": "article-journal",
"title": "DRIFT-EM enables direct wafer retrieval of ultrathin serial sections for large-volume electron microscopy",
"container-title": "Cell reports methods",
"author": [
{
"family": "Medina",
"given": "Nelson"
},
{
"family": "Gogola",
"given": "Joseph V."
},
{
"family": "Boergens",
"given": "Kevin"
},
{
"family": "Yang",
"given": "Fuming"
},
{
"family": "Meirovitch",
"given": "Yaron"
},
{
"family": "Lichtman",
"given": "Jeff W."
},
{
"family": "Kasthuri",
"given": "Narayanan"
},
{
"family": "Wildenberg",
"given": "Gregg"
}
],
"container-title-short": "Cell Rep Methods",
"volume": "6",
"issue": "6",
"page": "101429",
"DOI": "10.1016/j.crmeth.2026.101429",
"PMID": "42086049",
"PMCID": "PMC13282653",
"ISSN": "2667-2375",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.crmeth.2026.101429",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
5
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: OpenCV, scikit-image, Pillow, 4 other tools, histology / microscopy, methods / tools, 4 references
[2] doi:10.3389/fnsys.2026.1822122 [code]
Convergence-divergence circuits for multimodal integration of innate and learned opponent valences.
Journal: Frontiers in systems neuroscience
In common: NetworkX, scikit-image, Pillow, 4 other tools, 4 references
[3] doi:10.1038/s41593-026-02388-9 [code]
Hippocampal CA3 connectomics reveals a gradient of mossy fiber inputs and selective feedforward inhibition onto pyramidal cells.
Journal: Nature neuroscience
In common: NetworkX, OpenCV, Pillow, 4 other tools, histology / microscopy, 3 references
[4] doi:10.1038/s41467-026-72152-x [code]
Centralized brain networks controlling antennal grooming coordination.
Journal: Nature communications
In common: NetworkX, OpenCV, pandas, 3 other tools, 4 references
[5] doi:10.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: NetworkX, scikit-image, pandas, 3 other tools, 4 references
[6] doi:10.1038/s41467-026-72180-7 [code]
Probing molecular diversity and ultrastructure of brain cells with fluorescent aptamers.
Journal: Nature communications
In common: NetworkX, OpenCV, scikit-image, 5 other tools, histology / microscopy, 1 reference
[7] doi:10.1016/j.stemcr.2026.103015 [code]
Brain injury reactivates a developmental program driving genesis and integration of transient LGE-class interneurons.
Journal: Stem cell reports
In common: ImageJ / Fiji, NetworkX, OpenCV, 4 other tools, 1 reference
[8] doi:10.1038/s41598-026-57519-w [code]
Automated segmentation of neurons and spinal cord structures in immunofluorescence images using SpineDL.
Journal: Scientific reports
In common: NetworkX, OpenCV, scikit-image, 5 other tools, histology / microscopy, methods / tools
[9] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: NetworkX, OpenCV, scikit-image, 5 other tools, methods / tools
[10] doi:10.1371/journal.pcbi.1013441 [code]
Large vision model framework for automated C. elegans analysis: From static morphometry to dynamic neural activity.
Journal: PLoS computational biology
In common: NetworkX, OpenCV, scikit-image, 5 other tools, methods / tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.