def from_pil_to_sm_image(Pil_image,type_im='not GT'):
matrix=np.array(Pil_image)
dim=len(matrix.shape)
if type_im=='not GT':
if dim<3:
if dim==2:
print 'dim == 2 is unexepected...'
image = sm.Image(matrix.shape[1], matrix.shape[0])
im_array = image.getNumArray()
im_array[:,:] = np.transpose(matrix)
else:
image = sm.Image("RGB",matrix.shape[1], matrix.shape[0], min(matrix.shape[2],3)) ###il faudrait la mettre en RGB!!!
image_temp= sm.Image()
sm.splitChannels(image,image_temp)
im_array = image_temp.getNumArray()
for i in range(min(matrix.shape[2],3)):
im_array[:,:,i] = np.transpose(matrix[:,:,i])
sm.mergeChannels(image_temp,image)
else:
if dim<3:
image = sm.Image(matrix.shape[1], matrix.shape[0])
im_array = image.getNumArray()
im_array[:,:] = np.transpose(matrix)
else:
image= sm.Image('UINT8',matrix.shape[1],matrix.shape[0])
im_array = image.getNumArray()
im_array[:,:] = np.transpose(matrix[:,:,0])
return(image)
def __call__(self, original_image):
"""
Output:
dictionnaire contenant pour chaque canal choisi l'image transformée après application de l'opérateur.
"""
###
dic_im_res={}
#pdb.set_trace()
if original_image.getTypeAsString()=="RGB":
if self._channels_list == None:
self._channels_list = [0,1,2]
image_slices = sp.Image()
sp.splitChannels(original_image, image_slices)
for i in self._channels_list:
image_transformed = sp.Image(image_slices.getSlice(0))
self._operator_functor(image_slices.getSlice(i), image_transformed)
dic_im_res[i] = image_transformed
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
self._channels_list = [0]
image_transformed = sp.Image(original_image)
self._operator_functor(original_image, image_transformed)
dic_im_res[0] = image_transformed
else:
raise TypeError('pb')
return dic_im_res
def visu_TFPN(im_pred, im_GT):
"""
Enables to see the:
- true positives in green
- true negatives in white
- false positives in red
- false negatives in blue
"""
dic_color={'TP': [0, 255, 0], 'TN': [255, 255, 255], 'FP': [255, 0, 0], 'FN': [0, 0, 255] }
sp.test(im_pred, 1, 0, im_pred)
sp.test(im_GT, 1, 0, im_GT)
imtmp = sp.Image(im_GT)
iminv = sp.Image(im_GT)
imTP = sp.Image(im_GT)
imFN = sp.Image(im_GT)
imTN = sp.Image(im_GT)
imFP = sp.Image(im_GT)
sp.test(im_pred == im_GT, 1, 0, imtmp)
sp.test(im_pred == im_GT, 0, 1, iminv)
sp.test(im_pred>0, imtmp, 0, imTP)
sp.test(im_pred<1, iminv, 0, imFN)
sp.test(im_GT<1, imtmp, 0, imTN)
sp.test(im_GT<1, iminv, 0, imFP)
imR = sp.Image(im_GT)
imG = sp.Image(im_GT)
imB = sp.Image(im_GT)
sp.test(imTP, dic_color['TP'][0], 0, imR)
sp.test(imTP, dic_color['TP'][1], 0, imG)
sp.test(imTP, dic_color['TP'][2], 0, imB)
sp.test(imFN, dic_color['FN'][0], imR, imR)
sp.test(imFN, dic_color['FN'][1], imG, imG)
sp.test(imFN, dic_color['FN'][2], imB, imB)
sp.test(imTN, dic_color['TN'][0], imR, imR)
sp.test(imTN, dic_color['TN'][1], imG, imG)
sp.test(imTN, dic_color['TN'][2], imB, imB)
sp.test(imFP, dic_color['FP'][0], imR, imR)
sp.test(imFP, dic_color['FP'][1], imG, imG)
sp.test(imFP, dic_color['FP'][2], imB, imB)
imOut = sp.Image(imR, 'RGB')
im_slices = sp.Image()
sp.splitChannels(imOut, im_slices)
sp.copy(imR, im_slices.getSlice(0))
sp.copy(imG, im_slices.getSlice(1))
sp.copy(imB, im_slices.getSlice(2))
sp.mergeChannels(im_slices, imOut)
return imOut
def my_area_filtering(imin, size):
"""
Filtering of a gray level or color image.
Only V4 connexity is available.
"""
if imin.getTypeAsString() == "RGB":
im = sp.Image()
sp.splitChannels(imin, im)
for i in range(3):
gray_area_filtering(im.getSlice(i), size)
sp.mergeChannels(im, imin)
else:
gray_area_filtering(imin, size)
def my_area_filtering(imin, size):
"""
Filtering of a gray level or color image.
Only V4 connexity is available.
"""
if imin.getTypeAsString() == "RGB":
im = sp.Image()
sp.splitChannels(imin, im)
for i in range(3):
gray_area_filtering(im.getSlice(i), size)
sp.mergeChannels(im, imin)
else:
gray_area_filtering(imin, size)
def X_singlePlot(imIn, ax, label):
if (imIn.getTypeAsString() == "RGB"):
im3ch = sp.Image()
sp.splitChannels(imIn, im3ch)
imArr = im3ch.getNumArray()
imArr = np.rot90(imArr, -1)
imArr = np.fliplr(imArr)
ax.imshow(imArr)
else:
imInArr = imIn.getNumArray()
imInArr = np.rot90(imInArr, -1)
imInArr = np.fliplr(imInArr)
if not label:
ax.imshow(imInArr, cmap=cm.Greys_r, norm=cl.NoNorm())
else:
ax.imshow(imInArr, cmap=randcmap)
def __call__(self, original_image):
"""
Output:
dictionnaire contenant pour chaque canal choisi l'image de superpixels,
avec une seule valeur par superpixel.
"""
image_sp = self._spp_method(original_image)
blobs = sp.computeBlobs(image_sp)
dict_integrator = {
"mean": sp.measMeanVals,
"std": sp.measMeanVals,
"mode": sp.measModeVals,
"min": sp.measMinVals,
"max": sp.measMaxVals,
"vol": sp.measVolumes,
}
###
dic_im_res={}
if original_image.getTypeAsString()=="RGB":
if self._channels_list == None:
self._channels_list = [0,1,2]
image_slices = sp.Image()
sp.splitChannels(original_image, image_slices)
image_transformed = sp.Image(image_slices.getSlice(0))
for i in self._channels_list:
self._operator_functor(image_slices.getSlice(i), image_transformed)
vals_map = dict_integrator[self._integrator](image_transformed, blobs)
im_out = apply_with_integrator(vals_map, image_sp, self._integrator)
dic_im_res[i] = im_out
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
self._channels_list = [0]
image_transformed = sp.Image(original_image)
self._operator_functor(original_image, image_transformed)
vals_map = dict_integrator[self._integrator](image_transformed, blobs)
im_out = apply_with_integrator(vals_map, image_sp, self._integrator)
dic_im_res[0] = im_out
else:
raise TypeError('pb')
return dic_im_res
def smilToNumpyPlotNoNorm(imIn, labelImage=False):
if (imIn.getTypeAsString() == "RGB"):
imIn3ch = sp.Image()
sp.splitChannels(imIn, imIn3ch)
imInArr = imIn3ch.getNumArray()
imInArr = np.rot90(imInArr, -1)
imInArr = np.fliplr(imInArr)
plt.figure()
plt.imshow(imInArr)
plt.show()
else:
imInArr = imIn.getNumArray()
imInArr = np.rot90(imInArr, -1)
imInArr = np.fliplr(imInArr)
if not labelImage:
plt.figure()
plt.imshow(imInArr, cmap="gray", norm=cl.NoNorm())
plt.show()
else:
plt.figure()
plt.imshow(imInArr, cmap=randcmap)
plt.show()
def __call__(self, im):
if self.check_cache(im) is False:
arrIn = np.zeros(( im.getSize()[0], im.getSize()[1], 3 ))
if im.getTypeAsString()=="RGB":
image_slices = sp.Image()
sp.splitChannels(im, image_slices)
for i in range(3):
arrtmp = image_slices.getSlice(i)
arrIn[:, :, i] = arrtmp.getNumArray()
else:
for i in range(3):
arrIn[:, :, i] = im.getNumArray()
region_labels = slic(np.uint8(arrIn), self._params["nb_regions"], self._params["m"])
imout = sp.Image(region_labels.shape[0], region_labels.shape[1])
arrOut = imout.getNumArray()
for i in range(region_labels.shape[0]):
for j in range(region_labels.shape[1]):
arrOut[i, j] = region_labels[i, j]
##
copie16 = sp.Image(imout, "UINT16")
sp.copy(imout, copie16)
self.update_cache(im, copie16)
return self._cache_seg
def __call__(self, original_image):
"""
Plusieurs étapes:
1) calculer les superpixels de l'image originale
2) calculer le dictionnaire des imagettes de superpixels
3) appliquer l'opérateur sur chacune de ces imagettes
4) intégrer sur le superpixel pour n'avoir qu'une seule valeur (si besoin)
--> inclus dans l'opérateur
5) calculer la nouvelle image entière des superpixels, où cette fois-ci la valeur de chaque SP n'est pas son label mais celle calculée en 4.
[Note: plusieurs images si plusieurs cannaux sélectionnés dans channels_list. Output: dictionnaire de ces images finales.]
--> output plut^ot un dictionnaire car pas besoin des images.
Ouput:
dic_inter: un dictionnaire tel que:
- chaque clé est un numéro de superpixel ex: i
- chaque valeur est un dictionnaire associé au superpixel i, contenant pour chaque cannal j (clés) la valeur du feature.
"""
### Etape 1: calcul des SP
image_sp = self._spp_method(original_image)
blobs = sp.computeBlobs(image_sp)
barys = sp.measBarycenters(image_sp, blobs)
### Etape 2 : cacul du dictionnaire intermédiaire
### Inititation listes:
if original_image.getTypeAsString()=="RGB":
if self._channels_list == None:
self._channels_list = [0,1,2]
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
self._channels_list = [0]
else:
raise TypeError('pb')
dic_final = {}
for i in self._channels_list:
dic_final[i] = [] ## cette liste contiendra la valeur pour chaque superpixel
###
dic_inter = {}
nb_sp = len(blobs.keys()) ## nombre de superpixels
bboxes_coord = sp.measBoundBoxes(image_sp) ## dictionnary of coordinates of the two points (top left, bottom right) of each bounding box.
sim_sp = sp.Image(image_sp)## pour garder temporairement l'imagette du superpixel
for elem in range(nb_sp):
elem += 1
sp.crop(image_sp, bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_sp)
sp.subNoSat(sim_sp, elem, sim_sp)
sp.test(sim_sp, 0, 65535, sim_sp) ## imagette masque du superpixel i
# sim_sp.save('imagettes/bin_mask_'+str(elem)+'.png')
# if sim_sp.getSize()[0] == 1 and sim_sp.getSize()[1] == 1 :
# print "sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1])
# image_sp.save("essais/sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1]) + "_SP.png")
# original_image.save("essais/sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1]) + "_orig.png")
if original_image.getTypeAsString()=="RGB":
image_slices = sp.Image()
sp.splitChannels(original_image, image_slices)
dic_orig_slices={}
for i in self._channels_list:
sim_orig_slice= sp.Image(image_slices.getSlice(i))
sp.crop(image_slices.getSlice(i), bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_orig_slice)
sp.add(sim_orig_slice, 1, sim_orig_slice)
sp.test(sim_sp>0, sim_orig_slice, 0, sim_orig_slice)
dic_orig_slices[i] = sim_orig_slice
#sim_orig_slice.save('imagettes/orig_slice_'+str(i)+'_for_sup_'+str(elem)+'.png')
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
dic_orig_slices={}
sim_orig_slice= sp.Image(original_image)
sp.crop(original_image, bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_orig_slice)
sp.add(sim_orig_slice, 1, sim_orig_slice)
sp.test(sim_sp>0, sim_orig_slice, 0, sim_orig_slice)
dic_orig_slices[0] = sim_orig_slice
dic_inter[elem] = (sim_sp, dic_orig_slices, barys[elem])
### Etape 3: application de l'opérateur sur chaque imagette:
dic_elem_val_={}
for i in self._channels_list:
dic_final[i] += [self._operator_functor(dic_orig_slices[i])]
return dic_final
def __call__(self, original_image):
"""
Plusieurs étapes:
1) calculer les superpixels de l'image originale
2) calculer le dictionnaire des imagettes de superpixels
3) appliquer l'opérateur sur chacune de ces imagettes
4) intégrer sur le superpixel pour n'avoir qu'une seule valeur (si besoin)
--> inclus dans l'opérateur
5) calculer la nouvelle image entière des superpixels, où cette fois-ci la valeur de chaque SP n'est pas son label mais celle calculée en 4.
[Note: plusieurs images si plusieurs cannaux sélectionnés dans channels_list. Output: dictionnaire de ces images finales.]
--> output plut^ot un dictionnaire car pas besoin des images.
Ouput:
dic_inter: un dictionnaire tel que:
- chaque clé est un numéro de superpixel ex: i
- chaque valeur est un dictionnaire associé au superpixel i, contenant pour chaque cannal j (clés) la valeur du feature.
"""
### Etape 1: calcul des SP
image_sp = self._spp_method(original_image)
blobs = sp.computeBlobs(image_sp)
barys = sp.measBarycenters(image_sp, blobs)
### Etape 2 : cacul du dictionnaire intermédiaire
### Inititation listes:
if original_image.getTypeAsString()=="RGB":
if self._channels_list == None:
self._channels_list = [0,1,2]
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
self._channels_list = [0]
else:
raise TypeError('pb')
dic_final = {}
#for i in self._channels_list:
# dic_final[i] = [] ## cette liste contiendra la valeur pour chaque superpixel
###
dic_inter = {}
nb_sp = len(blobs.keys()) ## nombre de superpixels
bboxes_coord = sp.measBoundBoxes(image_sp) ## dictionnary of coordinates of the two points (top left, bottom right) of each bounding box.
sim_sp = sp.Image(image_sp)## pour garder temporairement l'imagette du superpixel
for elem in range(nb_sp):
elem += 1
sp.crop(image_sp, bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_sp)
sp.subNoSat(sim_sp, elem, sim_sp)
sp.test(sim_sp, 0, 65535, sim_sp) ## imagette masque du superpixel i
# sim_sp.save('imagettes/bin_mask_'+str(elem)+'.png')
# if sim_sp.getSize()[0] == 1 and sim_sp.getSize()[1] == 1 :
# print "sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1])
# image_sp.save("essais/sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1]) + "_SP.png")
# original_image.save("essais/sup_" + str(elem) +"pos_" + str(bboxes_coord[elem][0]) + "_" + str(bboxes_coord[elem][1]) + "_orig.png")
if original_image.getTypeAsString()=="RGB":
image_slices = sp.Image()
sp.splitChannels(original_image, image_slices)
dic_orig_slices={}
for i in self._channels_list:
sim_orig_slice= sp.Image(image_slices.getSlice(i))
sp.crop(image_slices.getSlice(i), bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_orig_slice)
sp.add(sim_orig_slice, 1, sim_orig_slice)
sp.test(sim_sp>0, sim_orig_slice, 0, sim_orig_slice)
dic_orig_slices[i] = sim_orig_slice
#sim_orig_slice.save('imagettes/orig_slice_'+str(i)+'_for_sup_'+str(elem)+'.png')
elif original_image.getTypeAsString()=="UINT8" or original_image.getTypeAsString()=="UINT16":
dic_orig_slices={}
sim_orig_slice= sp.Image(original_image)
sp.crop(original_image, bboxes_coord[elem][0], bboxes_coord[elem][1], bboxes_coord[elem][2] - bboxes_coord[elem][0] + 1, bboxes_coord[elem][3] - bboxes_coord[elem][1] + 1, sim_orig_slice)
sp.add(sim_orig_slice, 1, sim_orig_slice)
sp.test(sim_sp>0, sim_orig_slice, 0, sim_orig_slice)
dic_orig_slices[0] = sim_orig_slice
dic_inter[elem] = (sim_sp, dic_orig_slices, barys[elem])
### Etape 3: application de l'opérateur sur chaque imagette:
dic_elem_val_={}
for i in self._channels_list:
# TODO: would be better to check a feature list with memory
feats_from_op = None
for op in self._operator_functors:
# todo: remove _
feature_name = op.get_name()+"_"+self._spp_method.get_name()+"_for_channel_" + str(i)
if not feature_name in dic_final:
dic_final[feature_name] = []
dic_final[feature_name].append(op(dic_orig_slices[i], feats_from_op))
feats_from_op = op.feats
# the list of all features (channel is hard coded in the feature names)
features = self.get_name()
# get a matrix nb_features x nb_superpixels with all feature values
Xsp = np.array([dic_final[x] for x in features])
if self._uc == "pixel":
# get a vector with a concatenation of all lines of the superpixel image (label image)
# the -1 comes from the fact that the label image starts with 1.
indices = np.ravel(image_sp.getNumArray()) - 1
# we simply slice Xsp to get the final pixel features
X = Xsp[:,indices]
else:
# in case we want to classify superpixels, the initial matrix was fine.
X = Xsp
return X