ASMNet / image_utility.py

daliprf

init

144b876 almost 2 years ago

No virus

24.9 kB

	import random
	import numpy as np

	import matplotlib
	matplotlib.use('agg')
	import matplotlib.pyplot as plt

	import math
	from skimage.transform import warp, AffineTransform
	import cv2
	from scipy import misc
	from skimage.transform import rotate
	from PIL import Image
	from PIL import ImageOps
	from skimage.transform import resize
	from skimage import transform
	from skimage.transform import SimilarityTransform, AffineTransform
	import random
	from configuration import DatasetName

	class ImageUtility:

	def crop_and_save(self, _image, _label, file_name, num_of_landmarks, dataset_name):
	try:
	'''crop data: we add a small margin to the images'''

	xy_points, x_points, y_points = self.create_landmarks(landmarks=_label,
	scale_factor_x=1, scale_factor_y=1)

	# self.print_image_arr(str(x_points[0]), _image, x_points, y_points)

	img_arr, points_arr = self.cropImg(_image, x_points, y_points, no_padding=False)
	# img_arr = output_img
	# points_arr = t_label
	'''resize image to 224*224'''
	resized_img = resize(img_arr,
	(224, 224, 3),
	anti_aliasing=True)
	dims = img_arr.shape
	height = dims[0]
	width = dims[1]
	scale_factor_y = 224 / height
	scale_factor_x = 224 / width

	'''rescale and retrieve landmarks'''
	landmark_arr_xy, landmark_arr_x, landmark_arr_y = \
	self.create_landmarks(landmarks=points_arr,
	scale_factor_x=scale_factor_x,
	scale_factor_y=scale_factor_y)

	min_b = 0.0
	max_b = 224
	if not(min(landmark_arr_x) < min_b or min(landmark_arr_y) < min_b or
	max(landmark_arr_x) > max_b or max(landmark_arr_y) > max_b):

	# self.print_image_arr(str(landmark_arr_x[0]), resized_img, landmark_arr_x, landmark_arr_y)

	im = Image.fromarray((resized_img * 255).astype(np.uint8))
	im.save(str(file_name) + '.jpg')

	pnt_file = open(str(file_name) + ".pts", "w")
	pre_txt = ["version: 1 \n", "n_points: 68 \n", "{ \n"]
	pnt_file.writelines(pre_txt)
	points_txt = ""
	for i in range(0, len(landmark_arr_xy), 2):
	points_txt += str(landmark_arr_xy[i]) + " " + str(landmark_arr_xy[i + 1]) + "\n"

	pnt_file.writelines(points_txt)
	pnt_file.write("} \n")
	pnt_file.close()

	except Exception as e:
	print(e)

	def random_rotate(self, _image, _label, file_name, num_of_landmarks, dataset_name):
	try:

	xy_points, x_points, y_points = self.create_landmarks(landmarks=_label,
	scale_factor_x=1, scale_factor_y=1)
	# self.print_image_arr(str(xy_points[8]), _image, x_points, y_points)

	_image, _label = self.cropImg_2time(_image, x_points, y_points)

	_image = self.__noisy(_image)

	scale = (np.random.uniform(0.8, 1.0), np.random.uniform(0.8, 1.0))
	# scale = (1, 1)

	rot = np.random.uniform(-1 * 0.55, 0.55)
	translation = (0, 0)
	shear = 0

	tform = AffineTransform(
	scale=scale, # ,
	rotation=rot,
	translation=translation,
	shear=np.deg2rad(shear)
	)

	output_img = transform.warp(_image, tform.inverse, mode='symmetric')

	sx, sy = scale
	t_matrix = np.array([
	[sx * math.cos(rot), -sy * math.sin(rot + shear), 0],
	[sx * math.sin(rot), sy * math.cos(rot + shear), 0],
	[0, 0, 1]
	])
	landmark_arr_xy, landmark_arr_x, landmark_arr_y = self.create_landmarks(_label, 1, 1)
	label = np.array(landmark_arr_x + landmark_arr_y).reshape([2, num_of_landmarks])
	marging = np.ones([1, num_of_landmarks])
	label = np.concatenate((label, marging), axis=0)

	label_t = np.dot(t_matrix, label)
	lbl_flat = np.delete(label_t, 2, axis=0).reshape([2*num_of_landmarks])

	t_label = self.__reorder(lbl_flat, num_of_landmarks)

	'''crop data: we add a small margin to the images'''
	xy_points, x_points, y_points = self.create_landmarks(landmarks=t_label,
	scale_factor_x=1, scale_factor_y=1)
	img_arr, points_arr = self.cropImg(output_img, x_points, y_points, no_padding=False)
	# img_arr = output_img
	# points_arr = t_label
	'''resize image to 224*224'''
	resized_img = resize(img_arr,
	(224, 224, 3),
	anti_aliasing=True)
	dims = img_arr.shape
	height = dims[0]
	width = dims[1]
	scale_factor_y = 224 / height
	scale_factor_x = 224 / width

	'''rescale and retrieve landmarks'''
	landmark_arr_xy, landmark_arr_x, landmark_arr_y = \
	self.create_landmarks(landmarks=points_arr,
	scale_factor_x=scale_factor_x,
	scale_factor_y=scale_factor_y)

	min_b = 0.0
	max_b = 224
	if dataset_name == DatasetName.cofw:
	min_b = 5.0
	max_b = 214

	if not(min(landmark_arr_x) < 0 or min(landmark_arr_y) < min_b or
	max(landmark_arr_x) > 224 or max(landmark_arr_y) > max_b):

	# self.print_image_arr(str(landmark_arr_x[0]), resized_img, landmark_arr_x, landmark_arr_y)

	im = Image.fromarray((resized_img * 255).astype(np.uint8))
	im.save(str(file_name) + '.jpg')

	pnt_file = open(str(file_name) + ".pts", "w")
	pre_txt = ["version: 1 \n", "n_points: 68 \n", "{ \n"]
	pnt_file.writelines(pre_txt)
	points_txt = ""
	for i in range(0, len(landmark_arr_xy), 2):
	points_txt += str(landmark_arr_xy[i]) + " " + str(landmark_arr_xy[i + 1]) + "\n"

	pnt_file.writelines(points_txt)
	pnt_file.write("} \n")
	pnt_file.close()

	return t_label, output_img
	except Exception as e:
	print(e)
	return None, None


	def random_rotate_m(self, _image, _label_img, file_name):

	rot = random.uniform(-80.9, 80.9)

	output_img = rotate(_image, rot, resize=True)
	output_img_lbl = rotate(_label_img, rot, resize=True)

	im = Image.fromarray((output_img * 255).astype(np.uint8))
	im_lbl = Image.fromarray((output_img_lbl * 255).astype(np.uint8))

	im_m = ImageOps.mirror(im)
	im_lbl_m = ImageOps.mirror(im_lbl)

	im.save(str(file_name)+'.jpg')
	# im_lbl.save(str(file_name)+'_lbl.jpg')

	im_m.save(str(file_name) + '_m.jpg')
	# im_lbl_m.save(str(file_name) + '_m_lbl.jpg')

	im_lbl_ar = np.array(im_lbl)
	im_lbl_m_ar = np.array(im_lbl_m)

	self.__save_label(im_lbl_ar, file_name, np.array(im))
	self.__save_label(im_lbl_m_ar, file_name+"_m", np.array(im_m))


	def __save_label(self, im_lbl_ar, file_name, img_arr):

	im_lbl_point = []
	for i in range(im_lbl_ar.shape[0]):
	for j in range(im_lbl_ar.shape[1]):
	if im_lbl_ar[i, j] != 0:
	im_lbl_point.append(j)
	im_lbl_point.append(i)

	pnt_file = open(str(file_name)+".pts", "w")

	pre_txt = ["version: 1 \n", "n_points: 68 \n", "{ \n"]
	pnt_file.writelines(pre_txt)
	points_txt = ""
	for i in range(0, len(im_lbl_point), 2):
	points_txt += str(im_lbl_point[i]) + " " + str(im_lbl_point[i+1]) + "\n"

	pnt_file.writelines(points_txt)
	pnt_file.write("} \n")
	pnt_file.close()

	'''crop data: we add a small margin to the images'''
	xy_points, x_points, y_points = self.create_landmarks(landmarks=im_lbl_point,
	scale_factor_x=1, scale_factor_y=1)
	img_arr, points_arr = self.cropImg(img_arr, x_points, y_points)

	'''resize image to 224*224'''
	resized_img = resize(img_arr,
	(224, 224, 3),
	anti_aliasing=True)
	dims = img_arr.shape
	height = dims[0]
	width = dims[1]
	scale_factor_y = 224 / height
	scale_factor_x = 224 / width

	'''rescale and retrieve landmarks'''
	landmark_arr_xy, landmark_arr_x, landmark_arr_y = \
	self.create_landmarks(landmarks=points_arr,
	scale_factor_x=scale_factor_x,
	scale_factor_y=scale_factor_y)

	im = Image.fromarray((resized_img * 255).astype(np.uint8))
	im.save(str(im_lbl_point[0])+'.jpg')
	# self.print_image_arr(im_lbl_point[0], resized_img, landmark_arr_x, landmark_arr_y)


	def augment(self, _image, _label, num_of_landmarks):

	# face = misc.face(gray=True)
	#
	# rotate_face = ndimage.rotate(_image, 45)
	# self.print_image_arr(_label[0], rotate_face, [],[])

	# hue_img = tf.image.random_hue(_image, max_delta=0.1) # max_delta must be in the interval [0, 0.5].
	# sat_img = tf.image.random_saturation(hue_img, lower=0.0, upper=3.0)
	#
	# sat_img = K.eval(sat_img)
	#
	_image = self.__noisy(_image)

	shear = 0

	# rot = 0.0
	'''this scale has problem'''
	# scale = (random.uniform(0.8, 1.00), random.uniform(0.8, 1.00))

	scale = (1, 1)

	rot = np.random.uniform(-1 * 0.008, 0.008)

	tform = AffineTransform(scale=scale, rotation=rot, shear=shear,
	translation=(0, 0))

	output_img = warp(_image, tform.inverse, output_shape=(_image.shape[0], _image.shape[1]))

	sx, sy = scale
	t_matrix = np.array([
	[sx * math.cos(rot), -sy * math.sin(rot + shear), 0],
	[sx * math.sin(rot), sy * math.cos(rot + shear), 0],
	[0, 0, 1]
	])
	landmark_arr_xy, landmark_arr_x, landmark_arr_y = self.create_landmarks(_label, 1, 1)
	label = np.array(landmark_arr_x + landmark_arr_y).reshape([2, num_of_landmarks])
	marging = np.ones([1, num_of_landmarks])
	label = np.concatenate((label, marging), axis=0)

	label_t = np.dot(t_matrix, label)
	lbl_flat = np.delete(label_t, 2, axis=0).reshape([num_of_landmarks*2])

	t_label = self.__reorder(lbl_flat, num_of_landmarks)
	return t_label, output_img

	def __noisy(self, image):
	noise_typ = random.randint(0, 5)
	# if True or noise_typ == 0 :#"gauss":
	# row, col, ch = image.shape
	# mean = 0
	# var = 0.001
	# sigma = var ** 0.1
	# gauss = np.random.normal(mean, sigma, (row, col, ch))
	# gauss = gauss.reshape(row, col, ch)
	# noisy = image + gauss
	# return noisy
	if 1 <= noise_typ <= 2:# "s&p":
	row, col, ch = image.shape
	s_vs_p = 0.5
	amount = 0.04
	out = np.copy(image)
	# Salt mode
	num_salt = np.ceil(amount * image.size * s_vs_p)
	coords = [np.random.randint(0, i - 1, int(num_salt))
	for i in image.shape]
	out[coords] = 1

	# Pepper mode
	num_pepper = np.ceil(amount * image.size * (1. - s_vs_p))
	coords = [np.random.randint(0, i - 1, int(num_pepper))
	for i in image.shape]
	out[coords] = 0
	return out

	# elif 5 <=noise_typ <= 7: #"speckle":
	# row, col, ch = image.shape
	# gauss = np.random.randn(row, col, ch)
	# gauss = gauss.reshape(row, col, ch)
	# noisy = image + image * gauss
	# return noisy
	else:
	return image

	def __reorder(self, input_arr, num_of_landmarks):
	out_arr = []
	for i in range(num_of_landmarks):
	out_arr.append(input_arr[i])
	k = num_of_landmarks + i
	out_arr.append(input_arr[k])
	return np.array(out_arr)

	def print_image_arr_heat(self, k, image):
	plt.figure()
	plt.imshow(image)
	implot = plt.imshow(image)
	plt.axis('off')
	plt.savefig('heat' + str(k) + '.png', bbox_inches='tight')
	plt.clf()

	def print_image_arr(self, k, image, landmarks_x, landmarks_y):
	plt.figure()
	plt.imshow(image)
	implot = plt.imshow(image)

	plt.scatter(x=landmarks_x[:], y=landmarks_y[:], c='black', s=20)
	plt.scatter(x=landmarks_x[:], y=landmarks_y[:], c='white', s=15)
	plt.axis('off')
	plt.savefig('sss' + str(k) + '.png', bbox_inches='tight')
	# plt.show()
	plt.clf()

	def create_landmarks_from_normalized_original_img(self, img, landmarks, width, height, x_center, y_center, x1, y1, scale_x, scale_y):
	# landmarks_splited = _landmarks.split(';')
	landmark_arr_xy = []
	landmark_arr_x = []
	landmark_arr_y = []

	for j in range(0, len(landmarks), 2):
	x = ((x_center - float(landmarks[j]) * width)*scale_x) + x1
	y = ((y_center - float(landmarks[j + 1]) * height)*scale_y) + y1

	landmark_arr_xy.append(x)
	landmark_arr_xy.append(y)

	landmark_arr_x.append(x)
	landmark_arr_y.append(y)

	img = cv2.circle(img, (int(x), int(y)), 2, (255, 14, 74), 2)
	img = cv2.circle(img, (int(x), int(y)), 1, (0, 255, 255), 1)

	return landmark_arr_xy, landmark_arr_x, landmark_arr_y, img


	def create_landmarks_from_normalized(self, landmarks, width, height, x_center, y_center):

	# landmarks_splited = _landmarks.split(';')
	landmark_arr_xy = []
	landmark_arr_x = []
	landmark_arr_y = []

	for j in range(0, len(landmarks), 2):
	x = x_center - float(landmarks[j]) * width
	y = y_center - float(landmarks[j + 1]) * height

	landmark_arr_xy.append(x)
	landmark_arr_xy.append(y) # [ x1, y1, x2,y2 ]

	landmark_arr_x.append(x) # [x1, x2]
	landmark_arr_y.append(y) # [y1, y2]

	return landmark_arr_xy, landmark_arr_x, landmark_arr_y

	def create_landmarks(self, landmarks, scale_factor_x, scale_factor_y):
	# landmarks_splited = _landmarks.split(';')
	landmark_arr_xy = []
	landmark_arr_x = []
	landmark_arr_y = []
	for j in range(0, len(landmarks), 2):

	x = float(landmarks[j]) * scale_factor_x
	y = float(landmarks[j + 1]) * scale_factor_y

	landmark_arr_xy.append(x)
	landmark_arr_xy.append(y) # [ x1, y1, x2,y2 ]

	landmark_arr_x.append(x) # [x1, x2]
	landmark_arr_y.append(y) # [y1, y2]

	return landmark_arr_xy, landmark_arr_x, landmark_arr_y

	def create_landmarks_aflw(self, landmarks, scale_factor_x, scale_factor_y):
	# landmarks_splited = _landmarks.split(';')
	landmark_arr_xy = []
	landmark_arr_x = []
	landmark_arr_y = []
	for j in range(0, len(landmarks), 2):
	if landmarks[j][0] == 1:
	x = float(landmarks[j][1]) * scale_factor_x
	y = float(landmarks[j][2]) * scale_factor_y

	landmark_arr_xy.append(x)
	landmark_arr_xy.append(y) # [ x1, y1, x2,y2 ]

	landmark_arr_x.append(x) # [x1, x2]
	landmark_arr_y.append(y) # [y1, y2]

	return landmark_arr_xy, landmark_arr_x, landmark_arr_y

	def random_augmentation(self, lbl, img, number_of_landmark):
	# a = random.randint(0, 2)
	# if a == 0:
	# img, lbl = self.__add_margin(img, img.shape[0], lbl)

	'''this function has problem!!!'''
	# img, lbl = self.__add_margin(img, img.shape[0], lbl)

	# else:
	# img, lbl = self.__negative_crop(img, lbl)

	# i = random.randint(0, 2)
	# if i == 0:
	# img, lbl = self.__rotate(img, lbl, 90, img.shape[0], img.shape[1])
	# elif i == 1:
	# img, lbl = self.__rotate(img, lbl, 180, img.shape[0], img.shape[1])
	# else:
	# img, lbl = self.__rotate(img, lbl, 270, img.shape[0], img.shape[1])

	# k = random.randint(0, 3)
	# if k > 0:
	# img = self.__change_color(img)
	#
	img = self.__noisy(img)

	lbl = np.reshape(lbl, [number_of_landmark*2])
	return lbl, img


	def cropImg_2time(self, img, x_s, y_s):
	min_x = max(0, int(min(x_s) - 100))
	max_x = int(max(x_s) + 100)
	min_y = max(0, int(min(y_s) - 100))
	max_y = int(max(y_s) + 100)

	crop = img[min_y:max_y, min_x:max_x]

	new_x_s = []
	new_y_s = []
	new_xy_s = []

	for i in range(len(x_s)):
	new_x_s.append(x_s[i] - min_x)
	new_y_s.append(y_s[i] - min_y)
	new_xy_s.append(x_s[i] - min_x)
	new_xy_s.append(y_s[i] - min_y)
	return crop, new_xy_s

	def cropImg(self, img, x_s, y_s, no_padding=False):
	margin1 = random.randint(0, 10)
	margin2 = random.randint(0, 10)
	margin3 = random.randint(0, 10)
	margin4 = random.randint(0, 10)

	if no_padding:
	min_x = max(0, int(min(x_s)))
	max_x = int(max(x_s))
	min_y = max(0, int(min(y_s)))
	max_y = int(max(y_s))
	else:
	min_x = max(0, int(min(x_s) - margin1))
	max_x = int(max(x_s) + margin2)
	min_y = max(0, int(min(y_s) - margin3))
	max_y = int(max(y_s) + margin4)

	crop = img[min_y:max_y, min_x:max_x]

	new_x_s = []
	new_y_s = []
	new_xy_s = []

	for i in range(len(x_s)):
	new_x_s.append(x_s[i] - min_x)
	new_y_s.append(y_s[i] - min_y)
	new_xy_s.append(x_s[i] - min_x)
	new_xy_s.append(y_s[i] - min_y)

	# imgpr.print_image_arr(k, crop, new_x_s, new_y_s)
	# imgpr.print_image_arr_2(i, img, x_s, y_s, [min_x, max_x], [min_y, max_y])

	return crop, new_xy_s

	def __negative_crop(self, img, landmarks):

	landmark_arr_xy, x_s, y_s = self.create_landmarks(landmarks, 1, 1)
	min_x = img.shape[0] // random.randint(5, 15)
	max_x = img.shape[0] - (img.shape[0] // random.randint(15, 20))
	min_y = img.shape[0] // random.randint(5, 15)
	max_y = img.shape[0] - (img.shape[0] // random.randint(15, 20))

	crop = img[min_y:max_y, min_x:max_x]

	new_x_s = []
	new_y_s = []
	new_xy_s = []

	for i in range(len(x_s)):
	new_x_s.append(x_s[i] - min_x)
	new_y_s.append(y_s[i] - min_y)
	new_xy_s.append(x_s[i] - min_x)
	new_xy_s.append(y_s[i] - min_y)

	# imgpr.print_image_arr(crop.shape[0], crop, new_x_s, new_y_s)
	# imgpr.print_image_arr_2(crop.shape[0], crop, x_s, y_s, [min_x, max_x], [min_y, max_y])

	return crop, new_xy_s

	def __add_margin(self, img, img_w, lbl):
	marging_width = img_w // random.randint(15, 20)
	direction = random.randint(0, 4)

	if direction == 1:
	margings = np.random.random([img_w, int(marging_width), 3])
	img = np.concatenate((img, margings), axis=1)

	if direction == 2:
	margings_1 = np.random.random([img_w, int(marging_width), 3])
	img = np.concatenate((img, margings_1), axis=1)

	marging_width_1 = img_w // random.randint(15, 20)
	margings_2 = np.random.random([int(marging_width_1), img_w + int(marging_width), 3])
	img = np.concatenate((img, margings_2), axis=0)

	if direction == 3: # need chane labels
	margings_1 = np.random.random([img_w, int(marging_width), 3])
	img = np.concatenate((margings_1, img), axis=1)
	lbl = self.__transfer_lbl(int(marging_width), lbl, [1, 0])

	marging_width_1 = img_w // random.randint(15, 20)
	margings_2 = np.random.random([int(marging_width_1), img_w + int(marging_width), 3])
	img = np.concatenate((margings_2, img), axis=0)
	lbl = self.__transfer_lbl(int(marging_width_1), lbl, [0, 1])

	if direction == 4: # need chane labels
	margings_1 = np.random.random([img_w, int(marging_width), 3])
	img = np.concatenate((margings_1, img), axis=1)
	lbl = self.__transfer_lbl(int(marging_width), lbl, [1, 0])
	img_w1 = img_w + int(marging_width)

	marging_width_1 = img_w // random.randint(15, 20)
	margings_2 = np.random.random([int(marging_width_1), img_w1, 3])
	img = np.concatenate((margings_2, img), axis=0)
	lbl = self.__transfer_lbl(int(marging_width_1), lbl, [0, 1])
	img_w2 = img_w + int(marging_width_1)

	marging_width_1 = img_w // random.randint(15, 20)
	margings_1 = np.random.random([img_w2, int(marging_width_1), 3])
	img = np.concatenate((img, margings_1), axis=1)

	marging_width_1 = img_w // random.randint(15, 20)
	margings_2 = np.random.random([int(marging_width_1), img.shape[1], 3])
	img = np.concatenate((img, margings_2), axis=0)

	return img, lbl

	def __void_image(self, img, img_w, ):
	marging_width = int(img_w / random.randint(7, 16))
	direction = random.randint(0, 1)
	direction = 0
	if direction == 0:
	np.delete(img, 100, 1)
	# img[:, 0:marging_width, :] = 0
	elif direction == 1:
	img[img_w - marging_width:img_w, :, :] = 0
	if direction == 2:
	img[:, img_w - marging_width:img_w, :] = 0

	return img

	def __change_color(self, img):
	# color_arr = np.random.random([img.shape[0], img.shape[1]])
	color_arr = np.zeros([img.shape[0], img.shape[1]])
	axis = random.randint(0, 4)

	if axis == 0: # red
	img_mono = img[:, :, 0]
	new_img = np.stack([img_mono, color_arr, color_arr], axis=2)
	elif axis == 1: # green
	img_mono = img[:, :, 1]
	new_img = np.stack([color_arr, img_mono, color_arr], axis=2)
	elif axis == 2: # blue
	img_mono = img[:, :, 1]
	new_img = np.stack([color_arr, img_mono, color_arr], axis=2)
	elif axis == 3: # gray scale
	img_mono = img[:, :, 0]
	new_img = np.stack([img_mono, img_mono, img_mono], axis=2)
	else: # random noise
	color_arr = np.random.random([img.shape[0], img.shape[1]])
	img_mono = img[:, :, 0]
	new_img = np.stack([img_mono, img_mono, color_arr], axis=2)

	return new_img

	def __rotate_origin_only(self, xy_arr, radians, xs, ys):
	"""Only rotate a point around the origin (0, 0)."""
	rotated = []
	for xy in xy_arr:
	x, y = xy
	xx = x * math.cos(radians) + y * math.sin(radians)
	yy = -x * math.sin(radians) + y * math.cos(radians)
	rotated.append([xx + xs, yy + ys])
	return np.array(rotated)

	def __rotate(self, img, landmark_old, degree, img_w, img_h, num_of_landmarks):
	landmark_old = np.reshape(landmark_old, [num_of_landmarks, 2])

	theta = math.radians(degree)

	if degree == 90:
	landmark = self.__rotate_origin_only(landmark_old, theta, 0, img_h)
	return np.rot90(img, 3, axes=(-2, 0)), landmark
	elif degree == 180:
	landmark = self.__rotate_origin_only(landmark_old, theta, img_h, img_w)
	return np.rot90(img, 2, axes=(-2, 0)), landmark
	elif degree == 270:
	landmark = self.__rotate_origin_only(landmark_old, theta, img_w, 0)
	return np.rot90(img, 1, axes=(-2, 0)), landmark

	def __transfer_lbl(self, marging_width_1, lbl, axis_arr):
	new_lbl = []
	for i in range(0, len(lbl), 2):
	new_lbl.append(lbl[i] + marging_width_1 * axis_arr[0])
	new_lbl.append(lbl[i + 1] + marging_width_1 * axis_arr[1])
	return np.array(new_lbl)