def __init__(self, image, region):
#调整位置滤波器输出的参数
output_sigma_factor = 1 / float(16)
self.lamda = 1e-2
self.interp_factor = 0.025
#目标尺寸
self.target_size = np.array([region.height, region.width])
#目标中心位置
self.pos = [region.y + region.height / 2, region.x + region.width / 2]
#初始目标大小
init_target_size = self.target_size
#基本目标尺寸，是根据目标尺寸和当前的尺度变化因子决定的
self.base_target_size = self.target_size
#image.shape[:2]是返回图像（矩阵）前两维的大小，如果是1就返回第一维
#省略就返回三个维度的大小
#此步骤返回padding区域的大小，另外涉及到了用类初始化参数并作为形参用于另一函数的方法
self.sz = utils.get_window_size(self.target_size, image.shape[:2],
padding())
#位置滤波器和尺度滤波器的参数，理想的高斯响应里面的sigma
output_sigma = np.sqrt(np.prod(self.target_size)) * output_sigma_factor
#scale_sigma = np.sqrt(nScales) * scale_sigma_factor
#通过在x,y方向生成网格，从而生成相应的理想高斯响应
#arange(n)生成一个序列0到n，如果是两个参数就是从m到n，如果是三个参数，第三个参数就是步长
grid_y = np.arange(np.floor(self.sz[0])) - np.floor(self.sz[0] / 2)
grid_x = np.arange(np.floor(self.sz[1])) - np.floor(self.sz[1] / 2)
rs, cs = np.meshgrid(grid_x, grid_y)
y = np.exp(-0.5 / output_sigma**2 * (rs**2 + cs**2))
#求位置高斯响应的傅里叶变换
self.yf = np.fft.fft2(y, axes=(0, 1))
#获取特征图,参数为目标中心位置和尺寸，特征为hog
feature_map = utils.get_subwindow(image,
self.pos,
self.sz,
feature='hog')
#对特征图使用余弦窗，并进行傅里叶变换
self.cos_window = np.outer(np.hanning(y.shape[0]),
np.hanning(y.shape[1]))
x_hog = np.multiply(feature_map, self.cos_window[:, :, None])
xf = np.fft.fft2(x_hog, axes=(0, 1))
self.x_num = np.multiply(self.yf[:, :, None], np.conj(xf))
self.x_den = np.sum(np.multiply(xf, np.conj(xf)), axis=2)
def data(data_file_path):
"""
Input : Path to dataset
Output : Data in the required format
"""
scaler = MinMaxScaler()
data_sheet = pd.read_csv(data_file_path)
_, window_size = get_window_size(data_sheet)
features, values = create_dataset(data_sheet, window_size)
features = scaler.fit_transform(features)
values = scaler.fit_transform(values)
features = features.reshape(features.shape[0], features.shape[1], 1)
train_size = (int)(0.6 * features.shape[0])
all_truths = np.asarray(data_sheet['label'])
X_train = features[:train_size]
y_train = values[:train_size]
X_test = features[train_size:]
y_test = values[train_size:]
return X_train, y_train, X_test, y_test, window_size, train_size, all_truths
def __init__(self, image, region):
self.target_size = np.array([region.height, region.width])
self.pos = [region.y + region.height / 2, region.x + region.width / 2]
self.sz = utils.get_window_size(self.target_size, image.shape[:2],
padding())
# position prediction params
self.lamda = 1e-4
output_sigma_factor = 0.1
self.cell_size = 4
self.interp_factor = 0.01
self.x_num = []
self.x_den = []
# scale estimation params
self.current_scale_factor = 1.0
nScales = 33
scale_step = 1.02 # step of one scale level
scale_sigma_factor = 1 / float(4)
self.interp_factor_scale = 0.01
scale_model_max_area = 32 * 16
scale_model_factor = 1.0
self.min_scale_factor = np.power(
scale_step,
np.ceil(np.log(5. / np.min(self.sz)) / np.log(scale_step)))
self.max_scale_factor = np.power(
scale_step,
np.floor(
np.log(np.min(np.divide(image.shape[:2], self.target_size))) /
np.log(scale_step)))
if scale_model_factor * scale_model_factor * np.prod(
self.target_size) > scale_model_max_area:
scale_model_factor = np.sqrt(scale_model_max_area /
np.prod(self.target_size))
self.scale_model_sz = np.floor(self.target_size * scale_model_factor)
# Gaussian shaped label for position perdiction
l1_patch_num = np.floor(self.sz / self.cell_size)
output_sigma = np.sqrt(np.prod(
self.target_size)) * output_sigma_factor / self.cell_size
grid_y = np.arange(np.floor(l1_patch_num[0])) - np.floor(
l1_patch_num[0] / 2)
grid_x = np.arange(np.floor(l1_patch_num[1])) - np.floor(
l1_patch_num[1] / 2)
rs, cs = np.meshgrid(grid_x, grid_y)
y = np.exp(-0.5 / output_sigma**2 * (rs**2 + cs**2))
self.yf = np.fft.fft2(y, axes=(0, 1))
self.cos_window = np.outer(np.hanning(self.yf.shape[0]),
np.hanning(self.yf.shape[1]))
# Gaussian shaped label for scale estimation
ss = np.arange(nScales) - np.ceil(nScales / 2)
scale_sigma = np.sqrt(nScales) * scale_sigma_factor
ys = np.exp(-0.5 * (ss**2) / scale_sigma**2)
self.scaleFactors = np.power(scale_step, -ss)
self.ysf = np.fft.fft(ys)
if nScales % 2 == 0:
self.scale_window = np.hanning(nScales + 1)
self.scale_window = self.scale_window[1:]
else:
self.scale_window = np.hanning(nScales)
# Extracting hierarchical convolutional features and training
img = utils.get_subwindow(image, self.pos, self.sz)
img = transform.resize(img, (224, 224))
img = (img - imgMean) / imgStd
img = np.transpose(img, (2, 0, 1))
feature_ensemble = model(
Variable(torch.from_numpy(img[None, :, :, :]).float()).cuda())
for i in range(numlayers):
feature = feature_ensemble[i].data[0].cpu().numpy().transpose(
(1, 2, 0))
x = ndimage.zoom(
feature,
(float(self.cos_window.shape[0]) / feature.shape[0],
float(self.cos_window.shape[1]) / feature.shape[1], 1),
order=1)
x = np.multiply(x, self.cos_window[:, :, None])
xf = np.fft.fft2(x, axes=(0, 1))
self.x_num.append(np.multiply(self.yf[:, :, None], np.conj(xf)))
self.x_den.append(
np.real(np.sum(np.multiply(xf, np.conj(xf)), axis=2)))
# Extracting the sample feature map for the scale filter and training
s = utils.get_scale_subwindow(
image, self.pos, self.target_size,
self.current_scale_factor * self.scaleFactors, self.scale_window,
self.scale_model_sz)
sf = np.fft.fftn(s, axes=[0])
self.s_num = np.multiply(self.ysf[:, None], np.conj(sf))
self.s_den = np.real(np.sum(np.multiply(sf, np.conj(sf)), axis=1))
def __init__(self, image, region):
output_sigma_factor = 1 / float(16)
scale_sigma_factor = 1 / float(4)
self.lamda = 1e-2
self.lamda_scale = 1e-2
self.interp_factor = 0.025
nScales = 33 # number of scale levels
scale_model_factor = 1.0
scale_step = 1.02 # step of one scale level
scale_model_max_area = 32 * 16
self.currentScaleFactor = 1.0
self._results = []
self.target_size = np.array([region.height, region.width])
self.pos = [region.y + region.height / 2, region.x + region.width / 2]
init_target_size = self.target_size
self.base_target_size = self.target_size / self.currentScaleFactor
self.sz = utils.get_window_size(self.target_size, image.shape[:2],
padding())
output_sigma = np.sqrt(np.prod(self.target_size)) * output_sigma_factor
scale_sigma = np.sqrt(nScales) * scale_sigma_factor
grid_y = np.arange(np.floor(self.sz[0])) - np.floor(self.sz[0] / 2)
grid_x = np.arange(np.floor(self.sz[1])) - np.floor(self.sz[1] / 2)
rs, cs = np.meshgrid(grid_x, grid_y)
y = np.exp(-0.5 / output_sigma**2 * (rs**2 + cs**2))
# Gaussian shaped label for scale estimation
ss = np.arange(nScales) - np.ceil(nScales / 2)
ys = np.exp(-0.5 * (ss**2) / scale_sigma**2)
self.scaleFactors = np.power(scale_step, -ss)
self.yf = np.fft.fft2(y, axes=(0, 1))
self.ysf = np.fft.fft(ys)
feature_map = utils.get_subwindow(image,
self.pos,
self.sz,
feature='hog')
self.cos_window = np.outer(np.hanning(y.shape[0]),
np.hanning(y.shape[1]))
x_hog = np.multiply(feature_map, self.cos_window[:, :, None])
xf = np.fft.fft2(x_hog, axes=(0, 1))
# scale search preprocess
if nScales % 2 == 0:
self.scale_window = np.hanning(nScales + 1)
self.scale_window = self.scale_window[1:]
else:
self.scale_window = np.hanning(nScales)
self.scaleSizeFactors = self.scaleFactors
self.min_scale_factor = np.power(
scale_step,
np.ceil(np.log(5. / np.min(self.sz)) / np.log(scale_step)))
self.max_scale_factor = np.power(
scale_step,
np.floor(
np.log(
np.min(np.divide(image.shape[:2], self.base_target_size)))
/ np.log(scale_step)))
if scale_model_factor * scale_model_factor * np.prod(
init_target_size) > scale_model_max_area:
scale_model_factor = np.sqrt(scale_model_max_area /
np.prod(init_target_size))
self.scale_model_sz = np.floor(init_target_size * scale_model_factor)
s = utils.get_scale_subwindow(
image, self.pos, self.base_target_size,
self.currentScaleFactor * self.scaleSizeFactors, self.scale_window,
self.scale_model_sz)
sf = np.fft.fftn(s, axes=[0])
self.x_num = np.multiply(self.yf[:, :, None], np.conj(xf))
self.x_den = np.real(np.sum(np.multiply(xf, np.conj(xf)), axis=2))
self.s_num = np.multiply(self.ysf[:, None], np.conj(sf))
self.s_den = np.real(np.sum(np.multiply(sf, np.conj(sf)), axis=1))