def supOpen(imIn, imOut, n, grid=mamba.DEFAULT_GRID):
"""
Performs the supremum of directional openings. A white particle is preserved
(but not entirely) if its length is larger than 'n' in at least one direction.
This operator is an opening. The image edge is set to 'EMPTY' in order to
take into account particles touching the edge (they are considered as entirely
included in the image window).
When square grid is used, the size in oblique directions are reduced to be
similar to the horizontal and vertical size.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk1.reset()
if grid == mamba.SQUARE:
size = int((1.4142 * n + 1)/2)
linearOpen(imIn, imWrk2, 2, size, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
linearOpen(imIn, imWrk2, 4, size, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
d = 4
else:
d = 6
for i in range(1, d, 2):
linearOpen(imIn, imWrk2, i, n, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
mamba.copy(imWrk1, imOut)
def largeHexagonalErode(imIn, imOut, size, edge=mamba.FILLED):
"""
Erosion by large hexagons using erosions by large segments and the Steiner
decomposition property of the hexagon.
Edge effects are corrected by erosions with transposed decompositions
combined with inf operations (see documentation for further details).
This operator is quite complex to avoid edge effects.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
sizemax = min(imIn.getSize()) // 2
# If size larger than sizemax, the operation must be iterated to prevent edge effects.
n = size
mamba.copy(imIn, imOut)
while n > 0:
s = min(n, sizemax)
largeLinearErode(imOut, imWrk1, 6, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk1, imWrk1, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imWrk2, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk2, imWrk2, 6, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
largeLinearErode(imWrk1, imWrk2, 2, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imWrk1, 1, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk1, imWrk1, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imOut, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imOut, 1, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imOut, imWrk1, "inf")
largeLinearErode(imWrk1, imOut, 5, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "inf")
n = n - s
def infClose(imIn, imOut, n, grid=mamba.DEFAULT_GRID):
"""
Performs the infimum of directional closings. A black particle is preserved
if its length is larger than 'n' in at least one direction.
This operator is a closing. The image edge is set to 'FILLED' in order to
take into account particles touching the edge (they are supposed not to
extend outside the image window).
When square grid is used, the size in oblique directions are reduced to be
similar to the horizontal and vertical size.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk1.fill(mamba.computeMaxRange(imIn)[1])
if grid == mamba.SQUARE:
size = int((1.4142 * n + 1)/2)
linearClose(imIn, imWrk2, 2, size, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
linearClose(imIn, imWrk2, 4, size, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
d = 4
else:
d = 6
for i in range(1, d, 2):
linearClose(imIn, imWrk2, i, n, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
mamba.copy(imWrk1, imOut)
def initAcquisition(self):
# At the beginning, the thread creates the acquisition device and extracts
# specific information. This allow to create the mamba images and
# sequences.
err,w,h = core.MBRT_GetAcqSize()
if err!=core.MBRT_NO_ERR:
self.error = core.MBRT_StrErr(err)
self.mustStop = True
return (0,0)
err, freq = core.MBRT_GetAcqFrameRate()
if err!=core.MBRT_NO_ERR:
self.error = core.MBRT_StrErr(err)
self.mustStop = True
return (0,0)
self.frequency = freq
self.period = 1.0/self.frequency
core.MBRT_StartAcq()
self.red = mamba.imageMb(w,h)
self.green = mamba.imageMb(w,h)
self.blue = mamba.imageMb(w,h)
self.redSeq = mamba3D.sequenceMb(w,h,self.seqDepth)
self.greenSeq = mamba3D.sequenceMb(w,h,self.seqDepth)
self.blueSeq = mamba3D.sequenceMb(w,h,self.seqDepth)
self.seqIndex = 0
return self.red.getSize()
def hierarchicalLevel(imIn, imOut, grid=mamba.DEFAULT_GRID):
"""
Computes the next hierarchical level of image 'imIn' in the
waterfalls transformation and puts the result in 'imOut'.
This operation makes sure that the next hierarchical level is embedded
in the previous one.
'imIn' must be a valued watershed image.
"""
imWrk0 = mamba.imageMb(imIn)
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn, 1)
imWrk3 = mamba.imageMb(imIn, 1)
imWrk4 = mamba.imageMb(imIn, 32)
mamba.threshold(imIn, imWrk1, 0, 0)
mamba.negate(imWrk1, imWrk2)
hierarchy(imIn, imWrk2, imWrk0, grid=grid)
mamba.minima(imWrk0, imWrk2, grid=grid)
mamba.label(imWrk2, imWrk4, grid=grid)
mamba.watershedSegment(imWrk0, imWrk4, grid=grid)
mamba.copyBytePlane(imWrk4, 3, imWrk0)
mamba.threshold(imWrk0, imWrk2, 0, 0)
mamba.diff(imWrk1, imWrk2, imWrk3)
mamba.build(imWrk1, imWrk3)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
mamba.dilate(imWrk3, imWrk1, 1, se)
mamba.diff(imWrk2, imWrk1, imWrk1)
mamba.logic(imWrk1, imWrk3, imWrk1, "sup")
mamba.convertByMask(imWrk1, imWrk0, 255, 0)
mamba.logic(imIn, imWrk0, imOut, "inf")
def partitionLabel(imIn, imOut):
"""
This procedure labels each cell of image 'imIn' and puts the result in
'imOut'. The number of cells is returned. 'imIn' can be a 1-bit, 8-bit or a
32-bit image. 'imOut' is a 32-bit image. When 'imIn' is a binary image, all the
connected components of the background are also labelled. When 'imIn' is a grey
image, the 0-valued cells are also labelled (which is not the case with the label
operator.
Warning! The label values of adjacent cells are not necessarily consecutive.
"""
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn, 32)
if imIn.getDepth() == 1:
mamba.negate(imIn, imWrk1)
else:
mamba.threshold(imIn, imWrk1, 0, 0)
nb1 = mamba.label(imWrk1, imWrk2)
mamba.convertByMask(imWrk1, imOut, mamba.computeMaxRange(imOut)[1], 0)
mamba.logic(imOut, imWrk2, imOut, "sup")
nb2 = mamba.label(imIn, imWrk2)
mamba.addConst(imWrk2, nb1, imWrk2)
mamba.logic(imOut, imWrk2, imOut, "inf")
return nb1 + nb2
def endPoints(imIn, imOut, grid=mamba.DEFAULT_GRID, edge=mamba.FILLED):
"""
Extracts end points in 'imIn', supposed to be a "skeleton" image (connected
components without thickness), and puts them in 'imOut'.
'edge' is FILLED by default and it can be modified to take into account
extremities touching the edge.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
if grid == mamba.HEXAGONAL:
dse1 = hexagonalE
dse2 = hexagonalL
nb = 6
step = 1
else:
dse1 = squareE
dse2 = squareL
nb = 4
step = 2
rotatingThin(imIn, imWrk1, dse2, edge=edge)
# added to avoid blocking of the process in clipping
mamba.diff(imIn, imWrk1, imOut)
for i in range(nb):
hitOrMiss(imWrk1, imWrk2, dse1, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "sup")
dse1 = dse1.rotate(step)
def conjugateDirectionalErode(imIn,
imOut,
d,
size,
grid=mamba.DEFAULT_GRID,
edge=mamba.FILLED):
"""
Performs the erosion of image 'imIn' in the conjugate direction 'd' of the
grid and puts the result in image 'imOut'. The images can be binary, greyscale
or 32-bit images. 'size' is a multiple of the distance between two adjacent
points in the conjugate directions. 'edge' is set to FILLED by default (can
be changed).
Note that this operator is not equivalent to successive erosions by a doublet
of points.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
j3 = mamba.transposeDirection(d, grid=grid)
j2 = mamba.rotateDirection(d, grid=grid)
j1 = mamba.transposeDirection(j2, grid=grid)
val = mamba.computeMaxRange(imIn)[1] * int(edge == mamba.FILLED)
for i in range(size):
mamba.copy(imOut, imWrk1)
mamba.copy(imOut, imWrk2)
mamba.linearErode(imWrk1, imWrk1, d, n=1, grid=grid, edge=edge)
mamba.shift(imWrk1, imWrk1, j1, 1, val, grid=grid)
mamba.logic(imWrk1, imOut, imWrk1, "inf")
mamba.linearErode(imWrk2, imWrk2, j2, n=1, grid=grid, edge=edge)
mamba.shift(imWrk2, imWrk2, j3, 1, val, grid=grid)
mamba.logic(imWrk2, imOut, imWrk2, "inf")
mamba.logic(imWrk1, imWrk2, imOut, "sup")
def mosaic(imIn, imOut, imWts, grid=mamba.DEFAULT_GRID):
"""
Builds the mosaic image of 'imIn' and puts the results into 'imOut'.
The watershed line (pixel values set to 255) is stored in the
greytone image 'imWts'. A mosaic image is a simple image made of various
tiles of uniform grey values. It is built using the watershed of 'imIn'
gradient and original markers made of gradient minima which are labelled by
the maximum value of 'imIn' pixels inside them.
"""
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imWrk2)
im_mark = mamba.imageMb(imIn, 32)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
mamba.gradient(imIn, imOut, se=se)
mamba.minima(imOut, imWrk1, grid=grid)
mamba.add(im_mark, imWrk1, im_mark)
imWrk1.convert(8)
mamba.build(imWrk1, imWrk2, grid=grid)
mamba.add(im_mark, imWrk2, im_mark)
watershedSegment(imOut, im_mark, grid=grid)
mamba.copyBytePlane(im_mark, 3, imWts)
mamba.subConst(im_mark, 1, im_mark)
mamba.copyBytePlane(im_mark, 0, imOut)
def conjugateDirectionalErode(imIn, imOut, d, size, grid=mamba.DEFAULT_GRID, edge=mamba.FILLED):
"""
Performs the erosion of image 'imIn' in the conjugate direction 'd' of the
grid and puts the result in image 'imOut'. The images can be binary, greyscale
or 32-bit images. 'size' is a multiple of the distance between two adjacent
points in the conjugate directions. 'edge' is set to FILLED by default (can
be changed).
Note that this operator is not equivalent to successive erosions by a doublet
of points.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
j3 = mamba.transposeDirection(d, grid=grid)
j2 = mamba.rotateDirection(d, grid=grid)
j1 = mamba.transposeDirection(j2, grid=grid)
val = mamba.computeMaxRange(imIn)[1] * int(edge == mamba.FILLED)
for i in range(size):
mamba.copy(imOut, imWrk1)
mamba.copy(imOut, imWrk2)
mamba.linearErode(imWrk1, imWrk1, d, n=1, grid=grid, edge=edge)
mamba.shift(imWrk1, imWrk1, j1, 1, val, grid=grid)
mamba.logic(imWrk1, imOut, imWrk1, "inf")
mamba.linearErode(imWrk2, imWrk2, j2, n=1, grid=grid, edge=edge)
mamba.shift(imWrk2, imWrk2, j3, 1, val, grid=grid)
mamba.logic(imWrk2, imOut, imWrk2, "inf")
mamba.logic(imWrk1, imWrk2, imOut, "sup")
def conjugateDirectionalDilate(imIn, imOut, d, size, grid=mamba.DEFAULT_GRID, edge=mamba.EMPTY):
"""
Performs the dilation of image 'imIn' in the conjugate direction 'd' of the
grid and puts the result in image 'imOut'. The images can be binary, greyscale
or 32-bit images. 'size' is a multiple of the distance between two adjacent
points in the conjugate directions. 'edge' is set to EMPTY by default (can
be changed).
Note that the linear structuring element is not connected. Points connecting
adjacent points in the conjugate directions are not present. This is normal
if we want to insure that the result is identical when we iterate n size 1
operations to get a size n one (the same remark applies to the erosion).
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
j3 = mamba.transposeDirection(d, grid=grid)
j2 = mamba.rotateDirection(d, grid=grid)
j1 = mamba.transposeDirection(j2, grid=grid)
val = mamba.computeMaxRange(imIn)[1] * int(edge == mamba.FILLED)
for i in range(size):
mamba.copy(imOut, imWrk1)
mamba.copy(imOut, imWrk2)
mamba.linearDilate(imWrk1, imWrk1, d, 1, grid=grid, edge=edge)
mamba.shift(imWrk1, imWrk1, j1, 1, val, grid=grid)
mamba.logic(imWrk1, imOut, imWrk1, "sup")
mamba.linearDilate(imWrk2, imWrk2, j2, 1, grid=grid, edge=edge)
mamba.shift(imWrk2, imWrk2, j3, 1, val, grid=grid)
mamba.logic(imWrk2, imOut, imWrk2, "sup")
mamba.logic(imWrk1, imWrk2, imOut, "inf")
def conjugateDirectionalDilate(imIn, imOut, d, size, grid=mamba.DEFAULT_GRID, edge=mamba.EMPTY):
"""
Performs the dilation of image 'imIn' in the conjugate direction 'd' of the
grid and puts the result in image 'imOut'. The images can be binary, greyscale
or 32-bit images. 'size' is a multiple of the distance between two adjacent
points in the conjugate directions. 'edge' is set to EMPTY by default (can
be changed).
Note that the linear structuring element is not connected. Points connecting
adjacent points in the conjugate directions are not present. This is normal
if we want to insure that the result is identical when we iterate n size 1
operations to get a size n one (the same remark applies to the erosion).
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
j3 = mamba.transposeDirection(d, grid=grid)
j2 = mamba.rotateDirection(d, grid=grid)
j1 = mamba.transposeDirection(j2, grid=grid)
val = mamba.computeMaxRange(imIn)[1] * int(edge == mamba.FILLED)
for i in range(size):
mamba.copy(imOut, imWrk1)
mamba.copy(imOut, imWrk2)
mamba.linearDilate(imWrk1, imWrk1, d, 1, grid=grid, edge=edge)
mamba.shift(imWrk1, imWrk1, j1, 1, val, grid=grid)
mamba.logic(imWrk1, imOut, imWrk1, "sup")
mamba.linearDilate(imWrk2, imWrk2, j2, 1, grid=grid, edge=edge)
mamba.shift(imWrk2, imWrk2, j3, 1, val, grid=grid)
mamba.logic(imWrk2, imOut, imWrk2, "sup")
mamba.logic(imWrk1, imWrk2, imOut, "inf")
def vectorGradient(imIn, imModul, imAzim, size=1):
"""
Computes modulus (result in 'imModul') and azimut (in 'imAzim') of image
'imIn'. The 'size' of each directional gradient is set to 1 by default.
This operator is defined on the hexagonal grid (12 directions are used).
Note that this operator belongs to the residual operators class.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn)
imWrk4 = mamba.imageMb(imIn, 1)
mamba.copy(imIn, imWrk1)
imModul.reset()
imAzim.reset()
for i in range(12):
d = i + 1
# Directional gradient obtained with linear erosions and dilations.
directionalDilate(imWrk1, imWrk2, d, size)
directionalErode(imWrk1, imWrk3, d, size)
mamba.sub(imWrk2, imWrk3, imWrk2)
# For each direction, maximal pixels are indexed in a mask image.
mamba.generateSupMask(imWrk2, imModul, imWrk4, True)
mamba.convertByMask(imWrk4, imWrk3, 0, d)
# Modulus and azimut are calculated.
mamba.logic(imWrk2, imModul, imModul, "sup")
mamba.logic(imWrk3, imAzim, imAzim, "sup")
def vectorGradient(imIn, imModul, imAzim, size=1):
"""
Computes modulus (result in 'imModul') and azimut (in 'imAzim') of image
'imIn'. The 'size' of each directional gradient is set to 1 by default.
This operator is defined on the hexagonal grid (12 directions are used).
Note that this operator belongs to the residual operators class.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn)
imWrk4 = mamba.imageMb(imIn, 1)
mamba.copy(imIn, imWrk1)
imModul.reset()
imAzim.reset()
for i in range(12):
d = i + 1
# Directional gradient obtained with linear erosions and dilations.
directionalDilate(imWrk1, imWrk2, d, size)
directionalErode(imWrk1, imWrk3, d, size)
mamba.sub(imWrk2, imWrk3, imWrk2)
# For each direction, maximal pixels are indexed in a mask image.
mamba.generateSupMask(imWrk2, imModul, imWrk4, True)
mamba.convertByMask(imWrk4, imWrk3, 0, d)
# Modulus and azimut are calculated.
mamba.logic(imWrk2, imModul, imModul, "sup")
mamba.logic(imWrk3, imAzim, imAzim, "sup")
def partitionLabel(imIn, imOut):
"""
This procedure labels each cell of image 'imIn' and puts the result in
'imOut'. The number of cells is returned. 'imIn' can be a 1-bit, 8-bit or a
32-bit image. 'imOut' is a 32-bit image. When 'imIn' is a binary image, all the
connected components of the background are also labelled. When 'imIn' is a grey
image, the 0-valued cells are also labelled (which is not the case with the label
operator.
Warning! The label values of adjacent cells are not necessarily consecutive.
"""
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn, 32)
if imIn.getDepth() == 1:
mamba.negate(imIn, imWrk1)
else:
mamba.threshold(imIn, imWrk1, 0, 0)
nb1 = mamba.label(imWrk1, imWrk2)
mamba.convertByMask(imWrk1, imOut, mamba.computeMaxRange(imOut)[1], 0)
mamba.logic(imOut, imWrk2, imOut, "sup")
nb2 = mamba.label(imIn, imWrk2)
mamba.addConst(imWrk2, nb1, imWrk2)
mamba.logic(imOut, imWrk2, imOut, "inf")
return nb1 + nb2
def _initialQuasiDist_(imIn, imOut1, imOut2, grid=mamba.DEFAULT_GRID):
"""
Computes the initial quasi-distance. For internal use only. The resulting
quasi-distance is not lipchitzian (see MM documentation for details).
"""
maskIm = mamba.imageMb(imIn, 1)
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn, 32)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
i = 0
mamba.copy(imIn, imWrk1)
v2 = mamba.computeVolume(imWrk1)
v1 = v2 + 1
imOut1.reset()
imOut2.reset()
while v1 > v2:
i += 1
v1 = v2
mamba.erode(imWrk1, imWrk2, se=se)
mamba.sub(imWrk1, imWrk2, imWrk1)
_generateMask_(imWrk1, imOut1, maskIm)
mamba.convertByMask(maskIm, imWrk3, 0, i)
mamba.logic(imOut1, imWrk1, imOut1, "sup")
mamba.logic(imOut2, imWrk3, imOut2, "sup")
mamba.copy(imWrk2, imWrk1)
v2 = mamba.computeVolume(imWrk1)
def upperGeodesicDilate(imIn, imMask, imOut, n=1, se=mamba.DEFAULT_SE):
"""
Performs an upper geodesic dilation of image 'imIn' above 'imMask'.
The result is put inside 'imOut', 'n' controls the size of the dilation.
'se' specifies the type of structuring element used to perform the
computation (DEFAULT_SE by default).
Warning! 'imMask' and 'imOut' must be different.
"""
mamba.logic(imIn, imMask, imOut, "sup")
if imIn.getDepth() == 1:
for i in range(n):
mamba.diff(imOut, imMask, imOut)
mamba.dilate(imOut, imOut, se=se)
mamba.logic(imMask, imOut, imOut, "sup")
else:
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn, 1)
for i in range(n):
mamba.generateSupMask(imOut, imMask, imWrk2, True)
mamba.convertByMask(imWrk2, imWrk1, 0, mamba.computeMaxRange(imWrk1)[1])
mamba.logic(imOut, imWrk1, imOut, "inf")
mamba.dilate(imOut, imOut, se=se)
mamba.logic(imOut, imMask, imOut, "sup")
def largeHexagonalErode(imIn, imOut, size, edge=mamba.FILLED):
"""
Erosion by large hexagons using erosions by large segments and the Steiner
decomposition property of the hexagon.
Edge effects are corrected by erosions with transposed decompositions
combined with inf operations (see documentation for further details).
This operator is quite complex to avoid edge effects.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
sizemax = min(imIn.getSize())//2
# If size larger than sizemax, the operation must be iterated to prevent edge effects.
n = size
mamba.copy(imIn, imOut)
while n > 0:
s = min(n, sizemax)
largeLinearErode(imOut, imWrk1, 6, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk1, imWrk1, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imWrk2, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk2, imWrk2, 6, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
largeLinearErode(imWrk1, imWrk2, 2, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imWrk1, 1, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imWrk1, imWrk1, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imOut, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearErode(imOut, imOut, 1, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imOut, imWrk1, "inf")
largeLinearErode(imWrk1, imOut, 5, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "inf")
n = n - s
def mulRealConst(imIn, v, imOut, nearest=False, precision=2):
"""
Multiplies image 'imIn' by a real positive constant value 'v' and puts the
result in image 'imOut'. 'imIn' and 'imOut' can be 8-bit or 32-bit images.
If 'imOut' is greyscale (8-bit), the result is saturated (results
of the multiplication greater than 255 are limited to this value).
'precision' indicates the number of decimal digits taken into account for
the constant 'v' (default is 2).
If 'nearest' is true, the result is rounded to the nearest integer value.
If not (default), the result is simply truncated.
"""
if imIn.getDepth()==1 or imOut.getDepth()==1:
mamba.raiseExceptionOnError(core.MB_ERR_BAD_DEPTH)
imWrk1 = mamba.imageMb(imIn, 32)
imWrk2 = mamba.imageMb(imIn, 1)
precVal = (10 ** precision)
v1 = int(v * precVal)
if imIn.getDepth()==8:
imWrk1.reset()
mamba.copyBytePlane(imIn, 0, imWrk1)
else:
mamba.copy(imIn, imWrk1)
mulConst(imWrk1, v1, imWrk1)
if nearest:
adjVal = int(5 * (10 ** (precision - 1)))
addConst(imWrk1, adjVal , imWrk1)
divConst(imWrk1, precVal, imWrk1)
if imOut.getDepth()==8:
mamba.threshold(imWrk1, imWrk2, 255, mamba.computeMaxRange(imWrk1)[1])
mamba.copyBytePlane(imWrk1, 0, imOut)
imWrk2.convert(8)
mamba.logic(imOut, imWrk2, imOut, "sup")
else:
mamba.copy(imWrk1, imOut)
def hierarchicalLevel(imIn, imOut, grid=mamba.DEFAULT_GRID):
"""
Computes the next hierarchical level of image 'imIn' in the
waterfalls transformation and puts the result in 'imOut'.
This operation makes sure that the next hierarchical level is embedded
in the previous one.
'imIn' must be a valued watershed image.
"""
imWrk0 = mamba.imageMb(imIn)
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn, 1)
imWrk3 = mamba.imageMb(imIn, 1)
imWrk4 = mamba.imageMb(imIn, 32)
mamba.threshold(imIn,imWrk1, 0, 0)
mamba.negate(imWrk1, imWrk2)
hierarchy(imIn, imWrk2, imWrk0, grid=grid)
mamba.minima(imWrk0, imWrk2, grid=grid)
mamba.label(imWrk2, imWrk4, grid=grid)
mamba.watershedSegment(imWrk0, imWrk4, grid=grid)
mamba.copyBytePlane(imWrk4, 3, imWrk0)
mamba.threshold(imWrk0, imWrk2, 0, 0)
mamba.diff(imWrk1, imWrk2, imWrk3)
mamba.build(imWrk1, imWrk3)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
mamba.dilate(imWrk3, imWrk1, 1, se)
mamba.diff(imWrk2, imWrk1, imWrk1)
mamba.logic(imWrk1, imWrk3, imWrk1, "sup")
mamba.convertByMask(imWrk1, imWrk0, 255, 0)
mamba.logic(imIn, imWrk0, imOut, "inf")
def nonEqualNeighbors(imIn, imOut, nb, grid=mamba.DEFAULT_GRID, edge=mamba.FILLED):
"""
This operator compares the value of each pixel of image 'imIn'
with the value of its neighbors encoded in 'nb'.
If all the neighbor values are different, the pixel is unchanged.
Otherwise, it takes value 0.
This operator works on hexagonal or square 'grid' and
'edge' is set to FILLED by default.
This operator works for 8-bit and 32-bit images.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn, 1)
imWrk4 = mamba.imageMb(imIn, 1)
for d in mamba.getDirections(grid):
ed = 1<<d
if (nb & ed):
mamba.copy(imIn, imWrk1)
mamba.copy(imIn, imWrk2)
mamba.supNeighbor(imWrk1, imWrk1, ed, grid=grid, edge=edge)
mamba.infNeighbor(imWrk2, imWrk2, ed, grid=grid, edge=edge)
mamba.generateSupMask(imWrk2, imWrk1, imWrk3, False)
mamba.logic(imWrk4, imWrk3, imWrk4, "or")
mamba.convertByMask(imWrk4, imWrk1, mamba.computeMaxRange(imIn)[1], 0)
mamba.logic(imIn, imWrk1, imOut, "inf")
def cellsBuild(imIn, imInOut, grid=mamba.DEFAULT_GRID):
"""
Geodesic reconstruction of the cells of the partition image 'imIn' which
are marked by the image 'imInOut'. The marked cells take the value of
their corresponding marker. Note that the background cells (labelled by 0)
are also modified if they are marked.
The result is stored in 'imInOut'.
The images can be 8-bit or 32-bit images.
'grid' can be set to HEXAGONAL or SQUARE.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn, 1)
vol = 0
prec_vol = -1
dirs = mamba.getDirections(grid)[1:]
while (prec_vol != vol):
prec_vol = vol
for d in dirs:
ed = 1 << d
mamba.copy(imIn, imWrk1)
mamba.copy(imIn, imWrk2)
mamba.supNeighbor(imWrk1, imWrk1, ed, grid=grid)
mamba.infNeighbor(imWrk2, imWrk2, ed, grid=grid)
mamba.generateSupMask(imWrk2, imWrk1, imWrk3, False)
mamba.convertByMask(imWrk3, imWrk1, 0,
mamba.computeMaxRange(imIn)[1])
mamba.linearDilate(imInOut, imWrk2, d, 1, grid=grid)
mamba.logic(imWrk2, imWrk1, imWrk2, "inf")
v = mamba.buildNeighbor(imWrk1, imWrk2, d, grid=grid)
mamba.logic(imWrk2, imInOut, imInOut, "sup")
vol = mamba.computeVolume(imInOut)
def initAcquisition(self):
# At the beginning, the thread creates the acquisition device and extracts
# specific information. This allow to create the mamba images and
# sequences.
err, w, h = core.MBRT_GetAcqSize()
if err != core.MBRT_NO_ERR:
self.error = core.MBRT_StrErr(err)
self.mustStop = True
return (0, 0)
err, freq = core.MBRT_GetAcqFrameRate()
if err != core.MBRT_NO_ERR:
self.error = core.MBRT_StrErr(err)
self.mustStop = True
return (0, 0)
self.frequency = freq
self.period = 1.0 / self.frequency
core.MBRT_StartAcq()
self.red = mamba.imageMb(w, h)
self.green = mamba.imageMb(w, h)
self.blue = mamba.imageMb(w, h)
self.redSeq = mamba3D.sequenceMb(w, h, self.seqDepth)
self.greenSeq = mamba3D.sequenceMb(w, h, self.seqDepth)
self.blueSeq = mamba3D.sequenceMb(w, h, self.seqDepth)
self.seqIndex = 0
return self.red.getSize()
def isotropicDistance(imIn, imOut, edge=mamba.FILLED):
"""
Computes the distance function of a set in 'imIn'. This distance function
uses dodecagonal erosions and the grid is assumed to be hexagonal.
The procedure is quite slow but the result is more aesthetic.
This operator also illustrates how to perform successive dodecagonal
operations of increasing sizes.
"""
if imIn.getDepth() != 1:
mamba.raiseExceptionOnError(core.MB_ERR_BAD_DEPTH)
imOut.reset()
oldn = 0
size = 0
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imWrk1)
while mamba.computeVolume(imWrk1) != 0:
mamba.add(imOut, imWrk1, imOut)
size += 1
n = int(0.4641 * size)
n += abs(n % 2 - size % 2)
if (n - oldn) == 1:
mamba.copy(imWrk1, imWrk2)
mamba.erode(imWrk1, imWrk1, 1, se=mamba.HEXAGON, edge=edge)
else:
mamba.conjugateHexagonalErode(imWrk2, imWrk1, 1, edge=edge)
oldn = n
def binaryUltimateErosion(imIn, imOut1, imOut2, grid=mamba.DEFAULT_GRID, edge=mamba.FILLED):
"""
Ultimate erosion of binary image 'imIn'. 'imOut1' contains the ultimate
eroded set and 'imOut2' contains the associated function (that is the
height of each connected component of the ultimate erosion).
An ultimate erosion is composed of the union of the last connected
components of the successive erosions of the initial set. The associated
function provides the size of the corresponding erosion.
Depth of 'imOut1' is 1, depth of 'imOut2' is 32.
The operation is fast because it is computed using the distance function
of 'imIn' (the ultimate erosion is identical to the maxima of this
distance function).
The edge is set to 'FILLED' by default.
"""
imWrk1 = mamba.imageMb(imIn, 32)
imWrk2 = mamba.imageMb(imIn, 32)
mamba.computeDistance(imIn, imWrk1, grid=grid, edge=edge)
mamba.maxima(imWrk1, imOut1, grid=grid)
mamba.convertByMask(imOut1, imWrk2, 0, mamba.computeMaxRange(imWrk2)[1])
mamba.logic(imWrk1, imWrk2, imOut2, "inf")
def endPoints(imIn, imOut, grid=mamba.DEFAULT_GRID, edge=mamba.FILLED):
"""
Extracts end points in 'imIn', supposed to be a "skeleton" image (connected
components without thickness), and puts them in 'imOut'.
'edge' is FILLED by default and it can be modified to take into account
extremities touching the edge.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
if grid == mamba.HEXAGONAL:
dse1 = hexagonalE
dse2 = hexagonalL
nb = 6
step = 1
else:
dse1 = squareE
dse2 = squareL
nb = 4
step = 2
rotatingThin(imIn, imWrk1, dse2, edge=edge)
# added to avoid blocking of the process in clipping
mamba.diff(imIn, imWrk1, imOut)
for i in range(nb):
hitOrMiss(imWrk1, imWrk2, dse1, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "sup")
dse1 = dse1.rotate(step)
def multiplePoints(imIn, imOut, grid=mamba.DEFAULT_GRID):
"""
Extracts multiple points in 'imIn', supposed to be a "skeleton" image (connected
components without thickness), and puts the result in 'imOut'.
Note that, on a square grid, the resulting skeleton is supposed to be defined
on a 4-connectivity grid. if it is not the case, some multiple points are likely
to be missed.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
endPoints(imIn, imWrk2)
if grid == mamba.HEXAGONAL:
dse_list = [hexagonalS1, hexagonalS2]
step = 1
nb = 6
else:
dse_list = [squareS1, squareS2]
step = 2
nb = 4
for dse in dse_list:
for i in range(nb):
hitOrMiss(imIn, imWrk1, dse)
mamba.logic(imWrk1, imWrk2, imWrk2, "sup")
dse = dse.rotate(step)
mamba.diff(imIn, imWrk2, imOut)
def largeHexagonalDilate(imIn, imOut, size, edge=mamba.EMPTY):
"""
Dilation by large hexagons using dilations by large segments and the Steiner
decomposition property of the hexagon.
Edge effects are corrected by dilations with transposed decompositions
combined with sup operators.
This operator is quite complex to avoid edge effects.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
sizemax = min(imIn.getSize())//2
# If size larger than sizemax, the operation must be iterated to prevent edge effects.
n = size
mamba.copy(imIn, imOut)
while n > 0:
s = min(n, sizemax)
largeLinearDilate(imOut, imWrk1, 6, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk1, imWrk1, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imOut, imWrk2, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk2, imWrk2, 6, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
largeLinearDilate(imWrk1, imWrk2, 2, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imOut, imWrk1, 1, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk1, imWrk1, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imOut, imOut, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imOut, imOut, 1, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imOut, imWrk1, "sup")
largeLinearDilate(imWrk1, imOut, 5, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "sup")
n = n - s
def _sparseConjugateHexagonDilate(imIn, imOut, size, edge=mamba.EMPTY):
"""
Dilation by a conjugate hexagon. The structuring element used by this operation
is not complete. Some holes appear inside the structuring element. Therefore, this
operation should not be used to obtain true conjugate hexagons dilations (for
internal use only).
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
val = mamba.computeMaxRange(imIn)[1]*int(edge!=mamba.EMPTY)
for i in _sizeSplit(size):
mamba.copy(imOut, imWrk1)
j = 2*i
supFarNeighbor(imWrk1, imOut, 1, j, grid=mamba.SQUARE, edge=edge)
mamba.shift(imWrk1, imWrk2, 2, i, val, grid=mamba.HEXAGONAL)
supFarNeighbor(imWrk2, imOut, 4, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk2, imOut, 6, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk1, imOut, 5, j, grid=mamba.SQUARE, edge=edge)
mamba.shift(imWrk1, imWrk2, 5, i, val, grid=mamba.HEXAGONAL)
supFarNeighbor(imWrk2, imOut, 1, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk2, imOut, 3, i, grid=mamba.HEXAGONAL, edge=edge)
j = 3*i//2
supFarNeighbor(imWrk1, imOut, 2, j, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk1, imOut, 5, j, grid=mamba.HEXAGONAL, edge=edge)
def mosaic(imIn, imOut, imWts, grid=mamba.DEFAULT_GRID):
"""
Builds the mosaic image of 'imIn' and puts the results into 'imOut'.
The watershed line (pixel values set to 255) is stored in the
greytone image 'imWts'. A mosaic image is a simple image made of various
tiles of uniform grey values. It is built using the watershed of 'imIn'
gradient and original markers made of gradient minima which are labelled by
the maximum value of 'imIn' pixels inside them.
"""
imWrk1 = mamba.imageMb(imIn, 1)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imWrk2)
im_mark = mamba.imageMb(imIn, 32)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
mamba.gradient(imIn, imOut, se=se)
mamba.minima(imOut, imWrk1, grid=grid)
mamba.add(im_mark, imWrk1, im_mark)
imWrk1.convert(8)
mamba.build(imWrk1, imWrk2, grid=grid)
mamba.add(im_mark, imWrk2, im_mark)
watershedSegment(imOut, im_mark, grid=grid)
mamba.copyBytePlane(im_mark, 3, imWts)
mamba.subConst(im_mark, 1, im_mark)
mamba.copyBytePlane(im_mark, 0, imOut)
def lowerGeodesicErode(imIn, imMask, imOut, n=1, se=mamba.DEFAULT_SE):
"""
Performs a lower geodesic erosion of image 'imIn' under 'imMask'.
The result is put inside 'imOut', 'n' controls the size of the erosion.
'se' specifies the type of structuring element used to perform the
computation (DEFAULT_SE by default).
The binary lower geodesic erosion is realised using the fact that the
dilation is the dual operation of the erosion.
Warning! 'imMask' and 'imOut' must be different.
"""
if imIn.getDepth() == 1:
mamba.diff(imMask, imIn, imOut)
lowerGeodesicDilate(imOut, imMask, imOut, n, se=se)
mamba.diff(imMask, imOut, imOut)
else:
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn, 1)
mamba.logic(imIn, imMask, imOut, "inf")
for i in range(n):
mamba.generateSupMask(imOut, imMask, imWrk2, False)
mamba.convertByMask(imWrk2, imWrk1, 0, mamba.computeMaxRange(imWrk1)[1])
mamba.logic(imOut, imWrk1, imOut, "sup")
mamba.erode(imOut, imOut, se=se)
mamba.logic(imOut, imMask, imOut, "inf")
def volumeLabelling(imIn1, imIn2, imOut):
"""
Each connected component of the binary image or the partition 'imIn1' is
labelled with the volume of the greyscale or 32-bit image 'imIn2' inside
this component. The result is put in the 32-bit image 'imOut'.
"""
imWrk1 = mamba.imageMb(imIn1, 1)
imWrk2 = mamba.imageMb(imIn1, 32)
imWrk3 = mamba.imageMb(imIn1, 8)
imOut.reset()
n = imIn2.getDepth()
# Case of a 8-bit image.
if n == 8:
for i in range(8):
# Each bit plane is extracted and used in the labelling.
mamba.copyBitPlane(imIn2, i, imWrk1)
measureLabelling(imIn1, imWrk1, imWrk2)
# The resulting labels are combined to obtain the final one.
v = 2**i
mamba.mulConst(imWrk2, v, imWrk2)
mamba.add(imOut, imWrk2, imOut)
else:
for j in range(4):
# Each byte plane is treated.
mamba.copyBytePlane(imIn2, j, imWrk3)
for i in range(8):
mamba.copyBitPlane(imWrk3, i, imWrk1)
measureLabelling(imIn1, imWrk1, imWrk2)
v = 2**(8 * j + i)
mamba.mulConst(imWrk2, v, imWrk2)
mamba.add(imOut, imWrk2, imOut)
def cellsHMT(imIn, imOut, dse, edge=mamba.EMPTY):
"""
A Hit-Or-Miss transform is performed on each cell of the partition 'imIn'.
'dse' is a double structuring element (see thinthick.py module).
The result is put in 'imOut'. 'edge' is set to EMPTY by default.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
grid = dse.getGrid()
cse0 = dse.getStructuringElement(0)
cse1 = dse.getStructuringElement(1)
mamba.copy(imIn, imOut)
mamba.copy(imIn, imWrk1)
equalNeighbors(imWrk1,
imWrk2,
cse1.getEncodedDirections(withoutZero=True),
grid=grid,
edge=edge)
mamba.logic(imOut, imWrk2, imOut, "inf")
nonEqualNeighbors(imWrk1,
imWrk2,
cse0.getEncodedDirections(withoutZero=True),
grid=grid,
edge=edge)
mamba.logic(imOut, imWrk2, imOut, "inf")
def multiplePoints(imIn, imOut, grid=mamba.DEFAULT_GRID):
"""
Extracts multiple points in 'imIn', supposed to be a "skeleton" image (connected
components without thickness), and puts the result in 'imOut'.
Note that, on a square grid, the resulting skeleton is supposed to be defined
on a 4-connectivity grid. if it is not the case, some multiple points are likely
to be missed.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
endPoints(imIn, imWrk2)
if grid == mamba.HEXAGONAL:
dse_list = [hexagonalS1, hexagonalS2]
step = 1
nb = 6
else:
dse_list = [squareS1, squareS2]
step = 2
nb = 4
for dse in dse_list:
for i in range(nb):
hitOrMiss(imIn, imWrk1, dse)
mamba.logic(imWrk1, imWrk2, imWrk2, "sup")
dse = dse.rotate(step)
mamba.diff(imIn, imWrk2, imOut)
def nonEqualNeighbors(imIn,
imOut,
nb,
grid=mamba.DEFAULT_GRID,
edge=mamba.FILLED):
"""
This operator compares the value of each pixel of image 'imIn'
with the value of its neighbors encoded in 'nb'.
If all the neighbor values are different, the pixel is unchanged.
Otherwise, it takes value 0.
This operator works on hexagonal or square 'grid' and
'edge' is set to FILLED by default.
This operator works for 8-bit and 32-bit images.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn, 1)
imWrk4 = mamba.imageMb(imIn, 1)
for d in mamba.getDirections(grid):
ed = 1 << d
if (nb & ed):
mamba.copy(imIn, imWrk1)
mamba.copy(imIn, imWrk2)
mamba.supNeighbor(imWrk1, imWrk1, ed, grid=grid, edge=edge)
mamba.infNeighbor(imWrk2, imWrk2, ed, grid=grid, edge=edge)
mamba.generateSupMask(imWrk2, imWrk1, imWrk3, False)
mamba.logic(imWrk4, imWrk3, imWrk4, "or")
mamba.convertByMask(imWrk4, imWrk1, mamba.computeMaxRange(imIn)[1], 0)
mamba.logic(imIn, imWrk1, imOut, "inf")
def supOpen(imIn, imOut, n, grid=mamba.DEFAULT_GRID):
"""
Performs the supremum of directional openings. A white particle is preserved
(but not entirely) if its length is larger than 'n' in at least one direction.
This operator is an opening. The image edge is set to 'EMPTY' in order to
take into account particles touching the edge (they are considered as entirely
included in the image window).
When square grid is used, the size in oblique directions are reduced to be
similar to the horizontal and vertical size.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk1.reset()
if grid == mamba.SQUARE:
size = int((1.4142 * n + 1) / 2)
linearOpen(imIn, imWrk2, 2, size, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
linearOpen(imIn, imWrk2, 4, size, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
d = 4
else:
d = 6
for i in range(1, d, 2):
linearOpen(imIn, imWrk2, i, n, edge=mamba.EMPTY, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
mamba.copy(imWrk1, imOut)
def cellsBuild(imIn, imInOut, grid=mamba.DEFAULT_GRID):
"""
Geodesic reconstruction of the cells of the partition image 'imIn' which
are marked by the image 'imInOut'. The marked cells take the value of
their corresponding marker. Note that the background cells (labelled by 0)
are also modified if they are marked.
The result is stored in 'imInOut'.
The images can be 8-bit or 32-bit images.
'grid' can be set to HEXAGONAL or SQUARE.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk3 = mamba.imageMb(imIn, 1)
vol = 0
prec_vol = -1
dirs = mamba.getDirections(grid)[1:]
while (prec_vol!=vol):
prec_vol = vol
for d in dirs:
ed = 1<<d
mamba.copy(imIn, imWrk1)
mamba.copy(imIn, imWrk2)
mamba.supNeighbor(imWrk1, imWrk1, ed, grid=grid)
mamba.infNeighbor(imWrk2, imWrk2, ed, grid=grid)
mamba.generateSupMask(imWrk2, imWrk1, imWrk3, False)
mamba.convertByMask(imWrk3, imWrk1, 0, mamba.computeMaxRange(imIn)[1])
mamba.linearDilate(imInOut, imWrk2, d, 1, grid=grid)
mamba.logic(imWrk2, imWrk1, imWrk2, "inf")
v = mamba.buildNeighbor(imWrk1, imWrk2, d, grid=grid)
mamba.logic(imWrk2, imInOut, imInOut, "sup")
vol = mamba.computeVolume(imInOut)
def infClose(imIn, imOut, n, grid=mamba.DEFAULT_GRID):
"""
Performs the infimum of directional closings. A black particle is preserved
if its length is larger than 'n' in at least one direction.
This operator is a closing. The image edge is set to 'FILLED' in order to
take into account particles touching the edge (they are supposed not to
extend outside the image window).
When square grid is used, the size in oblique directions are reduced to be
similar to the horizontal and vertical size.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
imWrk1.fill(mamba.computeMaxRange(imIn)[1])
if grid == mamba.SQUARE:
size = int((1.4142 * n + 1) / 2)
linearClose(imIn, imWrk2, 2, size, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
linearClose(imIn, imWrk2, 4, size, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
d = 4
else:
d = 6
for i in range(1, d, 2):
linearClose(imIn, imWrk2, i, n, grid=grid)
mamba.logic(imWrk1, imWrk2, imWrk1, "inf")
mamba.copy(imWrk1, imOut)
def quasiDistance(imIn, imOut1, imOut2, grid=mamba.DEFAULT_GRID):
"""
Quasi-distance of image 'imIn'. 'imOut1' contains the residues image
and 'imOut2' contains the quasi-distance (associated function).
The quasi-distance of a greytone image is made of a patch of distance
functions of some almost flat regions in the image. When the image is a
simple indicator function of a set, the quasi-distance and the distance
function are identical.
Depth of 'imOut1' is the same as 'imIn', depth of 'imOut2' is 32.
"""
imWrk1 = mamba.imageMb(imIn, 32)
imWrk2 = mamba.imageMb(imIn, 32)
imWrk3 = mamba.imageMb(imIn, 32)
maskIm = mamba.imageMb(imIn, 1)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
_initialQuasiDist_(imIn, imOut1, imOut2, grid=grid)
mamba.copy(imOut2, imWrk1)
v1 = mamba.computeVolume(imOut2)
v2 = v1 + 1
while v2 > v1:
v2 = v1
mamba.erode(imWrk1, imWrk2, se=se)
mamba.sub(imWrk1, imWrk2, imWrk2)
mamba.threshold(imWrk2, maskIm, 2, mamba.computeMaxRange(imWrk2)[1])
mamba.convertByMask(maskIm, imWrk3, 0, mamba.computeMaxRange(imWrk3)[1])
mamba.logic(imWrk2, imWrk3, imWrk2, "inf")
mamba.subConst(imWrk2, 1, imWrk3)
mamba.logic(imWrk2, imWrk3, imWrk2, "inf") # Patch non saturated subtraction
mamba.sub(imWrk1, imWrk2, imWrk1)
v1 = mamba.computeVolume(imWrk1)
mamba.copy(imWrk1, imOut2)
def _sparseConjugateHexagonDilate(imIn, imOut, size, edge=mamba.EMPTY):
"""
Dilation by a conjugate hexagon. The structuring element used by this operation
is not complete. Some holes appear inside the structuring element. Therefore, this
operation should not be used to obtain true conjugate hexagons dilations (for
internal use only).
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
val = mamba.computeMaxRange(imIn)[1] * int(edge != mamba.EMPTY)
for i in _sizeSplit(size):
mamba.copy(imOut, imWrk1)
j = 2 * i
supFarNeighbor(imWrk1, imOut, 1, j, grid=mamba.SQUARE, edge=edge)
mamba.shift(imWrk1, imWrk2, 2, i, val, grid=mamba.HEXAGONAL)
supFarNeighbor(imWrk2, imOut, 4, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk2, imOut, 6, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk1, imOut, 5, j, grid=mamba.SQUARE, edge=edge)
mamba.shift(imWrk1, imWrk2, 5, i, val, grid=mamba.HEXAGONAL)
supFarNeighbor(imWrk2, imOut, 1, i, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk2, imOut, 3, i, grid=mamba.HEXAGONAL, edge=edge)
j = 3 * i // 2
supFarNeighbor(imWrk1, imOut, 2, j, grid=mamba.HEXAGONAL, edge=edge)
supFarNeighbor(imWrk1, imOut, 5, j, grid=mamba.HEXAGONAL, edge=edge)
def volumeLabelling(imIn1, imIn2, imOut):
"""
Each connected component of the binary image or the partition 'imIn1' is
labelled with the volume of the greyscale or 32-bit image 'imIn2' inside
this component. The result is put in the 32-bit image 'imOut'.
"""
imWrk1 = mamba.imageMb(imIn1, 1)
imWrk2 = mamba.imageMb(imIn1, 32)
imWrk3 = mamba.imageMb(imIn1, 8)
imOut.reset()
n = imIn2.getDepth()
# Case of a 8-bit image.
if n == 8:
for i in range(8):
# Each bit plane is extracted and used in the labelling.
mamba.copyBitPlane(imIn2, i, imWrk1)
measureLabelling(imIn1, imWrk1, imWrk2)
# The resulting labels are combined to obtain the final one.
v = 2 ** i
mamba.mulConst(imWrk2, v, imWrk2)
mamba.add(imOut, imWrk2, imOut)
else:
for j in range(4):
# Each byte plane is treated.
mamba.copyBytePlane(imIn2, j, imWrk3)
for i in range(8):
mamba.copyBitPlane(imWrk3, i, imWrk1)
measureLabelling(imIn1, imWrk1, imWrk2)
v = 2 ** (8 * j + i)
mamba.mulConst(imWrk2, v, imWrk2)
mamba.add(imOut, imWrk2, imOut)
def contrast():
im = mamba.imageMb("before.jpg")
imContrast = mamba.imageMb(im)
contrastEnhancer(im, imContrast, 10)
imContrast.save("contrast_A.jpg")
im = mamba.imageMb("after.jpg")
imContrast = mamba.imageMb(im)
contrastEnhancer(im, imContrast, 10)
imContrast.save("contrast_B.jpg")
def largeHexagonalDilate(imIn, imOut, size, edge=mamba.EMPTY):
"""
Dilation by large hexagons using dilations by large segments and the Steiner
decomposition property of the hexagon.
Edge effects are corrected by dilations with transposed decompositions
combined with sup operators.
This operator is quite complex to avoid edge effects.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn)
sizemax = min(imIn.getSize()) // 2
# If size larger than sizemax, the operation must be iterated to prevent edge effects.
n = size
mamba.copy(imIn, imOut)
while n > 0:
s = min(n, sizemax)
largeLinearDilate(imOut, imWrk1, 6, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk1,
imWrk1,
4,
s,
grid=mamba.HEXAGONAL,
edge=edge)
largeLinearDilate(imOut, imWrk2, 4, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk2,
imWrk2,
6,
s,
grid=mamba.HEXAGONAL,
edge=edge)
mamba.logic(imWrk1, imWrk2, imWrk1, "sup")
largeLinearDilate(imWrk1,
imWrk2,
2,
s,
grid=mamba.HEXAGONAL,
edge=edge)
largeLinearDilate(imOut, imWrk1, 1, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imWrk1,
imWrk1,
3,
s,
grid=mamba.HEXAGONAL,
edge=edge)
largeLinearDilate(imOut, imOut, 3, s, grid=mamba.HEXAGONAL, edge=edge)
largeLinearDilate(imOut, imOut, 1, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imWrk1, imOut, imWrk1, "sup")
largeLinearDilate(imWrk1, imOut, 5, s, grid=mamba.HEXAGONAL, edge=edge)
mamba.logic(imOut, imWrk2, imOut, "sup")
n = n - s
def markerControlledWatershed(imIn, imMarkers, imOut, grid=mamba.DEFAULT_GRID):
"""
Marker-controlled watershed transform of greytone image 'imIn'. The binary
image 'imMarkers' contains the markers which control the flooding process.
'imOut' contains the valued watershed.
"""
im_mark = mamba.imageMb(imIn, 32)
imWrk = mamba.imageMb(imIn)
label(imMarkers, im_mark, grid=grid)
watershedSegment(imIn, im_mark, grid=grid)
mamba.copyBytePlane(im_mark, 3, imWrk)
mamba.logic(imWrk, imIn, imOut, 'inf')
def markerControlledWatershed(imIn, imMarkers, imOut, grid=mamba.DEFAULT_GRID):
"""
Marker-controlled watershed transform of greytone image 'imIn'. The binary
image 'imMarkers' contains the markers which control the flooding process.
'imOut' contains the valued watershed.
"""
im_mark = mamba.imageMb(imIn, 32)
imWrk = mamba.imageMb(imIn)
label(imMarkers, im_mark, grid=grid)
watershedSegment(imIn, im_mark, grid=grid)
mamba.copyBytePlane(im_mark, 3, imWrk)
mamba.logic(imWrk, imIn, imOut, "inf")
def floorSubConst(imIn, v, imOut):
"""
Subtracts a constant value 'v' to image 'imIn' and puts the result in 'imOut'.
If imIn - v is negative, the result is truncated and limited to 0.
Note that this operator is mainly useful for 32-bit images, as the result
of the subtraction is always truncated for 8-bit images.
"""
imMask = mamba.imageMb(imIn, 1)
imWrk = mamba.imageMb(imIn)
mamba.subConst(imIn, v, imWrk)
mamba.generateSupMask(imIn, imWrk, imMask, False)
mamba.convertByMask(imMask, imOut, 0, mamba.computeMaxRange(imOut)[1])
mamba.logic(imOut, imWrk, imOut, "inf")
def geodesicSKIZ(imIn, imMask, imOut, grid=mamba.DEFAULT_GRID):
"""
Geodesic skeleton by zones of influence of binary image 'imIn' inside the
geodesic mask 'imMask'. The result is in binary image 'imOut'.
"""
imWrk1 = mamba.imageMb(imIn, 8)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imWrk2)
mamba.build(imMask, imWrk2, grid=grid)
mamba.convertByMask(imWrk2, imWrk1, 2, 1)
mamba.sub(imWrk1, imIn, imWrk1)
markerControlledWatershed(imWrk1, imIn, imWrk1, grid=grid)
mamba.threshold(imWrk1, imOut, 0, 0)
mamba.logic(imOut, imWrk2, imOut, "inf")
def mamba_ws(self, NEED_WL, res_type):
imDist = imageMb(*self.dist.shape, 32)
fillImageWithArray(self.dist, imDist)
imMarkers = imageMb(*self.markers.shape, 32)
fillImageWithArray(self.markers.astype(np.uint32), imMarkers)
if NEED_WL:
labels, res = decorator(watershedSegment, res_type)(imDist, imMarkers, grid=SQUARE)
else:
labels, res = decorator(basinSegment,res_type)(imDist, imMarkers, grid=SQUARE)
tmp = imageMb(*self.markers.shape, 8)
copyBytePlane(tmp, 3, imMarkers)
self.labels = getArrayFromImage(imMarkers, self.size)
return res
def geodesicSKIZ(imIn, imMask, imOut, grid=mamba.DEFAULT_GRID):
"""
Geodesic skeleton by zones of influence of binary image 'imIn' inside the
geodesic mask 'imMask'. The result is in binary image 'imOut'.
"""
imWrk1 = mamba.imageMb(imIn, 8)
imWrk2 = mamba.imageMb(imIn)
mamba.copy(imIn, imWrk2)
mamba.build(imMask, imWrk2, grid=grid)
mamba.convertByMask(imWrk2, imWrk1, 2, 1)
mamba.sub(imWrk1, imIn, imWrk1)
markerControlledWatershed(imWrk1, imIn, imWrk1, grid=grid)
mamba.threshold(imWrk1, imOut, 0, 0)
mamba.logic(imOut, imWrk2, imOut, "inf")
def fullThin(imIn, imOut, dse, edge=mamba.EMPTY):
"""
Performs a complete thinning of 'imIn' with the successive rotations of 'dse'
(until idempotence) and puts the result in 'imOut'.
'imIn' and 'imOut' are binary images.
'edge' is set to EMPTY by default.
"""
if edge == mamba.EMPTY:
imWrk = mamba.imageMb(imIn)
mamba.copy(imIn, imOut)
v1 = mamba.computeVolume(imOut)
v2 = 0
while v1 != v2:
v2 = v1
for i in range(mamba.gridNeighbors(dse.getGrid())):
hitOrMiss(imOut, imWrk, dse)
mamba.diff(imOut, imWrk, imOut)
dse = dse.rotate()
v1 = mamba.computeVolume(imOut)
else:
mamba.negate(imIn, imOut)
v1 = mamba.computeVolume(imOut)
v2 = 0
while v1 != v2:
v2 = v1
rotatingThick(imOut, imOut, dse.flip())
v1 = mamba.computeVolume(imOut)
mamba.negate(imOut, imOut)
def blackClip(imIn, imOut, step=0, grid=mamba.DEFAULT_GRID):
"""
Performs a black skeleton clipping (clipping of a black skeleton image).
If 'step' is not defined (or equal to 0), the clipping is performed until
idempotence. If 'step' is defined, 'step' black points (if possible) will be
removed from each branch of the black skeleton.
'edge' is always set to FILLED.
"""
imWrk = mamba.imageMb(imIn)
mamba.negate(imIn, imOut)
if step == 0:
v1 = mamba.computeVolume(imOut)
v2 = 0
while v1 != v2:
v2 = v1
endPoints(imOut, imWrk, grid=grid, edge=mamba.FILLED)
mamba.diff(imOut, imWrk, imOut)
v1 = mamba.computeVolume(imOut)
else:
for i in range(step):
endPoints(imOut, imWrk, grid=grid, edge=mamba.FILLED)
mamba.diff(imOut, imWrk, imOut)
mamba.negate(imOut, imOut)
def cellsErode(imIn, imOut, n=1, se=mamba.DEFAULT_SE, edge=mamba.FILLED):
"""
Simultaneous erosion of size 'n' (default 1) of all the cells of the
partition image 'imIn' with 'se' structuring element.
The resulting partition is put in 'imOut'.
'edge' is set to FILLED by default.
This operation works on 8-bit and 32-bit partitions.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn, 1)
mamba.dilate(imIn, imWrk1, n=n, se=se)
mamba.erode(imIn, imOut, n=n, se=se, edge=edge)
mamba.generateSupMask(imOut, imWrk1, imWrk2, False)
mamba.convertByMask(imWrk2, imWrk1, 0, mamba.computeMaxRange(imIn)[1])
mamba.logic(imOut, imWrk1, imOut, "inf")
def cellsComputeDistance(imIn, imOut, grid=mamba.DEFAULT_GRID, edge=mamba.EMPTY):
"""
Computation of the distance function for each cell of the partition
image 'imIn'.
The result is put in the 32-bit image 'imOut'.
This operator works on hexagonal or square 'grid' and
'edge' is set to EMPTY by default.
"""
imWrk1 = mamba.imageMb(imIn)
imWrk2 = mamba.imageMb(imIn, 1)
se = mamba.structuringElement(mamba.getDirections(grid), grid)
cellsErode(imIn, imWrk1, 1, se=se, edge=edge)
mamba.threshold(imWrk1, imWrk2, 1, 255)
mamba.computeDistance(imWrk2, imOut, grid=grid, edge=edge)
mamba.addConst(imOut, 1, imOut)
