def dog_detection(overlay,img, imp, cal):
# Create a variable of the correct type (UnsignedByteType) for the value-extended view
zero = img.randomAccess().get().createVariable()
# Run the difference of Gaussian
cell = 8.0 # microns in diameter
min_peak = 2.0 # min intensity for a peak to be considered
dog = DogDetection(Views.extendValue(img, zero), img,
[cal.pixelWidth, cal.pixelHeight,cal.pixelDepth],
cell / 2, cell,
DogDetection.ExtremaType.MINIMA,
min_peak, False,
DoubleType())
peaks = dog.getPeaks()
roi = OvalRoi(0, 0, cell/cal.pixelWidth, cell/cal.pixelHeight)
print ('Number of cells = ', len(peaks))
p = zeros(img.numDimensions(), 'i')
boundRect = imp.getRoi()
for peak in peaks:
# Read peak coordinates into an array of integers XYZ location of spots
peak.localize(p)
print(p)
if(boundRect is not None and boundRect.contains(p[0], p[1])):
oval = OvalRoi(p[0], p[1],cell/cal.pixelWidth, cell/cal.pixelHeight)
oval.setColor(Color.RED)
overlay.add(oval)
def createDoG(img, calibration, sigmaSmaller, sigmaLarger, minPeakValue):
# Fixed parameters
extremaType = DogDetection.ExtremaType.MAXIMA
normalizedMinPeakValue = False
# Infinite img
imgE = Views.extendMirrorSingle(img)
# In the differece of gaussian peak detection, the img acts as the interval
# within which to look for peaks. The processing is done on the infinite imgE.
return DogDetection(imgE, img, calibration, sigmaLarger, sigmaSmaller,
extremaType, minPeakValue, normalizedMinPeakValue)
def find_peaks(imp1, imp2, sigmaSmaller, sigmaLarger, minPeakValue): # FIND PEAKS # sigmaSmaller ==> Size of the smaller dots (in pixels) # sigmaLarger ==> Size of the bigger dots (in pixels) # minPeakValue ==> Intensity above which to look for dots # Preparation Neuron channel ip1_1 = IL.wrapReal(imp1) ip1E = Views.extendMirrorSingle(ip1_1) imp1.show() #Preparation Glioma channel ip2_1 = IL.wrapReal(imp2) ip2E = Views.extendMirrorSingle(ip2_1) imp2.show() calibration = [1.0 for i in range(ip1_1.numDimensions())] extremaType = DogDetection.ExtremaType.MINIMA normalizedMinPeakValue = False dog_1 = DogDetection(ip1E, ip1_1, calibration, sigmaSmaller, sigmaLarger, extremaType, minPeakValue, normalizedMinPeakValue) dog_2 = DogDetection(ip2E, ip2_1, calibration, sigmaSmaller, sigmaLarger, extremaType, minPeakValue, normalizedMinPeakValue) peaks_1 = dog_1.getPeaks() peaks_2 = dog_2.getPeaks() return ip1_1, ip2_1, peaks_1, peaks_2
# View as an infinite image, mirrored at the edges which is ideal for Gaussians
imgE = Views.extendMirrorSingle(img)
# Parameters for a Difference of Gaussian to detect embryo positions
calibration = [1.0
for i in range(img.numDimensions())] # no calibration: identity
sigmaSmaller = 15 # in pixels: a quarter of the radius of an embryo
sigmaLarger = 30 # pixels: half the radius of an embryo
extremaType = DogDetection.ExtremaType.MAXIMA
minPeakValue = 10
normalizedMinPeakValue = False
# In the differece of gaussian peak detection, the img acts as the interval
# within which to look for peaks. The processing is done on the infinite imgE.
dog = DogDetection(imgE, img, calibration, sigmaSmaller, sigmaLarger,
extremaType, minPeakValue, normalizedMinPeakValue)
peaks = dog.getPeaks()
# Create a PointRoi from the DoG peaks, for visualization
roi = PointRoi(0, 0)
# A temporary array of integers, one per dimension the image has
p = zeros(img.numDimensions(), 'i')
# Load every peak as a point in the PointRoi
for peak in peaks:
# Read peak coordinates into an array of integers
peak.localize(p)
roi.addPoint(imp, p[0], p[1])
imp.setRoi(roi)
cal = imp.getCalibration() # in microns
img = IJF.wrap(imp)
print(img.dimensions)
# Create a variable of the correct type (UnsignedByteType) for the value-extended view
zero = img.randomAccess().get().createVariable()
# Run the difference of Gaussian
cell = 30.0 # microns in diameter
min_peak = 10.0 # min intensity for a peak to be considered
dog = DogDetection(
Views.extendValue(img, zero),
img,
[cal.pixelWidth, cal.pixelHeight],
cell / 2,
cell,
DogDetection.ExtremaType.MAXIMA, #MAXIMA
min_peak,
False,
DoubleType())
peaks = dog.getPeaks()
roi = OvalRoi(0, 0, cell / cal.pixelWidth, cell / cal.pixelHeight)
print('Number of cells = ', len(peaks))
p = zeros(img.numDimensions(), 'i')
overlay = Overlay()
imp.setOverlay(overlay)
for peak in peaks:
# Read peak coordinates into an array of integers
peak.localize(p)
if (boundRect.contains(p[0], p[1])):
# View as an infinite image, mirrored at the edges which is ideal for Gaussians
imgE = Views.extendMirrorSingle(img)
# Parameters for a Difference of Gaussian to detect embryo positions
calibration = [1.0
for i in range(img.numDimensions())] # no calibration: identity
sigmaSmaller = 15 # in pixels: a quarter of the radius of an embryo
sigmaLarger = 30 # pixels: half the radius of an embryo
extremaType = DogDetection.ExtremaType.MAXIMA
minPeakValue = 10
normalizedMinPeakValue = False
# In the differece of gaussian peak detection, the img acts as the interval
# within which to look for peaks. The processing is done on the infinite imgE.
dog = DogDetection(imgE, img, calibration, sigmaSmaller, sigmaLarger,
extremaType, minPeakValue, normalizedMinPeakValue)
peaks = dog.getPeaks()
# Create a PointRoi from the DoG peaks, for visualization
roi = PointRoi(0, 0)
# A temporary array of integers, one per dimension the image has
p = zeros(img.numDimensions(), 'i')
# Load every peak as a point in the PointRoi
for peak in peaks:
# Read peak coordinates into an array of integers
peak.localize(p)
roi.addPoint(imp, p[0], p[1])
imp.setRoi(roi)
from ij import IJ
from net.imglib2.view import Views
from net.imglib2.algorithm.dog import DogDetection
from net.imglib2 import KDTree, RealPoint, RealRandomAccess, RealRandomAccessible
from net.imglib2.neighborsearch import NearestNeighborSearchOnKDTree
from net.imglib2.img.display.imagej import ImageJFunctions as IL
from net.imglib2.type.numeric.integer import UnsignedByteType
from java.util import AbstractList
# The difference of Gaussian calculation, same as above (compressed)
# (or, paste this script under the script above where 'dog' is defined)
imp = IJ.openImage("https://imagej.nih.gov/ij/images/embryos.jpg")
IJ.run(imp, "8-bit", "")
img = IL.wrapReal(imp)
imgE = Views.extendMirrorSingle(img)
dog = DogDetection(imgE, img, [1.0, 1.0], 15.0, 30.0,
DogDetection.ExtremaType.MAXIMA, 10, False)
# The spatial coordinates for the centers of all detected embryos
centers = dog.getSubpixelPeaks() # in floating-point precision
# A value for the inside of an embryo: white, in 8-bit
inside = UnsignedByteType(255)
# A value for the outside (the background): black, in 8-bit
outside = UnsignedByteType(0)
# The radius of a simulated embryo, same as sigmaLarger was above
radius = 30 # or = sigmaLarger
# KDTree: a data structure for fast spatial look up
kdtree = KDTree([inside] * len(centers), centers)
# A script to find cells by difference of Gaussian using imglib2.
# Uses as an example the "first-instar-brain.tif" RGB stack availalable
# from Fiji's "Open Samples" menu.
from net.imglib2.algorithm.dog import DogDetection
from net.imglib2.type.numeric.real import DoubleType
# Extract the red channel
interval = ops.run("create.img", [img.dimension(0), img.dimension(1), 1, img.dimension(3)], img.firstElement(), img.factory())
red = ops.run("transform.crop", img, interval)
# Create a variable of the correct type (UnsignedByteType) for the value-extended view
extended = ops.run("transform.extendZeroView", red)
# Run the difference of Gaussian
cell = 5.0 # microns in diameter
min_peak = 40.0 # min intensity for a peak to be considered
dog = DogDetection(extended, red,
[img.averageScale(0), img.averageScale(1), img.averageScale(3)],
cell / 2, cell,
DogDetection.ExtremaType.MINIMA,
min_peak, False,
DoubleType())
peaks = dog.getPeaks()
print len(peaks)
print peaks