def _get_scaled_img(self, npimg, scale):
get_base_scale = lambda s, w, h: max(self.target_size[0] / float(
h), self.target_size[1] / float(w)) * s
img_h, img_w = npimg.shape[:2]
if scale is None:
if npimg.shape[:2] != (self.target_size[1], self.target_size[0]):
# resize
npimg = cv2.resize(npimg,
self.target_size,
interpolation=cv2.INTER_CUBIC)
return [npimg], [(0.0, 0.0, 1.0, 1.0)]
elif isinstance(scale, float):
# scaling with center crop
base_scale = get_base_scale(scale, img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
o_size_h, o_size_w = npimg.shape[:2]
if npimg.shape[0] < self.target_size[1] or npimg.shape[
1] < self.target_size[0]:
newimg = np.zeros(
(max(self.target_size[1], npimg.shape[0]),
max(self.target_size[0], npimg.shape[1]), 3),
dtype=np.uint8)
newimg[:npimg.shape[0], :npimg.shape[1], :] = npimg
npimg = newimg
windows = sw.generate(npimg, sw.DimOrder.HeightWidthChannel,
self.target_size[0], self.target_size[1],
0.2)
rois = []
ratios = []
for window in windows:
indices = window.indices()
roi = npimg[indices]
rois.append(roi)
ratio_x, ratio_y = float(indices[1].start) / o_size_w, float(
indices[0].start) / o_size_h
ratio_w, ratio_h = float(indices[1].stop -
indices[1].start) / o_size_w, float(
indices[0].stop -
indices[0].start) / o_size_h
ratios.append((ratio_x, ratio_y, ratio_w, ratio_h))
return rois, ratios
elif isinstance(scale, tuple) and len(scale) == 2:
# scaling with sliding window : (scale, step)
base_scale = get_base_scale(scale[0], img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
o_size_h, o_size_w = npimg.shape[:2]
if npimg.shape[0] < self.target_size[1] or npimg.shape[
1] < self.target_size[0]:
newimg = np.zeros(
(max(self.target_size[1], npimg.shape[0]),
max(self.target_size[0], npimg.shape[1]), 3),
dtype=np.uint8)
newimg[:npimg.shape[0], :npimg.shape[1], :] = npimg
npimg = newimg
window_step = scale[1]
windows = sw.generate(npimg, sw.DimOrder.HeightWidthChannel,
self.target_size[0], self.target_size[1],
window_step)
rois = []
ratios = []
for window in windows:
indices = window.indices()
roi = npimg[indices]
rois.append(roi)
ratio_x, ratio_y = float(indices[1].start) / o_size_w, float(
indices[0].start) / o_size_h
ratio_w, ratio_h = float(indices[1].stop -
indices[1].start) / o_size_w, float(
indices[0].stop -
indices[0].start) / o_size_h
ratios.append((ratio_x, ratio_y, ratio_w, ratio_h))
return rois, ratios
elif isinstance(scale, tuple) and len(scale) == 3:
# scaling with ROI : (want_x, want_y, scale_ratio)
base_scale = get_base_scale(scale[2], img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
ratio_w = self.target_size[0] / float(npimg.shape[1])
ratio_h = self.target_size[1] / float(npimg.shape[0])
want_x, want_y = scale[:2]
ratio_x = want_x - ratio_w / 2.
ratio_y = want_y - ratio_h / 2.
ratio_x = max(ratio_x, 0.0)
ratio_y = max(ratio_y, 0.0)
if ratio_x + ratio_w > 1.0:
ratio_x = 1. - ratio_w
if ratio_y + ratio_h > 1.0:
ratio_y = 1. - ratio_h
roi = self._crop_roi(npimg, ratio_x, ratio_y)
return [roi], [(ratio_x, ratio_y, ratio_w, ratio_h)]
def compute_windows(image,pixels,overlap):
im = Image.open('/Users/ben/Documents/DeepForest/data/2017_OSBS_3_400000_3287000_image.tif')
data = np.array(im)
windows = sw.generate(image, sw.DimOrder.HeightWidthChannel, 250, 0.05)
return(windows)
def _get_scaled_img(self, npimg, scale, use_pad=False, box_size=None):
get_base_scale = lambda s, w, h: max(self.target_size[0] / float(
h), self.target_size[1] / float(w)) * s
img_h, img_w = npimg.shape[:2]
if scale is None:
if npimg.shape[:2] != (self.target_size[1], self.target_size[0]):
# resize
npimg = cv2.resize(npimg,
self.target_size,
interpolation=cv2.INTER_CUBIC)
return [npimg], [(0.0, 0.0, 1.0, 1.0)]
elif isinstance(scale, float) and use_pad:
print('scale' + str(scale))
print(npimg.shape)
npimg = cv2.resize(npimg,
dsize=None,
fx=scale,
fy=scale,
interpolation=cv2.INTER_CUBIC)
bbox = [box_size, np.max([box_size, np.shape(npimg)[1]])]
# pad height
pad = np.zeros((4, ), dtype=int)
h, w, _ = np.shape(npimg)
h = np.min([bbox[0], h])
bbox[0] = np.ceil(bbox[0] / 8) * 8
bbox[1] = np.max([bbox[1], w])
bbox[1] = np.ceil(bbox[1] / 8) * 8
pad[0] = int(np.floor((bbox[0] - h) / 2)) # up
pad[1] = int(np.floor((bbox[1] - w) / 2)) # left
pad[2] = int(bbox[0] - h - pad[0]) # down
pad[3] = int(bbox[1] - w - pad[1]) # right
pad_up = np.ones(
(pad[0], np.shape(npimg)[1], np.shape(npimg)[2])) * 0.5
npimg = np.concatenate([pad_up, npimg], axis=0)
pad_left = np.ones(
(np.shape(npimg)[0], pad[1], np.shape(npimg)[2])) * 0.5
npimg = np.concatenate([pad_left, npimg], axis=1)
pad_down = np.ones(
(pad[2], np.shape(npimg)[1], np.shape(npimg)[2])) * 0.5
npimg = np.concatenate([npimg, pad_down], axis=0)
pad_right = np.ones(
(np.shape(npimg)[0], pad[3], np.shape(npimg)[2])) * 0.5
npimg = np.concatenate([npimg, pad_right], axis=1)
return npimg, pad
elif isinstance(scale, float):
# scaling with center crop
base_scale = get_base_scale(scale, img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
o_size_h, o_size_w = npimg.shape[:2]
if npimg.shape[0] < self.target_size[1] or npimg.shape[
1] < self.target_size[0]:
newimg = np.zeros(
(max(self.target_size[1], npimg.shape[0]),
max(self.target_size[0], npimg.shape[1]), 3),
dtype=np.uint8)
newimg[:npimg.shape[0], :npimg.shape[1], :] = npimg
npimg = newimg
windows = sw.generate(npimg, sw.DimOrder.HeightWidthChannel,
self.target_size[0], self.target_size[1],
0.2)
rois = []
ratios = []
for window in windows:
indices = window.indices()
roi = npimg[indices]
rois.append(roi)
ratio_x, ratio_y = float(indices[1].start) / o_size_w, float(
indices[0].start) / o_size_h
ratio_w, ratio_h = float(indices[1].stop -
indices[1].start) / o_size_w, float(
indices[0].stop -
indices[0].start) / o_size_h
ratios.append((ratio_x, ratio_y, ratio_w, ratio_h))
return rois, ratios
elif isinstance(scale, tuple) and len(scale) == 2:
base_scale = get_base_scale(scale[0], img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
o_size_h, o_size_w = npimg.shape[:2]
if npimg.shape[0] < self.target_size[1] or npimg.shape[
1] < self.target_size[0]:
newimg = np.zeros(
(max(self.target_size[1], npimg.shape[0]),
max(self.target_size[0], npimg.shape[1]), 3),
dtype=np.uint8)
newimg[:npimg.shape[0], :npimg.shape[1], :] = npimg
npimg = newimg
window_step = scale[1]
windows = sw.generate(npimg, sw.DimOrder.HeightWidthChannel,
self.target_size[0], self.target_size[1],
window_step)
rois = []
ratios = []
for window in windows:
indices = window.indices()
roi = npimg[indices]
rois.append(roi)
ratio_x, ratio_y = float(indices[1].start) / o_size_w, float(
indices[0].start) / o_size_h
ratio_w, ratio_h = float(indices[1].stop -
indices[1].start) / o_size_w, float(
indices[0].stop -
indices[0].start) / o_size_h
ratios.append((ratio_x, ratio_y, ratio_w, ratio_h))
return rois, ratios
elif isinstance(scale, tuple) and len(scale) == 3:
base_scale = get_base_scale(scale[2], img_w, img_h)
npimg = cv2.resize(npimg,
dsize=None,
fx=base_scale,
fy=base_scale,
interpolation=cv2.INTER_CUBIC)
ratio_w = self.target_size[0] / float(npimg.shape[1])
ratio_h = self.target_size[1] / float(npimg.shape[0])
want_x, want_y = scale[:2]
ratio_x = want_x - ratio_w / 2.
ratio_y = want_y - ratio_h / 2.
ratio_x = max(ratio_x, 0.0)
ratio_y = max(ratio_y, 0.0)
if ratio_x + ratio_w > 1.0:
ratio_x = 1. - ratio_w
if ratio_y + ratio_h > 1.0:
ratio_y = 1. - ratio_h
roi = self._crop_roi(npimg, ratio_x, ratio_y)
return [roi], [(ratio_x, ratio_y, ratio_w, ratio_h)]
def compute_windows(image, pixels, overlap):
im = Image.open(image)
data = np.array(im)
windows = sw.generate(image, sw.DimOrder.HeightWidthChannel, 300.05)
return (windows)
x_min_data, y_min_data, x_max_data, y_max_data = dataset.bounds
poly_raster_bounds = Polygon([(x_min_data, y_min_data),
(x_min_data, y_max_data),
(x_max_data, y_max_data),
(x_max_data, y_min_data)])
# get raster metadata
x_pix_size_m = dataset.meta['transform'][0]
y_pix_size_m = dataset.meta['transform'][4]
x_raster_size_pix = dataset.meta['width']
y_raster_size_pix = dataset.meta['height']
# Generate the set of windows
windows = sw.generate(np.rot90(np.fliplr(dataset.read().T)),
sw.DimOrder.HeightWidthChannel, CHUNK_SIZE_PIX,
OVERLAP_FRAC)
for i in tqdm(range(len(windows)),
desc='Chopping tif file : ',
leave=False,
file=sys.stdout):
# convert chunk coordinates to bbox
x_min = (windows[i].x * x_pix_size_m) + x_min_data
x_max = ((windows[i].x + windows[i].w) * x_pix_size_m) + x_min_data
y_min = (windows[i].y * abs(y_pix_size_m)) + y_min_data
y_max = (
(windows[i].y + windows[i].h) * abs(y_pix_size_m)) + y_min_data
x_min_data, y_min_data, x_max_data, y_max_data = dataset.bounds
def compute_windows(numpy_image,pixels=400,overlap=0.05):
windows = sw.generate(numpy_image, sw.DimOrder.HeightWidthChannel, pixels,overlap )
return(windows)
img = np.array(scipy.ndimage.imread(str(path)))
windows = sw.generate(img, sw.DimOrder.HeightWidthChannel, 128, 0)
for i, window in enumerate(windows):
subset = img[ window.indices() ]
filename = str(os.path.basename(path))[:str(os.path.basename(path)).find(".")]
subset = skimage.img_as_int(subset)
skimage.io.imsave('C:\\Users\\rohit\\Workspace\\Python\\MODIS\\Red_128\\' + filename + '_' + str(i) + '.tif', subset) """
#directory = os.getcwd() + '\\MOD09GA_NIR\\'
directory = os.getcwd() + '\\M31\\'
pathlist = Path(directory).iterdir()
#print(directory)
for path in pathlist:
print(path)
img = np.array(scipy.ndimage.imread(str(path)))
windows = sw.generate(img, sw.DimOrder.HeightWidthChannel, 256, 0.3)
for i, window in enumerate(windows):
subset = img[ window.indices() ]
filename = str(os.path.basename(path))[:str(os.path.basename(path)).find(".")]
skimage.io.imsave(os.getcwd() + '\\M31_256\\' + filename + '_' + str(i) + '.png', subset)
def remove_dark(x):
windows = sw.generate(x, sw.DimOrder.HeightWidthChannel, 250, 0,
[remove_dark_single])
for window in windows:
x[window.indices()] = window.apply(x)
return x
c_img = adjust_contrast(c_img).copy()
plt.imshow(c_img)
plt.savefig('trn_col.png')
plt.close()
##################
# Sliding Window #
##################
import slidingwindow as sw
x_val, y_val = np.load('./kaggle/x_tmp_%d.npy' % N_Cls), np.load(
'./kaggle/y_tmp_%d.npy' % N_Cls)
data = y_val[0]
data = np.rollaxis(data, 0, 3)
windows = sw.generate(data, sw.DimOrder.HeightWidthChannel, 16, 0)
window_dict = {}
wind = 1
for window in windows:
subset = data[window.indices()]
window_dict[wind] = {}
for c in range(10):
class_ = subset[:, :, c].sum()
#print('The presence of class ' + str(c + 1) + ' is: ' + str((class_ / (160*160))*100) + '%')
window_dict[wind][c] = class_
wind += 1
np.save('./kaggle/dict_windows', window_dict)
import slidingwindow as sw
import numpy as np
import cv2
import FeatureExtractor
frame = cv2.imread("ts.jpg")
windows = sw.generate(frame, sw.DimOrder.HeightWidthChannel, 256, 0.5)
#print(windows)
count = 0
print(len(windows))
for window in windows:
f = window.apply(frame)
#print(np.shape(f))
#print(np.shape(f))
#print(window)
print(count)
print(np.shape(f))
count = count + 1
'''
for window in windows:
bbox = window.getRect()
p1 = (int(bbox[0]), int(bbox[1]))
p2 = (int(bbox[0] + bbox[2]), int(bbox[1] + bbox[3]))
cv2.rectangle(frame, p1, p2, (0,0,255), 2, 1)
while True:
cv2.imshow("image",frame)
cv2.waitKey(1)'''
