def apply_net(self, input_image, perform_downsample=True, perform_pad=True, perform_upsample=True, perform_blur=True, perform_offset=True):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by), (self.pad_by, self.pad_by)), 'symmetric')
if perform_downsample:
input_image = np.float32(mahotas.imresize(input_image, 1.0/self.downsample))
layer_temp = input_image.reshape(1, input_image.shape[0], input_image.shape[1])
for layeri in range(len(self.all_layers)):
layer_temp = self.all_layers[layeri].apply_layer(layer_temp)
output_image = layer_temp[0,:,:]
if perform_upsample:
output_image = np.float32(mahotas.imresize(output_image, self.downsample))
if perform_blur:
output_image = scipy.ndimage.filters.gaussian_filter(output_image, self.best_sigma)
if perform_offset:
#Translate
output_image = np.roll(output_image, self.best_offset[0], axis=0)
output_image = np.roll(output_image, self.best_offset[1], axis=1)
# Crop to valid size
output_image = output_image[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output_image
def test_imresize():
img = np.repeat(np.arange(100), 10).reshape((100, 10))
assert imresize(img, (1024, 104)).shape == (1024, 104)
assert imresize(img, (10., 10.)).shape == (1000, 100)
assert imresize(
img,
.2,
).shape == (20, 2)
assert imresize(img, (10., 2.)).shape == (1000, 20)
def apply_net(self, input_image, perform_downsample=False, perform_pad=False, perform_upsample=False, perform_blur=False, perform_offset=False):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by), (self.pad_by, self.pad_by)), 'symmetric')
if perform_downsample and self.downsample != 1:
input_image = np.float32(mahotas.imresize(input_image, 1.0/self.downsample))
nx = input_image.shape[0] - self.pad_by*2
ny = input_image.shape[1] - self.pad_by*2
nbatches = nx * ny
output = np.zeros((nx, ny), dtype=np.float32)
t_input_image = theano.shared(np.asarray(input_image,dtype=theano.config.floatX),borrow=True)
index_x = T.lscalar()
index_y = T.lscalar()
# eval_network_l0 = theano.function([index_x, index_y], self.all_layers[0].output,
# givens={self.x: t_input_image[index_x:index_x + self.pad_by * 2 + 1, index_y:index_y + self.pad_by * 2 + 1]})
# eval_network_l1 = theano.function([index_x, index_y], self.all_layers[1].output,
# givens={self.x: t_input_image[index_x:index_x + self.pad_by * 2 + 1, index_y:index_y + self.pad_by * 2 + 1]})
# eval_network_l2 = theano.function([index_x, index_y], self.all_layers[2].output,
# givens={self.x: t_input_image[index_x:index_x + self.pad_by * 2 + 1, index_y:index_y + self.pad_by * 2 + 1]})
eval_network = theano.function([index_x, index_y], self.all_layers[-1].output,
givens={self.x: t_input_image[index_x:index_x + self.pad_by * 2 + 1, index_y:index_y + self.pad_by * 2 + 1]})
for xi in range(nx):
for yi in range(ny):
# print eval_network_l0(xi, yi)[0,0,:,:]
# print eval_network_l1(xi, yi)[0,0,:,:]
# print eval_network_l2(xi, yi)[0,0,:,:]
# print eval_network(xi, yi)[0,0]
output[xi, yi] = eval_network(xi, yi)[0,0]
print "up to x={0} of {1}".format(xi+1, nx)
if perform_upsample:
output = np.float32(mahotas.imresize(output, self.downsample))
if perform_blur and self.best_sigma != 0:
output = scipy.ndimage.filters.gaussian_filter(output, self.best_sigma)
if perform_offset:
#Translate
output = np.roll(output, self.best_offset[0], axis=0)
output = np.roll(output, self.best_offset[1], axis=1)
# Crop to valid size
#output = output[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output
def write_image (output_path, data, image_num=0, downsample=1):
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path, np.uint16(normdata * 65535))
def write_image(output_path, data, image_num=0, downsample=1):
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path, np.uint16(normdata * 65535))
def get_image_block(self):
""" Loops through all images belonging to a Site, flattens pixel values,
and returns a pandas DataFrame for all values
If image dimensions are inconsistent, the images will be rescaled to the
largest image size.
:return pandas DataFrame of flattened pixel values, along with image
coordinates and Site name
"""
imgs = {i.name if i.maskName is None else i.maskName:i.get_image()
for i in self.images}
mask_names = [i.maskName for i in self.images
if i.maskName is not None]
maxRes = max((i.shape for i in imgs.values()))
rr, cc = np.mgrid[0:maxRes[0], 0:maxRes[1]]
imgBlock = {'imgRow': rr.astype(np.uint16).flatten(),
"imgCol": cc.astype(np.uint16).flatten()}
for k, v in imgs.items():
if v.dtype != np.bool and v.shape != maxRes:
imgBlock.update({k: mh.imresize(v, maxRes, order=3).flatten()
})
else:
imgBlock.update({k: v.flatten()})
df = pd.DataFrame(imgBlock)
df.loc[:, mask_names] = df.loc[:, mask_names].fillna(False).astype(np.bool)
df['site'] = self.name
return df
def output_image (data, layer, index, unpad_by, image_num=0, downsample=1):
data = data[unpad_by:data.shape[0]-unpad_by,unpad_by:data.shape[1]-unpad_by]
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path + '/{0:04d}_classify_output_layer{1}_{2}.tif'.format(image_num, layer, index), np.uint16(normdata * 65535))
def preprocess(self, frame):
# Uncomment the below if using an environment other than Atari Breakout
# In the standard preprocessing, the bottom and top 13 pixels are cropped out, but this crops the agent's paddle
# out of the frame in Breakout, making it impossible to converge. For all other environments, you should uncomment
# the line below to use the standard preprocessing algorithm, and comment out the alternative currently in use.
# return mahotas.imresize(mahotas.colors.rgb2grey(frame), (84, 110))[:, 13:-13] / 255.0
return mahotas.imresize(mahotas.colors.rgb2grey(frame),
(84, 84)) / 255.0
def apply_net(self, input_image, perform_downsample=False, perform_pad=False, perform_upsample=False, perform_blur=False, perform_offset=False):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by), (self.pad_by, self.pad_by)), 'symmetric')
if perform_downsample and self.downsample != 1:
input_image = np.float32(mahotas.imresize(input_image, 1.0/self.downsample))
nx = input_image.shape[0] - self.all_layers[0].input_footprint + 1
ny = input_image.shape[1] - self.all_layers[0].input_footprint + 1
nbatches = nx * ny
layer_temp = np.zeros((nbatches, 1, self.all_layers[0].input_footprint, self.all_layers[0].input_footprint), dtype=np.float32)
batchi = 0
for x in range(nx):
for y in range(ny):
#print (x,y)
layer_temp[batchi, :, :, :] = input_image[x:(x + self.all_layers[0].input_footprint), y:(y + self.all_layers[0].input_footprint)]
batchi += 1
assert batchi == nbatches
for layeri in range(len(self.all_layers)):
print 'Layer {0}.'.format(layeri)
layer_temp = self.all_layers[layeri].apply_layer(layer_temp)
output_image = layer_temp[:,0,0,0].reshape(nx, ny)
if perform_upsample:
output_image = np.float32(mahotas.imresize(output_image, self.downsample))
if perform_blur and self.best_sigma != 0:
output_image = scipy.ndimage.filters.gaussian_filter(output_image, self.best_sigma)
if perform_offset:
#Translate
output_image = np.roll(output_image, self.best_offset[0], axis=0)
output_image = np.roll(output_image, self.best_offset[1], axis=1)
# Crop to valid size
#output_image = output_image[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output_image
def apply_net(self,
input_image,
perform_downsample=True,
perform_pad=True,
perform_upsample=True,
perform_blur=True,
perform_offset=True):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by),
(self.pad_by, self.pad_by)),
'symmetric')
if perform_downsample:
input_image = np.float32(
mahotas.imresize(input_image, 1.0 / self.downsample))
layer_temp = input_image.reshape(1, input_image.shape[0],
input_image.shape[1])
for layeri in range(len(self.all_layers)):
layer_temp = self.all_layers[layeri].apply_layer(layer_temp)
output_image = layer_temp[0, :, :]
if perform_upsample:
output_image = np.float32(
mahotas.imresize(output_image, self.downsample))
if perform_blur:
output_image = scipy.ndimage.filters.gaussian_filter(
output_image, self.best_sigma)
if perform_offset:
#Translate
output_image = np.roll(output_image, self.best_offset[0], axis=0)
output_image = np.roll(output_image, self.best_offset[1], axis=1)
# Crop to valid size
output_image = output_image[self.pad_by:-self.pad_by,
self.pad_by:-self.pad_by]
return output_image
def output_image(data, layer, index, unpad_by, image_num=0, downsample=1):
data = data[unpad_by:data.shape[0] - unpad_by,
unpad_by:data.shape[1] - unpad_by]
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(
output_path + '/{0:04d}_classify_output_layer{1}_{2}.tif'.format(
image_num, layer, index), np.uint16(normdata * 65535))
def resized_img(url , percentage , output_url):
# image = cv2.imread(url)
image = mh.imread(url)
image = image[:,:,0]
# w , h = image.size
width = int(image.shape[1] * percentage)
height = int(image.shape[0] * percentage)
dim = (width , height)
# resized = cv2.resize(image , dim , interpolation=cv2.INTER_AREA)
resized = mh.imresize(image , nsize=dim,order=3)
cv2.imwrite(output_url,resized , [int(cv2.IMWRITE_PNG_COMPRESSION) , 10])
def extract(self):
'''Extracts morphology features to measure the size and shape of objects.
Returns
-------
pandas.DataFrame
extracted feature values for each object in `label_image`
'''
logger.info('extract morphology features')
features = list()
cm = mh.center_of_mass(img=self.label_image > 0,labels=self.label_image)
for obj in self.object_ids:
mask = self.get_object_mask_image(obj)
local_centroid_x = cm[obj][1]
local_centroid_y = cm[obj][0]
area = np.float64(np.count_nonzero(mask))
perimeter = mh.labeled.perimeter(mask)
if perimeter == 0:
circularity = np.nan
else:
circularity = (4.0 * np.pi * area) / (perimeter**2)
convex_hull = mh.polygon.fill_convexhull(mask)
area_convex_hull = np.count_nonzero(convex_hull)
convexity = area / area_convex_hull
eccentricity = mh.features.eccentricity(mask)
major_axis, minor_axis = mh.features.ellipse_axes(mask)
if major_axis == 0:
elongation = np.nan
else:
elongation = (major_axis - minor_axis) / major_axis
values = [
local_centroid_x, local_centroid_y, area, eccentricity, convexity, circularity, perimeter,
elongation
]
if self.compute_zernike:
logger.debug('extract Zernike moments for object #%d', obj)
r = 100
mask_rs = mh.imresize(mask, [r*2, r*2])
zernike_values = mh.features.zernike_moments(
mask_rs, degree=self._degree, radius=r
)
values.extend(zernike_values)
features.append(values)
return pd.DataFrame(features, columns=self.names, index=self.object_ids)
def get_images(data):
n_samples = len(data)
size = image_shape[0] * image_shape[1]
images = np.empty((n_samples, size))
for i, image in enumerate(data):
im = mh.imread(image)
im_grey = mh.colors.rgb2grey(im)
im_grey= mh.imresize(im_grey, image_shape)
images[i] = im_grey.ravel()
# global centering
images_centered = images - images.mean(axis=0)
# local centering
images_centered -= images_centered.mean(axis=1).reshape(n_samples, -1)
return images, images_centered
def imread(filename, longest=None):
if mahotas:
a = mahotas.imread(filename)
resize, width, height = newsize(a.shape[0], a.shape[1], longest)
if resize:
shape = list(a.shape)
a[0] = width
a[1] = height
a = mahotas.imresize(a, shape)
is16bit = a.dtype in (np.int16,np.uint16)
a = a.astype(np.float32)
if is16bit:
a /= 256.0
return a
img = Image.open(filename)
width, height = im.size
resize = newsize(width, height, longest)
if resize:
img = img.resize((width,height))
a = fromimage(img).astype(np.float32)
if len(a.shape) == 3 and a.shape[2] == 4:
print "Dropping alpha"
a = a[:,:,0:3]
return a
def salvatoriSnowCover(img_imglist, datetimelist, mask, settings, logger, red,
green, blue, middata, rectsw, extent, extent_proj, res,
dem, C, C_proj, Cz, hd, td, vd, f, w, interpolate, flat,
origin, ax, ay):
rectsw = bool(float(rectsw))
middata = bool(float(middata))
dummyImg = False
for img in img_imglist:
try:
mahotas.imread(img)
dummyImg = img
break
except:
pass
if not dummyImg:
logger.set("All images invalid.")
return False
if rectsw:
logger.set("Obtaining weight mask...")
params = map(np.copy, [
extent, extent_proj, res, dem, C, C_proj, Cz, hd, td, vd, f, w,
interpolate, flat, origin, ax, ay
])
auxfilename = False
from definitions import AuxDir, TmpDir
readydata = False
for hdf in os.listdir(AuxDir):
if "SNOWCOV001" in hdf:
try:
auxF = h5py.File(os.path.join(AuxDir, hdf), 'r')
readyfile = True
for i in range(len(params)):
attr = auxF['metadata'].attrs["param" + str(i)]
if np.prod(np.array([attr]).shape) == 1:
if (attr != params[i]):
readyfile = False
else:
if (attr != params[i]).any():
readyfile = False
if readyfile:
logger.set(
"Calculation has done before with same parameters, auxillary info is being read from file..."
)
tiles = np.copy(auxF['metadata'][...]).tolist()
for d in auxF:
if str(d) == 'metadata':
continue
varname = str(d).split()[0]
tilename = str(d).split()[1]
if len(tiles) == 1:
exec(varname + "= np.copy(auxF[d])")
else:
if varname not in locals():
exec(varname + '=None')
exec(varname + "=writeData(np.copy(auxF[d])," +
varname +
",map(int,tilename.split('-')))[0]")
auxF.close()
logger.set("\tRead.")
readydata = True
auxfilename = hdf
break
auxF.close()
except:
try:
auxF.close()
except:
continue
if not readydata:
Wp = Georectify1([dummyImg], [datetimelist[0]], mask, settings,
logger, extent, extent_proj, res, dem, C, C_proj,
Cz, hd, td, vd, f, w, interpolate, flat, origin,
ax, ay)[0][1][5]
logger.set('Writing results for next run...')
auxfilename = 'SNOWCOV001_' + str(uuid4()) + '.h5'
auxF = h5py.File(os.path.join(AuxDir, auxfilename), 'w')
tiles = [[0, 0, Wp.shape[0], Wp.shape[1]]]
auxF.create_dataset('metadata', data=np.array(tiles))
for i, p in enumerate(params):
auxF['metadata'].attrs.create("param" + str(i), p)
for i, tile in enumerate(tiles):
Wp_ = readData(Wp, tile)[0]
auxF.create_dataset('Wp ' + str(tile).replace(
', ', '-').replace('[', '').replace(']', ''),
Wp_.shape,
data=Wp_)
Wp_ = None
auxF.close()
Wp = Wp[::-1]
else:
Wp = np.ones(mahotas.imread(dummyImg).shape[:2])
mask, pgs, th = mask
mask = LensCorrRadial(mask, '0', logger, origin, ax, ay, 0)[0][1][1]
Wp *= (mask.transpose(2, 0, 1)[0] == 1)
if np.mean(mask) == 1:
logger.set("Weightmask quality: " + str(
np.sum(Wp[-100:, Wp.shape[1] / 2 - 50:Wp.shape[1] / 2 + 50] != 0) /
10000))
else:
logger.set("Weightmask quality: " +
str(1 - np.sum((Wp == 0) *
(mask.transpose(2, 0, 1)[0] == 1)) /
float(np.sum((mask.transpose(2, 0, 1)[0] == 1)))))
logger.set("Calculating snow cover fractions...")
scr = []
ssr = []
snr = []
mar = []
scn = []
ssn = []
snn = []
man = []
time = []
thr = []
thg = []
thb = []
Wp_full = deepcopy(Wp)
for i_img, imgf in enumerate(img_imglist):
try:
snow = 0
nosnow = 0
img = mahotas.imread(imgf)
if mask.shape != img.shape:
mask = maskers.polymask(img, pgs, logger)
Wp = mahotas.imresize(Wp_full, img.shape[:2])
(img,
thv) = salvatoriSnowDetect(img, mask * maskers.thmask(img, th),
settings, logger, red, green, blue)
# mimg = np.dstack((img==1,img==0,img==2)).astype(np.uint8)*255
if -1 in thv:
continue
time = np.append(time, (str(datetimelist[i_img])))
img = LensCorrRadial(img, str(datetimelist[i_img]), logger, origin,
ax, ay, 0)[0][1][1]
snow = np.sum(((img == 1) * Wp).astype(int))
nosnow = np.sum(((img == 0) * Wp).astype(int))
masked = np.sum(((img == 2) * Wp).astype(int))
scr = np.append(scr, snow / float(snow + nosnow))
if middata:
ssr = np.append(ssr, snow)
snr = np.append(snr, nosnow)
mar = np.append(mar, masked)
snow = np.sum(((img == 1)).astype(int))
nosnow = np.sum(((img == 0)).astype(int))
masked = np.sum(((img == 2)).astype(int))
scn = np.append(scn, snow / float(snow + nosnow))
ssn = np.append(ssn, snow)
snn = np.append(snn, nosnow)
man = np.append(man, masked)
thr = np.append(thr, thv[0])
thg = np.append(thg, thv[1])
thb = np.append(thb, thv[2])
except Exception as e:
print(e)
logger.set("Processing " + imgf + " failed.")
logger.set('Image: |progress:4|queue:' + str(i_img + 1) + '|total:' +
str(len(img_imglist)))
scr = np.round(scr * 100).astype(np.int32)
scn = np.round(scn * 100).astype(np.int32)
if middata:
return [[
"Snow Cover Fraction",
[
"Time", time, "Snow Cover Fraction", scr,
"Snow Cover Fraction - Non-Rectified", scn, "Threshold - Red",
thr, "Threshold - Green", thg, "Threshold - Blue", thb,
"Snow - Rectified", ssr, "Nosnow - Rectified", snr,
"Masked - Rectified", mar, "Snow - Non-Rectified", ssn,
"Nosnow - Non-Rectified", snn, "Masked - Non-Rectified", man
]
]]
else:
return [[
"Snow Cover Fraction", ["Time", time, "Snow Cover Fraction", scr]
]]
def apply_combo_net(self,
input_image,
block_size=400,
stump_input=None,
return_parts=False):
average_image = np.zeros(input_image.shape, dtype=np.float32)
parts = []
prev_downsample = 0
prev_pad_by = 0
start_time = time.clock()
for net_i in range(self.nnets):
net_input = stump_input if self.all_nets[
net_i].stumpin else input_image
downsample = self.all_nets[net_i].downsample
pad_by = self.all_nets[net_i].pad_by
# Downsample and pad
if prev_downsample != downsample or prev_pad_by != pad_by:
preprocessed_image = np.pad(net_input, ((pad_by, pad_by),
(pad_by, pad_by)),
'symmetric')
preprocessed_image = np.float32(
mahotas.imresize(preprocessed_image, 1.0 / downsample))
halo = int((pad_by + downsample - 1) / downsample)
# Compute in blocks (small edges)
block_x = range(halo, preprocessed_image.shape[0], block_size)
block_y = range(halo, preprocessed_image.shape[1], block_size)
# (full edges)
# block_x = range(halo, preprocessed_image.shape[0] - block_size + 1, block_size)
# block_y = range(halo, preprocessed_image.shape[1] - block_size + 1, block_size)
# if preprocessed_image.shape[0] % block_size > 0:
# block_x.append(max(halo, preprocessed_image.shape[0] - block_size - halo))
# if preprocessed_image.shape[1] % block_size > 0:
# block_y.append(max(halo, preprocessed_image.shape[1] - block_size - halo))
blocki = 0
nblocks = len(block_x) * len(block_y)
output_image = np.zeros(input_image.shape, dtype=np.float32)
for from_x in block_x:
for from_y in block_y:
# Crop out a padded input block
block = preprocessed_image[from_x - halo:from_x +
block_size + halo, from_y -
halo:from_y + block_size + halo]
# Apply network
output_block = self.all_nets[net_i].apply_net(
block, perform_downsample=False, perform_pad=False)
# Output block is not padded
to_x = (from_x - halo) * downsample
to_y = (from_y - halo) * downsample
output_image[to_x:to_x + output_block.shape[0], to_y:to_y +
output_block.shape[1]] = output_block
blocki += 1
print 'Block {0} of {1} complete.'.format(blocki, nblocks)
average_image += output_image
if return_parts:
parts.append(output_image)
print 'Net {0} of {1} complete.'.format(net_i + 1, self.nnets)
average_image /= self.nnets
end_time = time.clock()
print('Classification complete.')
print('Classification code ran for %.2fm' %
((end_time - start_time) / 60.))
return (average_image, parts) if return_parts else average_image
def get_blob_element(mask, rect, skel, num_blob_pixels, color, color_variance, grey, depth, label, is_subblob = False):
# Scale image for scale-invariant shape features
# Make it so the longest edge is equal to SHAPE_FEATURE_SIZE
resized_image = mahotas.imresize(mask,
float(SHAPE_FEATURE_SIZE) / max(mask.shape))
z_moments = zernike_moments(resized_image, SHAPE_FEATURE_SIZE, degree = Z_ORDER)
blob_element = xml.Element(label)
x_1 = rect[0]
y_1 = rect[1]
x_2 = x_1 + rect[2]
y_2 = y_1 + rect[3]
blob_element.attrib['x'] = str(rect[0])
blob_element.attrib['y'] = str(rect[1])
blob_element.attrib['width'] = str(rect[2])
blob_element.attrib['height'] = str(rect[3])
rect_center = (rect[0] + .5 * rect[2],
rect[1] + .5 * rect[3])
if (skel is not None and len(skel) > 0 ):
blob_element.attrib['head_dist'] = str(distance(rect_center,
skel['HEAD']['2d']))
blob_element.attrib['right_hand_dist'] = str(distance(rect_center,
skel['RIGHT_HAND']['2d']))
blob_element.attrib['left_hand_dist'] = str(distance(rect_center,
skel['LEFT_HAND']['2d']))
features_element = xml.Element('features')
blob_element.append(features_element)
size_element = xml.SubElement(features_element, 'size')
xml.SubElement(size_element, 'pixels').text = str(num_blob_pixels)
hu_element = get_hu_moments_element(mask)
features_element.append(hu_element)
grey_masked_image = grey & mask
blob_depth = depth & mask
if is_subblob:
blob_depth_rect = blob_depth
blob_mask_rect = mask
else:
blob_depth_rect = blob_depth[y_1:y_2, x_1:x_2]
blob_mask_rect = mask[y_1:y_2, x_1:x_2]
normal_vector_histogram = get_normal_vector_histogram(blob_depth_rect, blob_mask_rect.astype(numpy.uint8))
#print normal_vector_histogram
if normal_vector_histogram is None:
print 'Error calculating normal_vector_histogram'
return None
normal_histogram_element = xml.Element('normalhistogram')
for i in xrange(normal_vector_histogram.size):
xml.SubElement(normal_histogram_element, 'a_' + str(i)).text = str(normal_vector_histogram[i])
features_element.append(normal_histogram_element)
haralick_element = xml.Element('haralick')
haralick_features = haralick(grey_masked_image)
# Average the rows (the different directions of the features)
haralick_features_averaged = numpy.mean(haralick_features,axis=0)
#print len(haralick_features_averaged)
for i in xrange(NUM_HARALICK_FEATURES):
xml.SubElement(haralick_element, 'a_' + str(i)).text = str(haralick_features_averaged[i])
features_element.append(haralick_element)
zernike_element = xml.Element('zernike')
for i in xrange(Z_FEATURES):
xml.SubElement(zernike_element, 'a_' + str(i)).text = str(z_moments[i])
features_element.append(zernike_element)
rgb_element = xml.Element('rgb')
xml.SubElement(rgb_element, 'r').text = str(color[0])
xml.SubElement(rgb_element, 'g').text = str(color[1])
xml.SubElement(rgb_element, 'b').text = str(color[2])
features_element.append(rgb_element)
rgb_variance_element = xml.Element('rgb_var')
xml.SubElement(rgb_variance_element, 'r').text = str(color_variance[0])
xml.SubElement(rgb_variance_element, 'g').text = str(color_variance[1])
xml.SubElement(rgb_variance_element, 'b').text = str(color_variance[2])
features_element.append(rgb_variance_element)
return blob_element
def test_imresize():
img = np.repeat(np.arange(100), 10).reshape((100,10))
assert imresize(img, (1024,104)).shape == (1024,104)
assert imresize(img, (10.,10.)).shape == (1000,100)
assert imresize(img, .2,).shape == (20,2)
assert imresize(img, (10.,2.)).shape == (1000,20)
def apply_combo_net(self, input_image, block_size=400, stump_input=None, return_parts=False):
average_image = np.zeros(input_image.shape, dtype=np.float32)
parts = []
prev_downsample = 0
prev_pad_by = 0
start_time = time.clock()
for net_i in range(self.nnets):
net_input = stump_input if self.all_nets[net_i].stumpin else input_image
downsample = self.all_nets[net_i].downsample
pad_by = self.all_nets[net_i].pad_by
# Downsample and pad
if prev_downsample != downsample or prev_pad_by != pad_by:
preprocessed_image = np.pad(net_input, ((pad_by, pad_by), (pad_by, pad_by)), 'symmetric')
preprocessed_image = np.float32(mahotas.imresize(preprocessed_image, 1.0 / downsample))
halo = int((pad_by + downsample - 1) / downsample)
# Compute in blocks (small edges)
block_x = range(halo, preprocessed_image.shape[0], block_size)
block_y = range(halo, preprocessed_image.shape[1], block_size)
# (full edges)
# block_x = range(halo, preprocessed_image.shape[0] - block_size + 1, block_size)
# block_y = range(halo, preprocessed_image.shape[1] - block_size + 1, block_size)
# if preprocessed_image.shape[0] % block_size > 0:
# block_x.append(max(halo, preprocessed_image.shape[0] - block_size - halo))
# if preprocessed_image.shape[1] % block_size > 0:
# block_y.append(max(halo, preprocessed_image.shape[1] - block_size - halo))
blocki = 0
nblocks = len(block_x) * len(block_y)
output_image = np.zeros(input_image.shape, dtype=np.float32)
for from_x in block_x:
for from_y in block_y:
# Crop out a padded input block
block = preprocessed_image[from_x-halo:from_x+block_size+halo, from_y-halo:from_y+block_size+halo]
# Apply network
output_block = self.all_nets[net_i].apply_net(block, perform_downsample=False, perform_pad=False)
# Output block is not padded
to_x = (from_x - halo) * downsample
to_y = (from_y - halo) * downsample
output_image[to_x:to_x + output_block.shape[0], to_y:to_y + output_block.shape[1]] = output_block
blocki += 1
print 'Block {0} of {1} complete.'.format(blocki, nblocks)
average_image += output_image
if return_parts:
parts.append(output_image)
print 'Net {0} of {1} complete.'.format(net_i + 1, self.nnets)
average_image /= self.nnets
end_time = time.clock()
print('Classification complete.')
print('Classification code ran for %.2fm' % ((end_time - start_time) / 60.))
return (average_image, parts) if return_parts else average_image
# Main classification loop
for image_index in range(classify_start, classify_start + classify_n):
# Normalized training
input_image, target_image = open_image_and_gold(
image_index, crop_from, crop_size)
# Direct pixel intensity training
#input_image = np.float32(255-mahotas.imread(image_path_format_string.format(image_index))[crop_from[0]:crop_from[0]+crop_size,crop_from[1]:crop_from[1]+crop_size])
downsample = 1
if param_file.find('_ds2') != -1:
downsample = 2
input_image = np.float32(
mahotas.imresize(input_image, 1.0 / downsample))
elif param_file.find('_ds4') != -1:
downsample = 4
input_image = np.float32(
mahotas.imresize(input_image, 1.0 / downsample))
# Random rotate / mirror
# mirror = np.random.choice(2)
# rotate = np.random.choice(4)
# input_image = rotmir(input_image, mirror, rotate)
# target_image = rotmir(input_image, mirror, rotate)
#Pad the image borders so we get a full image output and to avoid edge effects
pad_image = np.pad(input_image, ((pad_by, pad_by), (pad_by, pad_by)),
'symmetric')
layer0_in = pad_image.reshape(1, pad_image.shape[0],
def get_features(train, images):
'''
Extract features for train or test images
------------------------------
Parameters
----------
train : Boolean
if Train, get features for train
images : ndarray
1-D array of image filepaths
Returns
----------
haralicks : ndarray
1-D flattened array of haralicks features
lbps : ndarray
1-D flattened array of linear binary patterns
labels : ndarray
1-D array of labels for train images
surf_descriptors : ndarray
1-D flattened array of surf descriptors feature
'''
haralicks = []
lbps = []
labels = []
alldescriptors = []
if train:
k = math.sqrt(22425/2)
path = 'objects/train/'
else:
k = math.sqrt(79727/2)
path = 'objects/test/'
object_dir_file_num = len([name for name in os.listdir(path) if name.endswith('.obj')])
if object_dir_file_num == 5:
haralicks = get_obj(train, 'haralicks')
lbps = get_obj(train, 'lbps')
labels = get_obj(train, 'labels')
surf_descriptors = get_obj(train, 'surfdescriptors')
else:
for i, fname in enumerate(images):
texture = compute_texture(fname)
binary_patt = compute_lbp(fname)
haralicks.append(texture)
lbps.append(binary_patt)
if train:
label = fname.split('/')[2]
labels.append(label)
im = mh.imresize(mh.imread(fname, as_grey=True), (600, 450))
im = im.astype(np.uint8)
# Dense sampling of surf
surf_desc = surf.dense(im, spacing=16)
# regular surf
# surf.surf(im, descriptor_only=True)
print('Image {}: {}'.format(i, surf_desc.shape))
alldescriptors.append(surf_desc)
concatenated = np.concatenate(alldescriptors)
print('Number of descriptors: {}'.format(
len(concatenated)))
concatenated = concatenated[::64]
km = get_kmeans(k, train, concatenated)
surf_descriptors = []
for d in alldescriptors:
c = km.predict(d)
surf_descriptors.append(np.bincount(c, minlength=k))
surf_descriptors = np.array(surf_descriptors, dtype=float)
haralicks = np.array(haralicks)
lbps = np.array(lbps)
labels = np.array(labels)
save_obj(train, 'surfdescriptors', surf_descriptors)
save_obj(train, 'haralicks', haralicks)
save_obj(train, 'lbps', lbps)
save_obj(train, 'labels', labels)
return haralicks, lbps, labels, surf_descriptors
def apply_net(self, input_image, perform_downsample=False, perform_pad=False, perform_upsample=False, perform_blur=False, perform_offset=False):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by), (self.pad_by, self.pad_by)), 'symmetric')
if perform_downsample and self.downsample != 1:
input_image = np.float32(mahotas.imresize(input_image, 1.0/self.downsample))
nx = input_image.shape[0] - self.pad_by*2
ny = input_image.shape[1] - self.pad_by*2
nbatches = nx * ny
input_batches = np.zeros((self.batch_size, self.layer0_channels, self.layer0_size, self.layer0_size), dtype=np.float32)
output = np.zeros(nbatches, dtype=np.float32)
#t_input_image = theano.shared(np.asarray(input_image,dtype=theano.config.floatX),borrow=True)
eval_network = theano.function([self.x], [self.all_layers[-1].output])
batch_count = 0
batch_start = 0
batchi = 0
for xi in range(nx):
for yi in range(ny):
input_batches[batchi, :, :, :] = input_image[xi : xi + self.pad_by * 2 + 1, yi : yi + self.pad_by * 2 + 1]
batchi += 1
if batchi == self.batch_size:
# Classify and reset
output[batch_start:batch_start + self.batch_size] = eval_network(input_batches)[0][:,0]
batch_count += 1
batch_start += self.batch_size
batchi = 0
if batch_count % 100 == 0:
print "Batch {0} done. Up to {1}.".format(batch_count, (xi, yi))
if batchi > 0:
output[batch_start:batch_start + batchi] = eval_network(input_batches)[0][:batchi,0]
output = output.reshape(nx, ny)
if perform_upsample:
output = np.float32(mahotas.imresize(output, self.downsample))
if perform_blur and self.best_sigma != 0:
output = scipy.ndimage.filters.gaussian_filter(output, self.best_sigma)
if perform_offset:
#Translate
output = np.roll(output, self.best_offset[0], axis=0)
output = np.roll(output, self.best_offset[1], axis=1)
# Crop to valid size
#output = output[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output
randnonmem = random.randrange(len(nonmembrane_indices[0]))
(samp_i, samp_j) = (nonmembrane_indices[0][randnonmem],
nonmembrane_indices[1][randnonmem])
membrane_type = "non-membrane"
samp_vol = np.zeros((imgd, imgd), dtype=np.uint8)
sample_img = input_vol[samp_i - min_border:samp_i + min_border,
samp_j - min_border:samp_j + min_border]
if np.random.uniform() > 0.5:
sample_img = sample_img[::-1, ...]
sample_img = np.rot90(sample_img, random.randrange(4))
if DOWNSAMPLE_BY != 1:
sample_img = np.uint8(
mahotas.imresize(sample_img, 1.0 / DOWNSAMPLE_BY))
mid_pix = min_border / DOWNSAMPLE_BY
if EVEN_OUTPUT:
samp_vol[:, :] = sample_img[mid_pix - imgrad:mid_pix + imgrad,
mid_pix - imgrad:mid_pix + imgrad]
else:
samp_vol[:, :] = sample_img[mid_pix - imgrad:mid_pix + imgrad +
1, mid_pix - imgrad:mid_pix +
imgrad + 1]
if display_output:
print 'Location ({0},{1},{2}).'.format(samp_i, samp_j, imgi)
output = zeros((imgd, imgd), dtype=uint8)
output[:, imgd] = samp_vol[:, :]
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path + '/{0:04d}_classify_output_layer{1}_{2}.tif'.format(image_num, layer, index), np.uint16(normdata * 65535))
# Main classification loop
for image_index in range(classify_start, classify_start + classify_n):
# Normalized training
input_image, target_image = open_image_and_gold(image_index, crop_from, crop_size)
# Direct pixel intensity training
#input_image = np.float32(255-mahotas.imread(image_path_format_string.format(image_index))[crop_from[0]:crop_from[0]+crop_size,crop_from[1]:crop_from[1]+crop_size])
downsample = 1
if param_file.find('_ds2') != -1:
downsample = 2
input_image = np.float32(mahotas.imresize(input_image, 1.0/downsample))
elif param_file.find('_ds4') != -1:
downsample = 4
input_image = np.float32(mahotas.imresize(input_image, 1.0/downsample))
# Random rotate / mirror
# mirror = np.random.choice(2)
# rotate = np.random.choice(4)
# input_image = rotmir(input_image, mirror, rotate)
# target_image = rotmir(input_image, mirror, rotate)
#Pad the image borders so we get a full image output and to avoid edge effects
pad_image = np.pad(input_image, ((pad_by, pad_by), (pad_by, pad_by)), 'symmetric')
layer0_in = pad_image.reshape(1, pad_image.shape[0], pad_image.shape[1])
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path + '/{0:04d}_classify_output_layer{1}_{2}.tif'.format(image_num, layer, index), np.uint16(normdata * 65535))
# Main classification loop
for image_index in range(classify_start, classify_start + classify_n):
# Normalized training
input_image, target_image = open_image_and_gold(image_index, crop_from, crop_size)
# Direct pixel intensity training
#input_image = np.float32(255-mahotas.imread(image_path_format_string.format(image_index))[crop_from[0]:crop_from[0]+crop_size,crop_from[1]:crop_from[1]+crop_size])
downsample = 1
if param_file.find('_ds2') != -1:
downsample = 2
input_image = np.float32(mahotas.imresize(input_image, 0.5))
# Random rotate / mirror
# mirror = np.random.choice(2)
# rotate = np.random.choice(4)
# input_image = rotmir(input_image, mirror, rotate)
# target_image = rotmir(input_image, mirror, rotate)
#Pad the image borders so we get a full image output and to avoid edge effects
pad_image = np.pad(input_image, ((pad_by, pad_by), (pad_by, pad_by)), 'symmetric')
layer0_in = pad_image.reshape(1, pad_image.shape[0], pad_image.shape[1])
start_time = time.clock()
#Classify image
layer_output = []
def extract(self):
'''Extracts morphology features to measure the size and shape of objects.
Returns
-------
pandas.DataFrame
extracted feature values for each object in `label_image`
'''
logger.info('extract morphology features')
distances = ndi.morphology.distance_transform_edt(self.label_image)
regionprops = measure.regionprops(label_image=self.label_image,
intensity_image=distances)
labels = []
features = []
for obj_props in regionprops:
obj = obj_props.label
mask = self.get_object_mask_image(obj)
roundness = mh.features.roundness(mask)
# calculate centroid, area and perimeter for selected object
if 'centroid' in obj_props: # skimage < 0.16
local_centroid_y, local_centroid_x = obj_props.centroid
elif 'centroidarray' in obj_props: # skimage >= 0.16
local_centroid_y, local_centroid_x = obj_props.centroidarray
else:
logger.error(
"No centroid coordinates computed for object with label %s"
" -- using `NaN` instead!", obj)
local_centroid_x = np.NaN
local_centroid_y = np.NaN
area = obj_props.area
perimeter = obj_props.perimeter
extent = obj_props.extent
# calculate circularity (a.k.a. form factor)
if perimeter == 0:
circularity = np.nan
else:
circularity = (4.0 * np.pi * area) / (perimeter**2)
# calculate convexity (a.k.a solidity)
area_convex_hull = obj_props.convex_area
convexity = area / float(area_convex_hull)
# calculate ellipse features
eccentricity = obj_props.eccentricity
equivalent_diameter = obj_props.equivalent_diameter
major_axis = obj_props.major_axis_length
minor_axis = obj_props.minor_axis_length
if major_axis == 0:
elongation = np.nan
else:
elongation = (major_axis - minor_axis) / major_axis
# calculate "distance" features
max_radius = obj_props.max_intensity
mean_radius = obj_props.mean_intensity
values = [
local_centroid_x, local_centroid_y, area, perimeter,
eccentricity, extent, convexity, circularity, roundness,
elongation, equivalent_diameter, major_axis, minor_axis,
max_radius, mean_radius
]
if self.compute_zernike:
logger.debug('extract Zernike moments for object #%d', obj)
r = 100
mask_rs = mh.imresize(mask, [r * 2, r * 2])
zernike_values = mh.features.zernike_moments(
mask_rs, degree=self._degree, radius=r)
values.extend(zernike_values)
features.append(values)
labels.append(obj)
if len(set(labels)) != len(self.object_ids):
logger.error(
'Number of unique objects with measurements returned by'
' regionprops ({}) does not match the number'
' of labels ({})'.format(len(set(labels)),
len(self.object_ids)))
raise PipelineRunError()
return pd.DataFrame(features, columns=self.names, index=labels)
def normalize_image(original_image, saturation_level=0.005, invert=True):
sorted_image = np.sort( np.uint8(original_image).ravel() )
minval = np.float32( sorted_image[ len(sorted_image) * ( saturation_level / 2 ) ] )
maxval = np.float32( sorted_image[ len(sorted_image) * ( 1 - saturation_level / 2 ) ] )
norm_image = np.float32(original_image - minval) * ( 255 / (maxval - minval))
norm_image[norm_image < 0] = 0
norm_image[norm_image > 255] = 255
if invert:
norm_image = 255 - norm_image
return np.uint8(norm_image)
input_image = np.float32(normalize_image(mahotas.imread(input_image_file), invert=(not image_inverted)))
stump_image = np.float32(normalize_image(mahotas.imread(input_stump_file), invert=(not image_inverted)))
if image_downsample_factor != 1:
input_image = mahotas.imresize(input_image, image_downsample_factor)
stump_image = mahotas.imresize(stump_image, image_downsample_factor)
average_image = combo_net.apply_combo_net(input_image, stump_input=stump_image)
if image_downsample_factor != 1:
average_image = np.float32(mahotas.imresize(average_image, 1.0 / image_downsample_factor))
temp_path = output_file + '_tmp'
out_hdf5 = h5py.File(temp_path, 'w')
# copy the probabilities for future use
probs_out = out_hdf5.create_dataset('probabilities',
data = average_image,
chunks = (64,64),
compression = 'gzip')
out_hdf5.close()
(1 - saturation_level / 2)])
norm_image = np.float32(original_image - minval) * (255 /
(maxval - minval))
norm_image[norm_image < 0] = 0
norm_image[norm_image > 255] = 255
if invert:
norm_image = 255 - norm_image
return np.uint8(norm_image)
input_image = np.float32(
normalize_image(mahotas.imread(input_image_path),
invert=(not image_inverted)))
if image_downsample_factor != 1:
input_image = mahotas.imresize(input_image, image_downsample_factor)
average_image = combo_net.apply_combo_net(input_image)
def write_image(output_path, data, image_num=0, downsample=1):
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path, np.uint16(normdata * 65535))
write_image(output_image_path, average_image)
from sklearn.svm import SVC
from sklearn.cross_validation import train_test_split
from sklearn.grid_search import GridSearchCV
from sklearn.metrics import classification_report
if __name__ == '__main__':
X = []
y = []
for path, subdirs, files in os.walk('data/English/Img/GoodImg/Bmp/'):
for filename in files:
f = os.path.join(path, filename)
target = filename[3:filename.index('-')]
img = mh.imread(f, as_grey=True)
if img.shape[0] <= 30 or img.shape[1] <= 30:
continue
img_resized = mh.imresize(img, (30, 30))
if img_resized.shape != (30, 30):
img_resized = mh.imresize(img_resized, (30, 30))
X.append(img_resized.reshape((900, 1)))
y.append(target)
X = np.array(X)
X = X.reshape(X.shape[:2])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.1)
pipeline = Pipeline([('clf', SVC(kernel='rbf', gamma=0.01, C=100))])
parameters = {
'clf__gamma': (0.01, 0.03, 0.1, 0.3, 1),
'clf__C': (0.1, 0.3, 1, 3, 10, 30),
}
grid_search = GridSearchCV(pipeline,
parameters,
n_jobs=3,
def normalize_image(original_image, saturation_level=0.005, invert=True):
sorted_image = np.sort( np.uint8(original_image).ravel() )
minval = np.float32( sorted_image[ len(sorted_image) * ( saturation_level / 2 ) ] )
maxval = np.float32( sorted_image[ len(sorted_image) * ( 1 - saturation_level / 2 ) ] )
norm_image = np.float32(original_image - minval) * ( 255 / (maxval - minval))
norm_image[norm_image < 0] = 0
norm_image[norm_image > 255] = 255
if invert:
norm_image = 255 - norm_image
return np.uint8(norm_image)
input_image = np.float32(normalize_image(mahotas.imread(input_image_path), invert=(not image_inverted)))
if image_downsample_factor != 1:
input_image = mahotas.imresize(input_image, image_downsample_factor)
average_image = combo_net.apply_combo_net(input_image)
def write_image (output_path, data, image_num=0, downsample=1):
if downsample != 1:
data = np.float32(mahotas.imresize(data, downsample))
maxdata = np.max(data)
mindata = np.min(data)
normdata = (np.float32(data) - mindata) / (maxdata - mindata)
mahotas.imsave(output_path, np.uint16(normdata * 65535))
write_image(output_image_path, average_image)
print 'Classification complete.'
def step(frame, file_time, output_file = None):
global g_adjacency, g_max, g_prev, g_colors, g_feat, g_gray, g_rgb, g_rgbfeat, g_blobidx, g_blobidxset, g_myrect, g_myhist
global current_frame_time, xml_root
global g_last_depth, g_last_depth_change
#global g_frameidx
#ni.show_frame(frame)
num_kinects = frame['num_kinects']
if num_kinects == 0:
return
depth = numpy.array(frame['depths'][0])
rgb = numpy.array(frame['images'][0])
cvmod.set_depth(depth.ravel())
g_sa = 0.
if g_showall:
g_sa = 1.
var = numpy.array([gx1, gx2, gy1, gy2, gz1, gz2, gd1, gd2, g_sa], dtype=numpy.float)
cvmod.set_vars(var)
if not BATCH_MODE and not BATCH_BLOB_MODE:
cvmod.output3d()
cvmod.process_blob()
adj = numpy.array(g_adjacency, dtype=numpy.uint8) * 255
adj = cv2.erode(adj, None)
adj = cv2.erode(adj, None)
adj = cv2.erode(adj, None)
if not BATCH_MODE and not BATCH_BLOB_MODE:
## cv2.imshow('Depth', depth_change)
## cv2.waitKey(10)
cv2.imshow('ADJ', adj)
cv2.waitKey(10)
max_idx, img, rects = maskblob.createblobmask(adj)
#print 'Rects',rects
if g_prev == None:
g_max, g_prev = max_idx, img
for i in range(max_idx):
g_colors.append(get_rcol())
return
## print "print", g_max, max_idx
new_g_colors = [None]
if not BATCH_MODE:
if g_feat != None:
nextPts, status, err = cv2.calcOpticalFlowPyrLK(g_gray, gorig, g_feat, None, winSize=(15, 15), maxLevel=5)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_feat[i][0]
#cv2.circle(cmask, (x1, y1), 4., (0, 0, 255), -1)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
#if dx*dx+dy*dy < 70*70:
# cv2.line(cmask, (x1, y1), (x2, y2), (0, 255, 0), 3)
ass_mat = numpy.zeros((max_idx, g_max), dtype=numpy.uint8)
for idx1 in range(1, g_max+1):
bmask = maskblob.getblob(g_prev, idx1)
bmask = cv2.dilate(bmask, None)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_feat[i][0]
if bmask[y1][x1] > 0:
for idx2 in range(1, max_idx+1):
dmask = maskblob.getblob(img, idx2)
dmask = cv2.dilate(dmask, None)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
if dx*dx+dy*dy < 70*70:
if dmask[y2][x2] > 0:
ass_mat[idx2-1][idx1-1] += 1
cv2.line(cmask, (x1, y1), (x2, y2), (0, 255, 0), 1)
if not BATCH_MODE and not BATCH_BLOB_MODE:
print ass_mat
for i in range(max_idx):
k = ass_mat[i]
if numpy.max(k) > 0:
p = numpy.argmax(k)
blobidxset[i] = g_blobidxset[p]
if not BATCH_MODE and not BATCH_BLOB_MODE:
print blobidxset
# End Batch
if len(rects) > 0:
a0, b0, w0, h0 = rects[0]
a1 = a0+w0
b1 = b0+h0
## cv2.rectangle(cmask, (a0, b0), (a1, b1), (255, 255, 255), 5)
else:
a0 = 0
b0 = 0
a1 = 630
b1 = 470
if g_myrect == None:
g_myrect = a0, b0, a1, b1
g_myhist = get_histogram(rgb, a0, b0, a1, b1)
#show_histogram(g_myhist)
else:
frame_element = xml.SubElement(xml_root,'frame')
frame_element.attrib['timestamp'] = str(current_frame_time)
## frame_element.attrib['confidence'] = str(numpy.std(prob_vector * hsv))
skeleton_element = xml.SubElement(frame_element,'skeleton')
if not (frame['skel'][0]['HEAD']['2d'][0] == 0 and
frame['skel'][0]['HEAD']['2d'][1] == 0):
xmlhelper.generate_skeleton_xml(frame, skeleton_element)
blobs_element = xml.SubElement(frame_element,'blobs')
#print 'Max prob: ', numpy.max(prob)
if output_file is not None:
blue_channel = rgb[:,:,0]
green_channel = rgb[:,:,1]
red_channel = rgb[:,:,2]
for blob_num in range(0, max_idx):
blob_mask = maskblob.getblob(img,blob_num + 1)
num_blob_pixels = numpy.sum(blob_mask, dtype=numpy.int32) / 255
if num_blob_pixels <= 8:
continue
## num_prob_pixels = numpy.sum(prob * blob_mask, dtype=numpy.int32) / 255
x_1 = rects[blob_num][0]
y_1 = rects[blob_num][1]
x_2 = x_1 + rects[blob_num][2]
y_2 = y_1 + rects[blob_num][3]
## blob_prob = prob * (blob_mask / 255)
## blob_attention = numpy.sum(blob_prob) / numpy.sum(prob)
blob_red = red_channel & blob_mask
red_value = numpy.sum(blob_red, dtype=numpy.int32) / num_blob_pixels
red_variance = numpy.std(blob_red[blob_red.nonzero()])
blob_red_rect = blob_red[x_1:x_2, y_1:y_2]
blob_green = green_channel & blob_mask
green_value = numpy.sum(blob_green, dtype=numpy.int32) / num_blob_pixels
green_variance = numpy.std(blob_green[blob_green.nonzero()])
blob_green_rect = blob_green[x_1:x_2, y_1:y_2]
blob_blue = blue_channel & blob_mask
blue_value = numpy.sum(blob_blue, dtype=numpy.int32) / num_blob_pixels
blue_variance = numpy.std(blob_blue[blob_blue.nonzero()])
blob_blue_rect = blob_blue[x_1:x_2, y_1:y_2]
blob_depth = depth & blob_mask
max_depth = numpy.max(blob_depth[blob_depth.nonzero()])
min_depth = numpy.min(blob_depth[blob_depth.nonzero()])
blob_color_rect = numpy.zeros((rects[blob_num][2], rects[blob_num][3], 3), numpy.uint8)
moments = cv2.moments(blob_mask)
hu_moments = cv2.HuMoments(moments)
# Scale image for scale-invariant shape features
resized_image = mahotas.imresize(blob_mask,
float(SHAPE_FEATURE_SIZE) / max(blob_mask.shape))
z_moments = zernike_moments(resized_image, SHAPE_FEATURE_SIZE, degree = Z_ORDER)
blob_element = xml.Element('blob')
blobs_element.append(blob_element)
blob_element.attrib['x'] = str(rects[blob_num][0])
blob_element.attrib['y'] = str(rects[blob_num][1])
blob_element.attrib['width'] = str(rects[blob_num][2])
blob_element.attrib['height'] = str(rects[blob_num][3])
rect_center = (rects[blob_num][0] + .5 * rects[blob_num][2],
rects[blob_num][1] + .5 * rects[blob_num][3])
blob_element.attrib['head_dist'] = str(distance(rect_center,
frame['skel'][0]['HEAD']['2d']))
blob_element.attrib['right_hand_dist'] = str(distance(rect_center,
frame['skel'][0]['RIGHT_HAND']['2d']))
blob_element.attrib['left_hand_dist'] = str(distance(rect_center,
frame['skel'][0]['LEFT_HAND']['2d']))
features_element = xml.Element('features')
blob_element.append(features_element)
size_element = xml.Element('size')
xml.SubElement(size_element, 'pixels').text = str(num_blob_pixels)
features_element.append(size_element)
hu_element = xml.Element('hu')
xml.SubElement(hu_element, 'i_1').text = str(hu_moments[0][0])
xml.SubElement(hu_element, 'i_2').text = str(hu_moments[1][0])
xml.SubElement(hu_element, 'i_3').text = str(hu_moments[2][0])
xml.SubElement(hu_element, 'i_4').text = str(hu_moments[3][0])
xml.SubElement(hu_element, 'i_5').text = str(hu_moments[4][0])
xml.SubElement(hu_element, 'i_6').text = str(hu_moments[5][0])
xml.SubElement(hu_element, 'i_7').text = str(hu_moments[6][0])
features_element.append(hu_element)
zernike_element = xml.Element('zernike')
for i in xrange(Z_FEATURES):
xml.SubElement(zernike_element, 'a_' + str(i)).text = str(z_moments[i])
features_element.append(zernike_element)
rgb_element = xml.Element('rgb')
xml.SubElement(rgb_element, 'r').text = str(red_value)
xml.SubElement(rgb_element, 'g').text = str(green_value)
xml.SubElement(rgb_element, 'b').text = str(blue_value)
features_element.append(rgb_element)
rgb_variance_element = xml.Element('rgb_var')
xml.SubElement(rgb_variance_element, 'r').text = str(red_variance)
xml.SubElement(rgb_variance_element, 'g').text = str(green_variance)
xml.SubElement(rgb_variance_element, 'b').text = str(blue_variance)
features_element.append(rgb_variance_element)
if not BATCH_MODE:
grayrgb = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)
grayrgborig = cv2.cvtColor(rgb, cv2.COLOR_BGR2GRAY)
grayrgbfeat = show_features(grayrgb, 500)
if g_rgbfeat != None:
nextPts, status, err = cv2.calcOpticalFlowPyrLK(g_rgb, grayrgborig, g_rgbfeat, None, winSize=(15, 15), maxLevel=5)
for i in range(len(nextPts)):
if status[i][0] == 1:
x1, y1 = g_rgbfeat[i][0]
#cv2.circle(rgb, (x1, y1), 4., (0, 0, 255), -1)
x2, y2 = nextPts[i][0]
dx = abs(x1-x2)
dy = abs(y1-y2)
if dx*dx+dy*dy < 30*30:
cv2.line(rgb, (x1, y1), (x2, y2), (0, 255, 0), 1)
f = cv2.calcOpticalFlowFarneback(g_rgb, grayrgborig, None, .5, 3, 15, 3, 5, 1.2, 0)
print f.shape
g_rgb = grayrgborig
g_rgbfeat = grayrgbfeat
if not BATCH_BLOB_MODE:
## cv2.imshow('MAS', cmask)
## cv2.waitKey(10)
## cv2.imshow('GAS', gmask)
## cv2.waitKey(10)
cv2.imshow('Gray',g_gray)
cv2.waitKey(10)
cv2.imshow('IMG', rgb)
cv2.waitKey(10)
if BATCH_MODE or BATCH_BLOB_MODE:
print numpy.max(depth)
print cv2.imwrite(file_time + 'rgb.jpg',rgb)
print cv2.imwrite(file_time + 'd.jpg',numpy.divide(depth,12))
def apply_net(
self,
input_image,
perform_downsample=False,
perform_pad=False,
perform_upsample=False,
perform_blur=False,
perform_offset=False,
):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by), (self.pad_by, self.pad_by)), "symmetric")
if perform_downsample and self.downsample != 1:
input_image = np.float32(mahotas.imresize(input_image, 1.0 / self.downsample))
nx = input_image.shape[0] - self.all_layers[0].input_footprint + 1
ny = input_image.shape[1] - self.all_layers[0].input_footprint + 1
nbatches = nx * ny
layer_temp = np.zeros(
(nbatches, 1, self.all_layers[0].input_footprint, self.all_layers[0].input_footprint), dtype=np.float32
)
print layer_temp.shape
batchi = 0
for x in range(nx):
for y in range(ny):
# print (x,y)
layer_temp[batchi, :, :, :] = input_image[
x : (x + self.all_layers[0].input_footprint), y : (y + self.all_layers[0].input_footprint)
]
batchi += 1
assert batchi == nbatches
output = np.zeros(nbatches, dtype=np.float32)
for block in range(nbatches / BLOCK_BATCHES + 1):
block_from = block * BLOCK_BATCHES
block_to = min((block + 1) * BLOCK_BATCHES, layer_temp.shape[0])
nbatches = block_to - block_from
block_temp = layer_temp[block_from:block_to, :, :, :]
for layeri in range(len(self.all_layers)):
print layeri
start_time = time.clock()
block_temp = self.all_layers[layeri].apply_layer(block_temp, nbatches)
end_time = time.clock()
print ("Layer time = %.2fm" % ((end_time - start_time) / 60.0))
if isinstance(block_temp, gpuarray.GPUArray):
block_temp = block_temp.get()
output[block_from:block_to] = block_temp[:, 0, 0, 0]
output = output.reshape(nx, ny)
if perform_upsample:
output = np.float32(mahotas.imresize(output, self.downsample))
if perform_blur and self.best_sigma != 0:
output = scipy.ndimage.filters.gaussian_filter(output, self.best_sigma)
if perform_offset:
# Translate
output = np.roll(output, self.best_offset[0], axis=0)
output = np.roll(output, self.best_offset[1], axis=1)
# Crop to valid size
# output = output[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output
else:
randnonmem = random.choice(len(nonmembrane_indices[0]))
(samp_i, samp_j) = (nonmembrane_indices[0][randnonmem], nonmembrane_indices[1][randnonmem])
membrane_type = "non-membrane"
# rotate by a random amount (linear interpolation)
rotation = random.random()*360
samp_vol = zeros((imgd, imgd, zd), dtype=uint8)
for zoffset in range(zd):
sample_img = input_vol[samp_i-min_border:samp_i+min_border, samp_j-min_border:samp_j+min_border, zoffset]
sample_img = scipy.misc.imrotate(sample_img, rotation)
if DOWNSAMPLE_BY != 1:
sample_img = np.uint8(mahotas.imresize(sample_img, 1.0 / DOWNSAMPLE_BY))
mid_pix = min_border / DOWNSAMPLE_BY
if EVEN_OUTPUT:
samp_vol[:,:,zoffset] = sample_img[mid_pix-imgrad:mid_pix+imgrad, mid_pix-imgrad:mid_pix+imgrad]
else:
samp_vol[:,:,zoffset] = sample_img[mid_pix-imgrad:mid_pix+imgrad+1, mid_pix-imgrad:mid_pix+imgrad+1]
if display_output:
print 'Location ({0},{1},{2}).'.format(samp_i, samp_j, imgi)
output = zeros((imgd, imgd * zd), dtype=uint8)
for out_z in range(zd):
output[:,out_z * imgd : (out_z + 1) * imgd] = samp_vol[:,:,out_z]
figure(figsize=(5, 5 * zd))
title(membrane_type)
def apply_net(self,
input_image,
perform_downsample=False,
perform_pad=False,
perform_upsample=False,
perform_blur=False,
perform_offset=False):
if perform_pad:
input_image = np.pad(input_image, ((self.pad_by, self.pad_by),
(self.pad_by, self.pad_by)),
'symmetric')
if perform_downsample and self.downsample != 1:
input_image = np.float32(
mahotas.imresize(input_image, 1.0 / self.downsample))
nx = input_image.shape[0] - self.all_layers[0].input_footprint + 1
ny = input_image.shape[1] - self.all_layers[0].input_footprint + 1
nbatches = nx * ny
layer_temp = np.zeros((nbatches, 1, self.all_layers[0].input_footprint,
self.all_layers[0].input_footprint),
dtype=np.float32)
print layer_temp.shape
batchi = 0
for x in range(nx):
for y in range(ny):
#print (x,y)
layer_temp[batchi, :, :, :] = input_image[x:(
x + self.all_layers[0].input_footprint), y:(
y + self.all_layers[0].input_footprint)]
batchi += 1
assert batchi == nbatches
output = np.zeros(nbatches, dtype=np.float32)
for block in range(nbatches / BLOCK_BATCHES + 1):
block_from = block * BLOCK_BATCHES
block_to = min((block + 1) * BLOCK_BATCHES, layer_temp.shape[0])
nbatches = block_to - block_from
block_temp = layer_temp[block_from:block_to, :, :, :]
for layeri in range(len(self.all_layers)):
print layeri
start_time = time.clock()
block_temp = self.all_layers[layeri].apply_layer(
block_temp, nbatches)
end_time = time.clock()
print('Layer time = %.2fm' % ((end_time - start_time) / 60.))
if isinstance(block_temp, gpuarray.GPUArray):
block_temp = block_temp.get()
output[block_from:block_to] = block_temp[:, 0, 0, 0]
output = output.reshape(nx, ny)
if perform_upsample:
output = np.float32(mahotas.imresize(output, self.downsample))
if perform_blur and self.best_sigma != 0:
output = scipy.ndimage.filters.gaussian_filter(
output, self.best_sigma)
if perform_offset:
#Translate
output = np.roll(output, self.best_offset[0], axis=0)
output = np.roll(output, self.best_offset[1], axis=1)
# Crop to valid size
#output = output[self.pad_by:-self.pad_by,self.pad_by:-self.pad_by]
return output
from sklearn.svm import SVC
from sklearn.cross_validation import train_test_split
from sklearn.grid_search import GridSearchCV
from sklearn.metrics import classification_report
if __name__ == '__main__':
X = []
y = []
for path, subdirs, files in os.walk('data/English/Img/GoodImg/Bmp/'):
for filename in files:
f = os.path.join(path, filename)
target = filename[3:filename.index('-')]
img = mh.imread(f, as_grey=True)
if img.shape[0] <= 30 or img.shape[1] <= 30:
continue
img_resized = mh.imresize(img, (30, 30))
if img_resized.shape != (30, 30):
img_resized = mh.imresize(img_resized, (30, 30))
X.append(img_resized.reshape((900, 1)))
y.append(target)
X = np.array(X)
X = X.reshape(X.shape[:2])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.1)
pipeline = Pipeline([
('clf', SVC(kernel='rbf', gamma=0.01, C=100))
])
parameters = {
'clf__gamma': (0.01, 0.03, 0.1, 0.3, 1),
'clf__C': (0.1, 0.3, 1, 3, 10, 30),
}
grid_search = GridSearchCV(pipeline, parameters, n_jobs=3, verbose=1, scoring='accuracy')
Warp_strength= 12.14
# Thresholding parameters (for post processing after the edge is computed)
Threshold_min = -1
Threshold_max = 0.0019
# [] Choose to compute the analog or digital edge,
Morph_flag =1 # [] To compute analog edge, set Morph_flag=0 and to compute digital edge, set Morph_flag=1
[Edge, PST_Kernel]= PST(Image_orig_grey, LPF, Phase_strength, Warp_strength, Threshold_min, Threshold_max, Morph_flag)
if Morph_flag ==0:
Edge = (Edge/np.max(Edge))*3
else:
Overlay=mh.overlay(Image_orig_grey,Edge)
image=Edge.astype(np.uint8)*255
new_image=mh.imresize(image, (224,224))
# convert from Numpy to a list of values
swim.append(new_image)
if count%50==0:
print(count)
count+=1
if count>2000: #I added this limit because my comp/ google Colab couldn't handle more data than that
break
except:
pass
count+=1
print(count)
#Save/ load the list to/from a file
os.chdir("/content/gdrive/My Drive/Colab Notebooks/Motion_Net")
