def CRF(self,
image,
softmax,
iterations=1,
sdims_g=(1, 1),
sdims_b=(3, 3),
schan=0.5):
softmax = softmax.transpose(2, 0, 1)
n_classes = softmax.shape[0]
unary = unary_from_softmax(softmax)
d = dcrf.DenseCRF(image.shape[1] * image.shape[0], n_classes)
d.setUnaryEnergy(unary)
feats = create_pairwise_gaussian(sdims=sdims_g, shape=image.shape[:2])
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=sdims_b,
schan=schan,
img=image,
chdim=2)
d.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(iterations)
probabilities = np.array(Q).reshape((n_classes, image.shape[0], -1))
labels = np.argmax(Q, axis=0).reshape(image.shape[0:2])
return probabilities.transpose(1, 2, 0), labels
def apply(self, image, colour_axis):
spatial_sigmas = [self.sigma for _ in range(len(image.shape) - 1)]
shape = [
image.shape[i] for i in range(len(image.shape)) if i != colour_axis
]
return crf_utils.create_pairwise_gaussian(sdims=spatial_sigmas,
shape=shape)
def CRF(x, image):
unary = unary_from_softmax(x) #C,H,W
unary = np.ascontiguousarray(unary)
d = dcrf.DenseCRF(image.shape[-2] * image.shape[-1], 10)
d.setUnaryEnergy(unary)
gau_feats = create_pairwise_gaussian(sdims=(3, 3), shape=image.shape[-2:])
d.addPairwiseEnergy(gau_feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
bil_feats = create_pairwise_bilateral(sdims=(10, 10),
schan=[5],
img=np.array(image).transpose(
1, 2, 0),
chdim=2)
d.addPairwiseEnergy(bil_feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
x = np.argmax(Q, axis=0).reshape(image.shape[-2], image.shape[-1])
Q = np.array(Q)
Q = Q.reshape(-1, image.shape[-2], image.shape[-1])
return Q, x
def adjust_prediction(self, probability, image):
crf = dcrf.DenseCRF(np.prod(probability.shape), 2)
# crf = dcrf.DenseCRF(np.prod(probability.shape), 1)
binary_prob = np.stack((1 - probability, probability), axis=0)
unary = unary_from_softmax(binary_prob)
# unary = unary_from_softmax(np.expand_dims(probability, axis=0))
crf.setUnaryEnergy(unary)
# per dimension scale factors
sdims = [self.sdims] * 3
smooth = create_pairwise_gaussian(sdims=sdims, shape=probability.shape)
crf.addPairwiseEnergy(smooth, compat=2)
if self.schan:
# per channel scale factors
schan = [self.schan] * 6
appearance = create_pairwise_bilateral(sdims=sdims,
schan=schan,
img=image,
chdim=3)
crf.addPairwiseEnergy(appearance, compat=2)
result = crf.inference(self.iter)
crf_prediction = np.argmax(result, axis=0).reshape(
probability.shape).astype(np.float32)
return crf_prediction
def test_complete_inference2():
dcrf = densecrf.DenseCRF(100, 2)
pcrf = pycrf.DenseCRF(100, 2)
unary = test_utils._get_simple_unary()
img = test_utils._get_simple_img()
dcrf.setUnaryEnergy(-np.log(unary))
pcrf.set_unary_energy(-np.log(unary))
feats = utils.create_pairwise_gaussian(sdims=(1.5, 1.5),
shape=img.shape[:2])
dcrf.addPairwiseEnergy(feats, compat=3)
pcrf.add_pairwise_energy(feats, compat=3)
feats = utils.create_pairwise_bilateral(sdims=(2, 2), schan=2,
img=img, chdim=2)
dcrf.addPairwiseEnergy(feats, compat=3)
pcrf.add_pairwise_energy(feats, compat=3)
# d.addPairwiseBilateral(2, 2, img, 3)
res1 = np.argmax(dcrf.inference(10), axis=0).reshape(10, 10)
res2 = np.argmax(pcrf.inference(10), axis=0).reshape(10, 10)
if False:
# Save the result for visual inspection
import scipy as scp
import scipy.misc
scp.misc.imsave("test.png", res1)
assert(np.all(res1 == res2))
def CRF(img, probabilities, K):
#print("Probabilities shape : " , probabilities.shape)
processed_probabilities = probabilities.squeeze()
#print("Processed : " , processed_probabilities.shape)
softmax = processed_probabilities.transpose((2, 0, 1))
#print(softmax.shape)
unary = unary_from_softmax(softmax)
#print(unary.shape)
unary = np.ascontiguousarray(unary)
#print(unary.shape)
d = dcrf.DenseCRF(img.shape[0] * img.shape[1], K)
d.setUnaryEnergy(unary)
#d.addPairwiseGaussian(sxy=3, compat=3)
feats = create_pairwise_gaussian(sdims=(3, 3), shape=(img.shape[1], img.shape[0]))
#feats = create_pairwise_bilateral(sdims=(5, 5), schan=(10, 10, 10), img=img.reshape(img.shape[1], img.shape[0], 3), chdim=2)
#print("Feats : \n", feats)
d.addPairwiseEnergy(feats, compat=5, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
res = np.argmax(Q, axis=0).reshape(img.shape[1], img.shape[0]).astype('float32')
res *= (255. / res.max())
res.reshape(img.shape[:2])
#print("Res \n", res)
return res
def dense_crf(img, output_probs_1, output_probs_0):
h = output_probs_1.shape[0]
w = output_probs_1.shape[1]
output_probs_1 = np.expand_dims(output_probs_1, 0)
output_probs_0 = np.expand_dims(output_probs_0, 0)
output_probs = np.append(output_probs_0, output_probs_1, axis=0)
d = dcrf.DenseCRF2D(w, h, 2)
U = -np.log(output_probs)
U = U.reshape((2, -1))
U = np.ascontiguousarray(U)
img = np.ascontiguousarray(img).astype(np.uint8)
d.setUnaryEnergy(U)
gaussian_energy = create_pairwise_gaussian(sdims=(3, 3),
shape=img.shape[:2])
d.addPairwiseEnergy(gaussian_energy, compat=3)
pairwise_energy = create_pairwise_bilateral(sdims=(50, 50),
schan=(5, ),
img=img,
chdim=2)
d.addPairwiseEnergy(pairwise_energy, compat=10)
Q = d.inference(3)
map_q = np.array(Q)[1, :].reshape(h, w)
Q = np.argmax(np.array(Q), axis=0).reshape((h, w))
return Q
def crf(labels,rgb,classes=None,ls=[0,1,2,3,4,5]):
if classes==None:
labels += np.amin(labels)
labels /= np.amax(labels)
classes = labels.shape[2]
c_img = np.rollaxis(labels,2)
U = unary_from_softmax(c_img)
else:
c_img = cl.classimg(labels,map=True,labels=ls)
c_img = np.reshape(c_img,(c_img.shape[0]*c_img.shape[1])).astype(int)
U = unary_from_labels(np.array([0,3]),2,.7,zero_unsure=True)
d = dcrf.DenseCRF2D(labels.shape[0], labels.shape[1], classes)
d.setUnaryEnergy(U)
PG = create_pairwise_gaussian((3,3),labels.shape[:2])
d.addPairwiseEnergy(PG,3)
PB = create_pairwise_bilateral((59,59), (13,13,13,13), rgb,chdim=2)
d.addPairwiseEnergy(PB,6)
Q = d.inference(5)
map = np.argmax(Q, axis=0)
map = np.reshape(map,labels.shape[:2])
return map
def densecrf(logits):
"""
applies coditional random fields on predictions
The idea is consider the nbr voxels in making
class prediction of current pixel
refer CRF and MRF papers for more theoretical idea
args
logits: Nb_classes x Height x Width x Depth
returns
tensor of size Height x Width x Depth
"""
shape = logits.shape[1:]
new_image = np.empty(shape)
d = dcrf.DenseCRF(np.prod(shape), logits.shape[0])
U = unary_from_softmax(logits)
d.setUnaryEnergy(U)
feats = create_pairwise_gaussian(sdims=(1.0, 1.0, 1.0), shape=shape)
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
new_image = np.argmax(Q, axis=0).reshape((shape[0], shape[1], shape[2]))
return new_image
def dense_crf(original_image, annotated_image, NUM_OF_CLASSESS, use_2d=True):
# Converting annotated image to RGB if it is Gray scale
print(original_image.shape, annotated_image.shape)
# Gives no of class labels in the annotated image
#n_labels = len(set(labels.flat))
n_labels = NUM_OF_CLASSESS
# Setting up the CRF model
d = dcrf.DenseCRF2D(original_image.shape[1], original_image.shape[0],
n_labels)
# get unary potentials (neg log probability)
processed_probabilities = annotated_image
softmax = processed_probabilities.transpose((2, 0, 1))
print(softmax.shape)
U = unary_from_softmax(softmax, scale=None, clip=1e-5)
U = np.ascontiguousarray(U)
#U = unary_from_labels(labels, n_labels, gt_prob=0.7, zero_unsure=False)
d.setUnaryEnergy(U)
# This potential penalizes small pieces of segmentation that are
# spatially isolated -- enforces more spatially consistent segmentations
feats = create_pairwise_gaussian(sdims=(3, 3),
shape=original_image.shape[:2])
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features --
# because the segmentation that we get from CNN are too coarse
# and we can use local color features to refine them
feats = create_pairwise_bilateral(sdims=(80, 80),
schan=(13, 13, 13),
img=original_image,
chdim=2)
d.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# Run Inference for 5 steps
Q = d.inference(5)
print(Q)
#print(">>>>>>>>Qshape: ", Q.shape)
# Find out the most probable class for each pixel.
output = np.argmax(Q, axis=0).reshape(
(original_image.shape[0], original_image.shape[1]))
print(output.shape)
plt.subplot(240 + 1)
plt.imshow(output, cmap=plt.get_cmap('nipy_spectral'))
plt.show()
return output
def crf(self, input_vol, softmax_vol): # prob shape: classes, width, height, depth # vol shape: width, height, depth assert len(softmax_vol.shape) == 4 assert len(input_vol.shape) == 4 return_ = np.empty((input_vol.shape[1:])) for slice_idx in range(input_vol.shape[3]): image = input_vol[:, :, :, slice_idx] softmax = softmax_vol[:, :, :, slice_idx] # softmax = softmax.transpose(2, 0, 1) # image = image.transpose(2, 0, 1) n_classes = softmax.shape[0] unary = unary_from_softmax(softmax) d = dcrf.DenseCRF(image.shape[1]*image.shape[0], n_classes) d.setUnaryEnergy(unary) feats = create_pairwise_gaussian(sdims=(1., 1.), shape=image.shape[:2]) d.addPairwiseEnergy(feats, compat=3, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC) # This creates the color-dependent features and then add them to the CRF feats = create_pairwise_bilateral(sdims=(3., 3.), schan=0.5, img=image, chdim=2) d.addPairwiseEnergy(feats, compat=10, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC) Q = d.inference(iterations) probabilities = np.array(Q).reshape((n_classes,image.shape[0],-1)) labels = np.argmax(Q, axis=0).reshape(image.shape[0:2]) return_[:,:,slice_idx] = labels return return_
def get_crf_seg(img, labels, n_labels, opts):
'''
crf_out_final = get_crf_seg(img, labels, n_labels)
'''
crf = dcrf.DenseCRF(img.shape[1] * img.shape[0], n_labels)
U = unary_from_softmax(labels)
crf.setUnaryEnergy(U)
# pairwise positional (gaussian) terms
feats = create_pairwise_gaussian(sdims=(opts.gaussian_sx, opts.gaussian_sx), shape=img.shape[:2])
crf.addPairwiseEnergy(feats, compat=opts.crf_gaussian_weight,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# pairwise bilateral (color + position) terms
feats = create_pairwise_bilateral(sdims=(opts.bilateral_sx, opts.bilateral_sx), \
schan=(opts.bilateral_color, opts.bilateral_color, opts.bilateral_color),
img=img, chdim=2)
crf.addPairwiseEnergy(feats, compat=opts.crf_bilateral_weight,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# run inference
Q = crf.inference(5)
return Q
def run_CRF(patient, sdimsB, sdimsG, schan):
path0 = path + 'patient_' + str(patient) +'_ProbMapClass0.nii.gz'
path1 = path + 'patient_' + str(patient) +'_ProbMapClass1.nii.gz'
ims, npoints, nlabels, affine = niiToNumpyCRFinput(path0, path1)
shape1 = ims.shape[1:]
name = 'patient_' + str(patient) + '_CRF'
d = dcrf.DenseCRF(npoints, nlabels) # npoints, nlabels
U = ims
shape = U.shape[1:]
# print (np.sum(U))
U = unary_from_softmax(ims)
d.setUnaryEnergy(U)
G = create_pairwise_gaussian(sdimsG, shape)
d.addPairwiseEnergy(w2*G, compat=compat1)
B = create_pairwise_bilateral(sdimsB, schan, ims, chdim=0)
d.addPairwiseEnergy(w1*B, compat=compat2)
# Q = d.inference(1)
Q, tmp1, tmp2 = d.startInference()
for i in range(5):
# print("KL-divergence at {}: {}".format(i, d.klDivergence(Q)))
d.stepInference(Q, tmp1, tmp2)
patientCRF = np.argmax(Q, axis=0).reshape(shape1).astype(np.float32)
#print (patientCRF.shape, patientCRF.dtype, np.sum(patientCRF))
# if patient == 48:
# im = nib.Nifti1Image(patientCRF, affine=affine)
# nib.save(im, os.path.join(CRFpath, name + '.nii.gz'))
# im1 = nib.load(CRFpath + name + '.nii.gz')
# print(im1.get_data().shape)
# print(im1.get_data().dtype)
# print(im1.header)
return patientCRF
def dencecrf(x, y, nlabels, w1, w2, alpha, beta, gamma, iteration=5):
_x = np.array(x)
_y = np.array(y, np.float32)
assert len(_x.shape) == len(_y.shape), 'Shape of x and y should be (..., nchannels), (..., nlabels)'
assert _y.shape[-1] == nlabels, 'Expect y.shape (...,{}), got {}'.format(nlabels, _y.shape)
_y = _y.reshape((-1, nlabels))
_y = np.transpose(_y, (1,0))
d = dcrf.DenseCRF(np.prod(_x.shape[0:-1]), nlabels)
d.setUnaryEnergy(_y.copy(order='C'))
imgdim = len(_x.shape)-1
gamma = (gamma,) * imgdim
alpha = (alpha,) * imgdim
beta = (beta,) * _x.shape[-1]
featG = create_pairwise_gaussian(gamma, _x.shape[0:-1]) # g
featB = create_pairwise_bilateral(alpha, beta, _x, imgdim) #a b
d.addPairwiseEnergy(featG, w2) # w2
d.addPairwiseEnergy(featB, w1) # w1
out = d.inference(iteration)
out = np.transpose(out, (1,0))
out = np.reshape(out, y.shape)
return out
def pp_denseCRF(imag, y_pred,
pairwise_gauss=True, pairwise_bilateral=True,
pw_gauss_sdims=(10, 10), pw_gauss_compat=3,
pw_bilat_sdims=(20, 20), pw_bilat_schan=(0.005,),
pw_bilat_compat=10, inf_steps=5):
'''Dense CRF postprocessing using 2D image / softmax prediction matrix'''
height, width, channels = imag.shape
n_classes = y_pred.shape[-1]
# Set unary energy
d = dcrf.DenseCRF2D(width, height, n_classes)
U = unary_from_softmax(np.moveaxis(y_pred, -1, 0))
d.setUnaryEnergy(U)
# Create the (color)-independent features and add them to the CRF
if pairwise_gauss == True:
pw_gauss = create_pairwise_gaussian(sdims=pw_gauss_sdims,
shape=y_pred.shape[:2])
d.addPairwiseEnergy(pw_gauss, compat=pw_gauss_compat)
# Create the (color)-dependent features and add them to the CRF
if pairwise_bilateral == True:
pw_bilateral = create_pairwise_bilateral(sdims=pw_bilat_sdims,
schan=pw_bilat_schan,
img=imag, chdim=2)
d.addPairwiseEnergy(pw_bilateral, compat=pw_bilat_compat)
# Inference
Q = d.inference(inf_steps)
# Reshape eigen matrix and return prediction in original shape
pred_Q = np.reshape(Q, (n_classes, height, width))
pred_orig_shape = np.moveaxis(pred_Q, 0, -1)
return pred_orig_shape
def post_processing(data, probas):
[h,w] = data.shape
n_labels = 2
pred_maps = np.zeros(data.shape)
#print 'postprocessing:', data.shape, probas.shape
img = np.uint8(data*255)
img = data[...,np.newaxis]
#proba = probas
proba = probas + 0.1
#proba[proba>1] = 1
labels = np.zeros((2,img.shape[0],img.shape[1]))
labels[0] = 1-proba
labels[1] = proba
#U=labels
U = unary_from_softmax(labels) # note: num classes is first dim
pairwise_energy = create_pairwise_bilateral(sdims=(7,7), schan=(0.001,), img=img, chdim=2)
pairwise_gaussian = create_pairwise_gaussian(sdims=(3,3), shape=img.shape[:2])
d = dcrf.DenseCRF2D(w, h, n_labels)
d.setUnaryEnergy(U)
d.addPairwiseEnergy(pairwise_gaussian, compat=1, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC)
d.addPairwiseEnergy(pairwise_energy, compat=1, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC) # `compat` is the "strength" of this potential.
Q = d.inference(5)
pred_maps = np.argmax(Q, axis=0).reshape((h,w))
return pred_maps
def process(final_probabilities,image,iters): softmax = final_probabilities.squeeze() print softmax.shape processed_probabilities = softmax.transpose((2, 0, 1)) # The input should be the negative of the logarithm of probability values # Look up the definition of the softmax_to_unary for more information unary = softmax_to_unary(processed_probabilities) # The inputs should be C-continious -- we are using Cython wrapper unary = np.ascontiguousarray(unary) d = dcrf.DenseCRF(image.shape[0] * image.shape[1], 2) d.setUnaryEnergy(unary) # This potential penalizes small pieces of segmentation that are # spatially isolated -- enforces more spatially consistent segmentations feats = create_pairwise_gaussian(sdims=(10, 10), shape=image.shape[:2]) d.addPairwiseEnergy(feats, compat=3, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC) # This creates the color-dependent features -- # because the segmentation that we get from CNN are too coarse # and we can use local color features to refine them feats = create_pairwise_bilateral(sdims=(50, 50), schan=(20, 20, 20), img=image, chdim=2) d.addPairwiseEnergy(feats, compat=10, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC) return d.inference(iters)
def compute_lattice(self, img, num_classes=None):
if num_classes is not None:
self.num_classes = num_classes
assert self.num_classes is not None
npixels = self.shape[0] * self.shape[1]
crf = dcrf.DenseCRF(npixels, self.num_classes)
sdims = self.conf['pos_feats']['sdims']
feats = utils.create_pairwise_gaussian(sdims=(sdims, sdims),
shape=img.shape[:2])
self.smooth_feats = feats
self.crf = crf
self.crf.addPairwiseEnergy(self.smooth_feats,
compat=self.conf['pos_feats']['compat'])
sdims = self.conf['col_feats']['sdims']
schan = self.conf['col_feats']['schan']
feats = utils.create_pairwise_bilateral(sdims=(sdims, sdims),
schan=(schan, schan, schan),
img=img,
chdim=2)
self.appear_feats = feats
self.crf.addPairwiseEnergy(self.appear_feats,
compat=self.conf['pos_feats']['compat'])
def get_crf_img(inputs, outputs):
for i in range(outputs.shape[0]):
img = inputs[i]
softmax_prob = outputs[i]
unary = unary_from_softmax(softmax_prob)
unary = np.ascontiguousarray(unary)
d = dcrf.DenseCRF(img.shape[0] * img.shape[1], 2)
d.setUnaryEnergy(unary)
feats = create_pairwise_gaussian(sdims=(10, 10), shape=img.shape[:2])
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
feats = create_pairwise_bilateral(sdims=(50, 50),
schan=(20, 20, 20),
img=img,
chdim=2)
d.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
res = np.argmax(Q, axis=0).reshape((img.shape[0], img.shape[1]))
if i == 0:
crf = np.expand_dims(res, axis=0)
else:
res = np.expand_dims(res, axis=0)
crf = np.concatenate((crf, res), axis=0)
return crf
def dense_crf(probs,
img=None,
n_iters=10,
n_classes=2,
sxy_gaussian=(1, 1),
compat_gaussian=4,
kernel_gaussian=dcrf.DIAG_KERNEL,
normalisation_gaussian=dcrf.NORMALIZE_SYMMETRIC,
sxy_bilateral=(10, 10),
compat_bilateral=5,
srgb_bilateral=(5, 5, 5),
kernel_bilateral=dcrf.DIAG_KERNEL,
normalisation_bilateral=dcrf.NORMALIZE_SYMMETRIC):
"""DenseCRF over unnormalised predictions.
More details on the arguments at https://github.com/lucasb-eyer/pydensecrf.
Args:
probs: class probabilities per pixel.
img: if given, the pairwise bilateral potential on raw RGB values will be computed.
n_iters: number of iterations of MAP inference.
sxy_gaussian: standard deviations for the location component of the colour-independent term.
compat_gaussian: label compatibilities for the colour-independent term (can be a number, a 1D array, or a 2D array).
kernel_gaussian: kernel precision matrix for the colour-independent term (can take values CONST_KERNEL, DIAG_KERNEL, or FULL_KERNEL).
normalisation_gaussian: normalisation for the colour-independent term (possible values are NO_NORMALIZATION, NORMALIZE_BEFORE, NORMALIZE_AFTER, NORMALIZE_SYMMETRIC).
sxy_bilateral: standard deviations for the location component of the colour-dependent term.
compat_bilateral: label compatibilities for the colour-dependent term (can be a number, a 1D array, or a 2D array).
srgb_bilateral: standard deviations for the colour component of the colour-dependent term.
kernel_bilateral: kernel precision matrix for the colour-dependent term (can take values CONST_KERNEL, DIAG_KERNEL, or FULL_KERNEL).
normalisation_bilateral: normalisation for the colour-dependent term (possible values are NO_NORMALIZATION, NORMALIZE_BEFORE, NORMALIZE_AFTER, NORMALIZE_SYMMETRIC).
Returns:
Refined predictions after MAP inference.
"""
_, h, w, _ = probs.shape
probs = probs[0].transpose(2, 0,
1).copy(order='C') # Need a contiguous array.
d = dcrf.DenseCRF2D(w, h, n_classes) # Define DenseCRF model.
U = unary_from_softmax(probs) # Unary potential.
U = U.reshape((n_classes, -1)) # Needs to be flat.
d.setUnaryEnergy(U)
energy = create_pairwise_gaussian(sxy_gaussian, [w, h])
d.addPairwiseEnergy(energy, compat=compat_gaussian)
if img is not None:
assert (
img.shape[1:3] == (h, w)
), "The image height and width must coincide with dimensions of the logits."
energy = create_pairwise_bilateral(sdims=sxy_bilateral,
schan=srgb_bilateral[0],
img=img,
chdim=-1)
d.addPairwiseEnergy(energy, compat=compat_bilateral)
Q = d.inference(n_iters)
preds = np.array(Q, dtype=np.float32).reshape(
(n_classes, h, w)).transpose(1, 2, 0)
return np.expand_dims(preds, 0)
def __call__(self, image: np.ndarray, keypoints: np.ndarray) -> np.ndarray:
if not imageutils.is_in_range(image, [0, 255]):
raise imageutils.RangeError(image, "image", [0, 255])
dynamic_range = image.max() / image.min()
is_low_range = dynamic_range <= 2.0
if is_low_range:
import warnings
warnings.warn(
Warning(
"image has low dynamic range. Maybe convert to [0, 255]?"))
h, w, c = image.shape
keypoint_probs = imageutils.keypoints_to_heatmaps((h, w),
keypoints,
var=self.var)
keypoint_probs = np.rollaxis(keypoint_probs, 2, 0)
bg_prob = 1.0 - np.amax(keypoint_probs, axis=0, keepdims=True)
probs = np.concatenate([bg_prob, keypoint_probs], axis=0)
n_labels = probs.shape[0]
probs_flat = np.reshape(probs, (n_labels, -1))
d = dcrf.DenseCRF(h * w, n_labels)
# flatten everything for dense crf
# Set unary according to keypoints
U = -np.log(probs_flat + 1.0e-6).astype(np.float32)
d.setUnaryEnergy(U.copy(order="C"))
# This creates the color-independent features and then add them to the CRF
feats = create_pairwise_gaussian(sdims=(3, 3), shape=image.shape[:2])
d.addPairwiseEnergy(
feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC,
)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=(80, 80),
schan=(13, 13, 13),
img=image,
chdim=2)
d.addPairwiseEnergy(
feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC,
)
# Run five inference steps.
Q = d.inference(self.n_steps)
# Find out the most probable class for each pixel.
MAP = np.argmax(Q, axis=0)
MAP = MAP.reshape((h, w))
return MAP
def apply(self, image, colour_axis):
if colour_axis == -1:
colour_axis = len(image.shape) - 1
shape = [
image.shape[i] for i in range(len(image.shape)) if i != colour_axis
]
return crf_utils.create_pairwise_gaussian(sdims=self.sigmas,
shape=shape)
def crfInference(imageGT, fgMask, probs):
##################################
### Read images and annotation ###
##################################
# img = np.uint8(img*255)
img = skimage.color.rgb2lab(imageGT)
M = 3 # forground, background, occluding object.
###########################
### Setup the CRF model ###
###########################
# Example using the DenseCRF class and the util functions
crfmodel = dcrf.DenseCRF(img.shape[0] * img.shape[1], M)
# get unary potentials (neg log probability)
# U = compute_unary(labels, M)
U = unaryOcclusionModel(img, fgMask, probs)
U = superpixelUnary(imageGT, U, fgMask, 0.8)
crfmodel.setUnaryEnergy(U)
# This creates the color-independent features and then add them to the CRF
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
crfmodel.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=(30, 30),
schan=(13, 13, 13),
img=img,
chdim=2)
crfmodel.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
####################################
### Do inference and compute map ###
####################################
Q = crfmodel.inference(5)
mapseg = np.argmax(Q, axis=0).reshape(img.shape[:2])
# res = map.astype('float32') * 255 / map.max()
# plt.imshow(res)
# plt.show()
# # Manually inference
# Q, tmp1, tmp2 = crfmodel.startInference()
# for i in range(5):
# print("KL-divergence at {}: {}".format(i, crfmodel.klDivergence(Q)))
# crfmodel.stepInference(Q, tmp1, tmp2)
return mapseg, np.array(Q)
def apply_crf(seg_pred_probs,imgs):
# Appearance parameters
# a_sxy=160 # theta_alpha (refer website for equation terminology)
# a_srgb= 3 # theta_beta
# a_w1= 5 # weight term for bilateral term
# # Gaussian smoothness term
# g_sxy= 10 # theta_gamma
# g_w2=30 # weight term for Gaussian smoothness
a_w1, a_sxy, a_srgb = 5, 2, 0.1
g_w2, g_sxy = 10, 5
num_batch = seg_pred_probs.shape[0]
masks_out = np.zeros_like(imgs)
for k in range(num_batch):
seg_pred_prob = seg_pred_probs[k,:,:,:]
img = imgs[k,:,:,:]
seg_pred_prob_tmp = np.swapaxes(np.swapaxes( seg_pred_prob,0,2 ),1,2)# to above mentioned shape - you could use np.swapaxes to achieve this.
unary = unary_from_softmax(seg_pred_prob_tmp)
d = dcrf.DenseCRF2D(exp_config.image_size[0],exp_config.image_size[1], exp_config.nlabels)
d.setUnaryEnergy(unary)
###########################
#Calculate Bilateral term
###########################
################################################
# img_re = np.squeeze(img) #img_test_slice- 2D image containing intensity values
img_re = np.copy(img)
gaussian_pairwise_energy = create_pairwise_gaussian(sdims=(g_sxy,g_sxy), shape=img_re.shape[:2])
d.addPairwiseEnergy(gaussian_pairwise_energy, compat=g_w2)
bilateral_pairwise_energy = create_pairwise_bilateral(sdims=(a_sxy,a_sxy), schan=(a_srgb,), img=img_re, chdim=2)
d.addPairwiseEnergy(bilateral_pairwise_energy, compat=a_w1)
# gaussian_pairwise_energy = create_pairwise_gaussian(shape=img_re.shape[:2])
# d.addPairwiseEnergy(gaussian_pairwise_energy)
#
# bilateral_pairwise_energy = create_pairwise_bilateral(img=img_re, chdim=2)
# d.addPairwiseEnergy(bilateral_pairwise_energy)
################################################
######################
# Inference
######################
# Run inference for 100 iterations
Q_final = d.inference(100)
# The Q is now the approximate posterior, we can get a MAP estimate using argmax.
crf_seg_soln = np.argmax(Q_final, axis=0)
# Unfortunately, the DenseCRF flattens everything, so get it back into picture form (width,height).
crf_seg_soln = crf_seg_soln.reshape((exp_config.image_size[0],exp_config.image_size[1]))
masks_out[k,:,:,:] = np.copy(np.expand_dims(crf_seg_soln,2))
return masks_out
def crf(image, softmax):
unary = softmax_to_unary(softmax) # 转为一元.
unary = np.ascontiguousarray(unary)
d = dcrf.DenseCRF2D(image.shape[0], image.shape[1], 2)
d.setUnaryEnergy(unary)
feats = create_pairwise_gaussian(sdims=(4, 4), shape=image.shape[:2]) # (5,5) #(10,10)
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
def crf(img, prob):
func_start = time.time()
img = np.swapaxes(img, 0, 2)
# img.shape: (width, height, num of channels)
num_iter = 5
prob = np.swapaxes(prob, 1, 2) # shape: (1, width, height)
# preprocess prob to (num_classes, width, height) since we have 2 classes: car and background.
num_classes = 2
probs = np.tile(prob, (num_classes, 1, 1)) # shape: (2, width, height)
probs[0] = np.subtract(1, prob) # class 0 is background
probs[1] = prob # class 1 is car
d = dcrf.DenseCRF(img.shape[0] * img.shape[1], num_classes)
unary = unary_from_softmax(probs) # shape: (num_classes, width * height)
unary = np.ascontiguousarray(unary)
d.setUnaryEnergy(unary)
# This potential penalizes small pieces of segmentation that are
# spatially isolated -- enforces more spatially consistent segmentations
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# Note that this potential is not dependent on the image itself.
# This creates the color-dependent features --
# because the segmentation that we get from CNN are too coarse
# and we can use local color features to refine them
feats = create_pairwise_bilateral(sdims=(80, 80), schan=(13, 13, 13),
img=img, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(num_iter) # set the number of iterations
res = np.argmax(Q, axis=0).reshape((img.shape[0], img.shape[1]))
# res.shape: (width, height)
res = np.swapaxes(res, 0, 1) # res.shape: (height, width)
res = res[np.newaxis, :, :] # res.shape: (1, height, width)
func_end = time.time()
# print('{:.2f} sec spent on CRF with {} iterations'.format(func_end - func_start, num_iter))
# about 2 sec for a 1280 * 960 image with 5 iterations
return res
def postprocessing_pydensecrf(logits):
# probs of shape 3d image per class: Nb_classes x Height x Width x Depth
shape = logits.shape[1:]
new_image = np.empty(shape)
d = dcrf.DenseCRF(np.prod(shape), logits.shape[0])
U = unary_from_softmax(logits)
d.setUnaryEnergy(U)
feats = create_pairwise_gaussian(sdims=(1.0, 1.0, 1.0), shape=shape)
d.addPairwiseEnergy(feats, compat=3, kernel=dcrf.DIAG_KERNEL, normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
new_image = np.argmax(Q, axis=0).reshape((shape[0], shape[1],shape[2]))
return new_image
def crf(img, scores):
'''
scores: prob numpy array after softmax with shape (_, C, H, W)
img: image of shape (H, W, C)
CRF parameters: bi_w = 4, bi_xy_std = 121, bi_rgb_std = 5, pos_w = 3, pos_xy_std = 3
'''
img = np.asarray(img, dtype=np.uint8) # image.shape = [366,500,3]
scores = np.asarray(scores.cpu().detach(), dtype=np.float32)
scores = np.ascontiguousarray(scores)
img = np.ascontiguousarray(img)
n_classes, h, w = scores.shape
d = dcrf.DenseCRF2D(w, h, n_classes)
U = -np.log(scores)
U = U.reshape((n_classes, -1))
d.setUnaryEnergy(U)
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.FULL_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features --
# because the segmentation that we get from CNN are too coarse
# and we can use local color features to refine them
feats = create_pairwise_bilateral(sdims=(40, 40),
schan=(7, 7, 7),
img=img,
chdim=2)
d.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.FULL_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
Q = np.array(Q).reshape((2, h, w))
for ii in range(Q.shape[0]):
Q[ii] = cv2.medianBlur(Q[ii], 5)
# Q[ii] = cv2.GaussianBlur(Q[ii], (7, 7), 1)
Q_score = copy.deepcopy(Q)
Q = np.argmax(Q, axis=0)
return Q, Q_score
def crf(train_image, final_probabilities, train_annotation, number_class):
for index_image in xrange(1):
image = train_image
softmax = final_probabilities[0].squeeze()
#softmax_to_unary
softmax = softmax.transpose((2, 0, 1))
unary = unary_from_softmax(softmax)
#softmax_to_unary
unary = np.ascontiguousarray(unary)
d = dcrf.DenseCRF(image.shape[0] * image.shape[1], number_class)
d.setUnaryEnergy(unary)
# This potential penalizes small pieces of segmentation that are
# spatially isolated -- enforces more spatially consistent segmentations
feats = create_pairwise_gaussian(sdims=(10, 10), shape=image.shape[:2])
d.addPairwiseEnergy(feats,
compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features --
# because the segmentation that we get from CNN are too coarse
# and we can use local color features to refine them
feats = create_pairwise_bilateral(sdims=(50, 50),
schan=(20, 20, 20),
img=image,
chdim=2)
d.addPairwiseEnergy(feats,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
res = np.argmax(Q, axis=0).reshape((image.shape[0], image.shape[1]))
cmap = plt.get_cmap('bwr')
f, (ax1, ax2) = plt.subplots(1, 2, sharey=True)
ax1.imshow(res, vmax=1.5, vmin=-0.4, cmap=cmap)
ax1.set_title('Segmentation with CRF post-processing')
probability_graph = ax2.imshow(
np.dstack((train_annotation, ) * 3) * 100)
ax2.set_title('Ground-Truth Annotation')
plt.savefig('annotation_%d.png' % index_image,
bbox_inches='tight',
pad_inches=0)
plt.gcf().clear()
plt.show()
def get_prediction(pred_after_cnn, image):
unary = pred_after_cnn.transpose((2, 0, 1))
unary = -unary.reshape((unary.shape[0],-1))
unary = np.ascontiguousarray(unary).astype(np.float32)
d = dcrf.DenseCRF(image.shape[0] * image.shape[1], pred_after_cnn.shape[2])
d.setUnaryEnergy(unary)
feats = create_pairwise_gaussian(sdims=(10, 10), shape=image.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
feats = create_pairwise_bilateral(sdims=(50, 50), schan=(20, 20, 20),
img=image, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
res = np.argmax(Q, axis=0).reshape((image.shape[0], image.shape[1]))
return res
# def get_prediction(pred_after_cnn, image):
# d = dcrf.DenseCRF2D(pred_after_cnn.shape[1], pred_after_cnn.shape[0], pred_after_cnn.shape[2])
#
# U = pred_after_cnn.transpose((2, 0, 1))
# U = -U.reshape((U.shape[0],-1))
#
# U = np.ascontiguousarray(U).astype(np.float32)
#
# d.setUnaryEnergy(U)
#
# d.addPairwiseGaussian(sxy=3, compat=3)
# d.addPairwiseBilateral(sxy=80, srgb=13, rgbim=image, compat=10)
#
# Q = d.inference(5)
#
# map = np.argmax(Q, axis=0).reshape(image.shape[0:2])
#
# return map
def compute_lattice(self, img, num_classes=None):
"""
Compute indices for the lattice approximation.
Arguments:
img: np.array with shape [height, width, 3]
The input image. Default config assumes image
data in [0, 255]. For normalized images adapt
`schan`. Try schan = 0.1 for images in [-0.5, 0.5]
"""
if num_classes is not None:
self.num_classes = num_classes
assert self.num_classes is not None
npixels = self.shape[0] * self.shape[1]
crf = dcrf.DenseCRF(npixels, self.num_classes)
sdims = self.conf['pos_feats']['sdims']
feats = utils.create_pairwise_gaussian(
sdims=(sdims, sdims),
shape=img.shape[:2])
self.smooth_feats = feats
self.crf = crf
self.crf.addPairwiseEnergy(
self.smooth_feats, compat=self.conf['pos_feats']['compat'])
sdims = self.conf['col_feats']['sdims']
schan = self.conf['col_feats']['schan']
feats = utils.create_pairwise_bilateral(sdims=(sdims, sdims),
schan=(schan, schan, schan),
img=img, chdim=2)
self.appear_feats = feats
self.crf.addPairwiseEnergy(
self.appear_feats, compat=self.conf['pos_feats']['compat'])
def perform_crf(image, probabilities):
image = image.squeeze()
softmax = probabilities.squeeze().transpose((2, 0, 1))
# The input should be the negative of the logarithm of probability values
# Look up the definition of the softmax_to_unary for more information
unary = unary_from_softmax(softmax)
# The inputs should be C-continious -- we are using Cython wrapper
unary = np.ascontiguousarray(unary)
d = dcrf.DenseCRF(image.shape[0] * image.shape[1], number_of_classes)
d.setUnaryEnergy(unary)
# This potential penalizes small pieces of segmentation that are
# spatially isolated -- enforces more spatially consistent segmentations
feats = create_pairwise_gaussian(sdims=(10, 10), shape=image.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features --
# because the segmentation that we get from CNN are too coarse
# and we can use local color features to refine them
feats = create_pairwise_bilateral(sdims=(50, 50), schan=(20, 20, 20),
img=image, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
Q = d.inference(5)
res = np.argmax(Q, axis=0).reshape((image.shape[0], image.shape[1]))
return res
def crf(fn_im,fn_anno,fn_output,colorful_fn_output):
##################################
### Read images and annotation ###
##################################
img = imread(fn_im)
#truth_img = imread(truth_image).astype(np.uint8)
# Convert the annotation's RGB color to a single 32-bit integer color 0xBBGGRR
anno_rgb = imread(fn_anno)
#anno_lbl = anno_rgb[:,:,0] + (anno_rgb[:,:,1] << 8) + (anno_rgb[:,:,2] << 16)
anno_lbl = anno_rgb
# Convert the 32bit integer color to 1, 2, ... labels.
# Note that all-black, i.e. the value 0 for background will stay 0.
colors, labels = np.unique(anno_lbl, return_inverse=True)
# And create a mapping back from the labels to 32bit integer colors.
# But remove the all-0 black, that won't exist in the MAP!
colors = colors[1:]
colorize = np.empty((len(colors), 1), np.uint8)
colorize[:,0] = (colors & 0x0000FF)
#colorize[:,1] = (colors & 0x00FF00) >> 8
#colorize[:,2] = (colors & 0xFF0000) >> 16
# Compute the number of classes in the label image.
# We subtract one because the number shouldn't include the value 0 which stands
# for "unknown" or "unsure".
n_labels = len(set(labels.flat)) - 1
print(n_labels, " labels and \"unknown\" 0: ", set(labels.flat))
###########################
### Setup the CRF model ###
###########################
use_2d = False
# use_2d = True
if use_2d:
print("Using 2D specialized functions")
# Example using the DenseCRF2D code
if n_labels==1:
n_labels+=1
d = dcrf.DenseCRF2D(img.shape[1], img.shape[0], n_labels)
# get unary potentials (neg log probability)
U = unary_from_labels(labels, n_labels, gt_prob=0.7, zero_unsure=False)
d.setUnaryEnergy(U)
# This adds the color-independent term, features are the locations only.
d.addPairwiseGaussian(sxy=(3, 3), compat=3, kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This adds the color-dependent term, i.e. features are (x,y,r,g,b).
d.addPairwiseBilateral(sxy=(80, 80), srgb=(13, 13, 13), rgbim=img,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
else:
print("Using generic 2D functions")
# Example using the DenseCRF class and the util functions
d = dcrf.DenseCRF(img.shape[1] * img.shape[0], n_labels)
# get unary potentials (neg log probability)
U = unary_from_labels(labels, n_labels, gt_prob=0.7, zero_unsure=True)
d.setUnaryEnergy(U)
# This creates the color-independent features and then add them to the CRF
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=(80, 80), schan=(13, 13, 13),
img=img, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
####################################
### Do inference and compute MAP ###
####################################
# Run five inference steps.
Q = d.inference(10)
# Find out the most probable class for each pixel.
MAP = np.argmax(Q, axis=0)
# Convert the MAP (labels) back to the corresponding colors and save the image.
MAP = colorize[MAP,:]
####################################
### Convert to greyscale ###
####################################
crf_img = MAP.reshape(anno_lbl.shape)
########change to rgb########
label = anno_lbl
ind = crf_img
r = ind.copy()
g = ind.copy()
b = ind.copy()
r_gt = label.copy()
g_gt = label.copy()
b_gt = label.copy()
wall = [139,181,248]
building = [251,209,244]
sky = [44,230,121]
floor = [156,40,149]
tree = [166,219,98]
ceiling = [35,229,138]
road = [143,56,194]
bed = [144,223,70]
windowpane = [200,162,57]
grass = [120,225,199]
cabinet = [87,203,13]
sidewalk = [185,1,136]
person = [16,167,16]
earth = [29,249,241]
door = [17,192,40]
table = [199,44,241]
mountain = [193,196,159]
plant = [241,172,78]
curtain = [56,94,128]
chair = [231,166,116]
car = [50,209,252]
water = [217,56,227]
painting = [168,198,178]
sofa = [77,179,188]
shelf = [236,191,103]
house = [248,138,151]
sea = [214,251,89]
mirror = [208,204,187]
rug = [115,104,49]
field = [29,202,113]
armchair = [159,160,95]
seat = [78,188,13]
fence = [83,203,82]
desk = [8,234,116]
rock = [80,159,200]
wardrobe = [124,194,2]
lamp = [192,146,237]
bathtub = [64,3,73]
railing = [17,213,58]
cushion = [106,54,105]
base = [125,72,155]
box = [202,36,231]
column = [79,144,4]
signboard = [118,185,128]
chest = [138,61,178]
counter = [23,182,182]
sand = [154,114,4]
sink = [201,0,83]
skyscraper = [21,134,53]
fireplace = [194,77,237]
refrigerator = [198,81,106]
grandstand = [37,222,181]
path = [203,185,14]
stairs = [134,140,113]
runway = [220,196,79]
case = [64,26,68]
pooltable = [128,89,2]
pillow = [199,228,65]
screen = [62,215,111]
stairway = [124,148,166]
river = [221,119,245]
bridge = [68,57,158]
bookcase = [80,47,26]
blind = [143,59,56]
coffeetable = [14,80,215]
toilet = [212,132,31]
flower = [2,234,129]
book = [134,179,44]
hill = [53,21,129]
bench = [80,176,236]
countertop = [154,39,168]
stove = [221,44,139]
palm = [103,56,185]
kitchenisland = [224,138,83]
computer = [243,93,235]
swivelchair = [80,158,63]
boat = [81,229,38]
bar = [116,215,38]
arcademachine = [103,69,182]
hovel = [66,81,5]
bus = [96,157,229]
towel = [164,49,170]
light = [14,42,146]
truck = [164,67,44]
tower = [108,116,151]
chandelier = [144,8,144]
awning = [85,68,228]
streetlight = [16,236,72]
booth = [108,7,86]
television = [172,27,94]
airplane = [119,247,193]
dirttrack = [155,240,152]
apparel = [49,158,204]
pole = [23,193,204]
land = [228,66,107]
bannister = [69,36,163]
escalator = [238,158,228]
ottoman = [202,226,35]
bottle = [194,243,151]
buffet = [192,56,76]
poster = [16,115,240]
stage = [61,190,185]
van = [7,134,32]
ship = [192,87,171]
fountain = [45,11,254]
conveyerbelt = [179,183,31]
canopy = [181,175,146]
washer = [13,187,133]
plaything = [12,1,2]
swimmingpool = [63,199,190]
stool = [221,248,32]
barrel = [183,221,51]
basket = [90,111,162]
waterfall = [82,0,6]
tent = [40,0,239]
bag = [252,81,54]
minibike = [110,245,152]
cradle = [0,187,93]
oven = [163,154,153]
ball = [134,66,99]
food = [123,150,242]
step = [38,144,137]
tank = [59,180,230]
tradename = [144,212,16]
microwave = [132,125,200]
pot = [26,3,35]
animal = [199,56,92]
bicycle = [83,223,224]
lake = [203,47,137]
dishwasher = [74,74,251]
screen = [246,81,197]
blanket = [168,130,178]
sculpture = [136,85,200]
hood = [186,147,103]
sconce = [170,21,85]
vase = [104,52,182]
trafficlight = [166,147,202]
tray = [103,119,71]
ashcan = [74,161,165]
fan = [14,9,83]
pier = [129,194,43]
crtscreen = [7,100,55]
plate = [13,12,170]
monitor = [30,21,22]
bulletinboard = [224,189,139]
shower = [40,77,25]
radiator = [194,14,94]
glass = [178,8,231]
clock = [234,166,8]
flag = [248,25,7]
unlabelled = [0,0,0]
label_colours = np.array([wall,building,sky,floor,tree,ceiling,road,bed ,windowpane,grass,cabinet,sidewalk,person,earth,door,table,mountain,plant,curtain,chair,car,water,painting,sofa,shelf,house,sea,mirror,rug,field,armchair,seat,fence,desk,rock,wardrobe,lamp,bathtub,railing,cushion,base,box,column,signboard,chest,counter,sand,sink,skyscraper,fireplace,refrigerator,grandstand,path,stairs,runway,case,pooltable,pillow,screen,stairway,river,bridge,bookcase,blind,coffeetable,toilet,flower,book,hill,bench,countertop,stove,palm,kitchenisland,computer,swivelchair,boat,bar,arcademachine,hovel,bus,towel,light,truck,tower,chandelier,awning,streetlight,booth,television,airplane,dirttrack,apparel,pole,land,bannister,escalator,ottoman,bottle,buffet,poster,stage,van,ship,fountain,conveyerbelt,canopy,washer,plaything,swimmingpool,stool,barrel,basket,waterfall,tent,bag,minibike,cradle,oven,ball,food,step,tank,tradename,microwave,pot,animal,bicycle,lake,dishwasher,screen,blanket,sculpture,hood,sconce,vase,trafficlight,tray,ashcan,fan,pier,crtscreen,plate,monitor,bulletinboard,shower,radiator,glass,clock,flag,unlabelled])
for l in range(0,150):
r[ind==l] = label_colours[l,0]
g[ind==l] = label_colours[l,1]
b[ind==l] = label_colours[l,2]
r_gt[label==l] = label_colours[l,0]
g_gt[label==l] = label_colours[l,1]
b_gt[label==l] = label_colours[l,2]
# r_truth[truth_img==l] = label_colours[l,0]
# g_truth[truth_img==l] = label_colours[l,1]
# b_truth[truth_img==l] = label_colours[l,2]
rgb = np.zeros((ind.shape[0], ind.shape[1], 3))
rgb[:,:,0] = r
rgb[:,:,1] = g
rgb[:,:,2] = b
rgb_gt = np.zeros((label.shape[0], label.shape[1], 3))
rgb_gt[:,:,0] = r_gt
rgb_gt[:,:,1] = g_gt
rgb_gt[:,:,2] = b_gt
cv2.imwrite(colorful_fn_output,rgb)
########change to rgb########
imsave(fn_output,crf_img)
# Just randomly manually run inference iterations
Q, tmp1, tmp2 = d.startInference()
for i in range(10):
print("KL-divergence at {}: {}".format(i, d.klDivergence(Q)))
d.stepInference(Q, tmp1, tmp2)
# This adds the color-dependent term, i.e. features are (x,y,r,g,b).
d.addPairwiseBilateral(sxy=(80, 80), srgb=(13, 13, 13), rgbim=img,
compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
else:
# Example using the DenseCRF class and the util functions
d = dcrf.DenseCRF(img.shape[0] * img.shape[1], M)
# get unary potentials (neg log probability)
U = compute_unary(labels, M)
d.setUnaryEnergy(U)
# This creates the color-independent features and then add them to the CRF
feats = create_pairwise_gaussian(sdims=(3, 3), shape=img.shape[:2])
d.addPairwiseEnergy(feats, compat=3,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
# This creates the color-dependent features and then add them to the CRF
feats = create_pairwise_bilateral(sdims=(80, 80), schan=(13, 13, 13),
img=img, chdim=2)
d.addPairwiseEnergy(feats, compat=10,
kernel=dcrf.DIAG_KERNEL,
normalization=dcrf.NORMALIZE_SYMMETRIC)
####################################
### Do inference and compute map ###
####################################
