def __init__(self, image, dimensions=199, model=None, initial_face=None,
callback=None):
"""Initializes fitter for given image.
Fits provided number of dimensions of given model to the image.
"""
self.__image = array(image)
self.__model = model
self.__pcs = dimensions
self._dimensions = (dimensions
+ Face.LIGHT_COMPONENTS_COUNT
+ Face.DIRECTION_COMPONENTS_COUNT
+ Face.SCALE_COMPONENTS_COUNT)
self.__callback = callback
self._initial_face = initial_face
if self._initial_face is None:
self._initial_face = Face(
coefficients=zeros(self.__pcs, dtype='f')
)
coefficients = self._initial_face.coefficients
if len(coefficients) != self.__pcs:
correct_coefficients = zeros(self.__pcs, dtype='f')
count = min(len(coefficients), self.__pcs)
correct_coefficients[:count] = coefficients[:count]
self._initial_face = Face(
coefficients=correct_coefficients,
directed_light=self._initial_face.directed_light,
ambient_light=self._initial_face.ambient_light,
scale=self._initial_face.scale
)
def test_set_directed_light():
face = Face()
face.position = (0, 0, 0)
assert allclose(face.position, (0, 0, 0))
assert allclose(face.position_cartesian, (0, 0, 1))
face.position = (1, 1, 1)
assert allclose(face.position, (1, 1, 1))
assert allclose(face.position_cartesian, (0, 1, 0))
def test_set_directed_light():
face = Face()
face.position = (0, 0, 0)
assert allclose(face.position, (0, 0, 0))
assert allclose(face.position_cartesian, (0, 0, 1))
face.position = (1, 1, 1)
assert allclose(face.position, (1, 1, 1))
assert allclose(face.position_cartesian, (0, 1, 0))
def calculate_shrink(self):
self.__step = 'shrink'
self.__parameters[1:] = self.__parameters[0] + self.__sigma * \
(self.__parameters[1:] - self.__parameters[0])
self.__errors[1:] = [None] * (len(self.__errors) - 1)
self.__end = self.__parameters[0] + self.__sigma * \
(self.__end - self.__parameters[0])
self.end_error = None
for i in range(1, self._dimensions):
self.request_face(Face.from_array(self.__parameters[i]), i)
self.request_face(Face.from_array(self.__end), self._dimensions)
def start(self):
self.__loop = 0
self.__face = self._initial_face
self.__parameters = self._initial_face.as_array
self.request_face(self.__face, 'init')
self.__errors = {}
self.__generate_errors()
self.__indices = [0] * len(self.__levels)
self.__directions = [1] * len(self.__levels)
self.__parameters[self.__levels] = [
self.__get_value(i, self.__indices[i])
for i in range(len(self.__levels))
]
change_on = 0
while change_on != -1:
self.__errors[tuple(
self.__indices)] = self.__get_parameter(change_on=change_on)
change_on = self.__inc_index()
result = self.__convert_parameters()
parameters = self._initial_face.as_array
parameters[self.__levels] = result[-1][0]
face = Face.from_array(parameters)
self.get_face(face)
self.finish(face)
def test_face_setter():
view = View()
model = Model(view)
face = Face()
model.face = face
assert model.face is face
assert view.face is face
def test_receive_images():
results = []
images = [[0]*4, [1]*4, [2]*4]
face = Face()
view = View()
model = Model(view)
callback = lambda img: results.append(img)
model.request_image(face, callback)
model.request_image(face, callback)
view.image = images[0]
view.callback()
assert len(results) == 1
assert allclose(results[0], images[0])
view.image = images[1]
view.callback()
assert len(results) == 2
assert allclose(results[1], images[1])
final_callback = lambda img: results.append([img])
model.request_image(face, callback)
view.image = images[2]
view.callback()
assert len(results) == 3
assert allclose(results[2], [images[2]])
def __derivative_face(self, param, dx):
params = self.__face.as_array
if param >= 0:
params[param] += dx
else:
params[param] += self.__light_dx
return Face.from_array(params)
def start(self):
face = self._initial_face.as_array
for _ in range(self.__max_loops):
derivatives = self.__get_derivatives(face)
face += derivatives * self.__step
self.finish(Face.from_array(face))
def test_request_image():
results = []
face = Face()
callback = lambda img: results.append(img)
model = Model(View())
model.request_image(face, callback)
assert results == []
def get_face(self, face):
"""Get face image by face object.
Accepts both `Face` instance
and Face representation as `NumPy` `array`.
"""
if isinstance(face, ndarray):
face = Face.from_array(face)
return self.__model.get_image(face)
def __initiate_parameters(self):
self.__step = 'start'
initial_parameters = concatenate((
self._initial_face.coefficients,
[self._initial_face.ambient_light],
self._initial_face.directed_light
))
for i in range(len(self.__parameters)):
# print('Initial step {} of {}'.format(i, self._dimensions))
# self.__parameters[i] = randn(self._dimensions) * 1
# self.__parameters[i] = zeros(self._dimensions)
# self.__parameters[i][:i] = self.__offset
self.__parameters[i] = initial_parameters.copy()
self.__parameters[i][:i] += self.__offset
self.request_face(Face.from_array(self.__parameters[i]), i)
# self.__end = ones(self._dimensions)
# self.__end = randn(self._dimensions)
self.__end = initial_parameters + self.__offset
self.request_face(Face.from_array(self.__end), self._dimensions)
def test_receive_image():
results = []
face = Face()
view = View()
model = Model(view)
callback = lambda img: results.append(img)
model.request_image(face, callback)
view.image = [1, 2, 3, 4]
view.callback()
assert allclose(results[0], view.image)
def receive_image(self, image, index=None):
if index == 'init':
return
elif index == 'pre':
self.__get_parameter(self.__current_step + 1)
return
shadows = image
if index is None:
self.finish(self.__face)
return
self.__errors[index] = self.get_image_deviation(shadows)
if None in self.__errors:
return
errors = array(self.__errors)
max_error = errors.max()
if self.__loop >= self.__determined_loops:
X = exp(-errors / max_error).sum()
v = rand()
best_index = -1
t = 0
for i, error in enumerate(errors):
e = exp(error / max_error) / X
t += e
if v <= e:
best_index = i
break
else:
v -= e
if best_index == -1:
best_index = len(self.__errors) - 1
else:
best_index = argmin(self.__errors)
self.__parameters[self.__current_step] = self.__values[best_index]
self.__face = Face.from_array(self.__parameters)
print('{}.{}: Error of the best is {} ({})'.format(
self.__loop, self.__current_step, self.__errors[best_index],
min(self.__errors)))
if self.__current_step + 1 == self._dimensions \
and self.__loop + 1 >= self.__max_loops:
self.request_face(self.__face)
return
elif self.__current_step + 1 == self._dimensions:
self.__current_step = 0
self.__loop += 1
self.request_face(self.__face, 'pre')
return
self.request_face(self.__face, 'pre')
def __generate_face_parameters(self):
"""Generate random face.
Based on needed parameters to iterate by and initial Face.
"""
parameters = self._initial_face.as_array
parameters[self.__iterating_parameters] = randn(
len(self.__iterating_parameters))
self.__parameters.append(parameters)
self.__differences.append(None)
self.__values.append(None)
return Face.from_array(parameters)
def test_request_images():
results = []
images = [[0]*4, [1]*4, [2]*4]
face = Face()
view = View()
model = Model(view)
callback = lambda img: results.append(img)
model.request_image(face, callback)
model.request_image(face, callback)
assert len(results) == 0
def __next_iteration(self):
self.__loop += 1
self.__current_step = -5
coefficients = (self.__face.coefficients -
self.__step * self.__derivatives[:-Face.NON_PCS_COUNT])
directed_light = (
self.__face.directed_light -
self.__step * self.__derivatives[Face.LIGHT_COMPONENTS_SLICE] / 50)
self.__face = Face(coefficients=coefficients,
directed_light=directed_light)
# print(self.__derivatives)
self.request_face(self.__face, 'start_iteration')
def __get_parameter(self, i):
self.__current_step = i
if self.__steps[i] % 2 == 0:
self.__values = linspace(-4, 4, self.__steps[i] + 1, dtype='f')
else:
self.__values = linspace(-4, 4, self.__steps[i] + 2, dtype='f')
self.__errors = [None] * self.__values.size
for i, value in enumerate(self.__values):
self.__values[i] = value
parameters = self.__parameters.copy()
parameters[self.__current_step] = value
self.request_face(Face.from_array(parameters), i)
def start(self):
x0 = self._initial_face.as_array.copy()
final_simplex = x0.copy()
final_simplex[Face.PCS_SLICE] += self.__offset
final_simplex[0:-Face.NON_PCS_COUNT:2] = 1
final_simplex[1:-Face.NON_PCS_COUNT:2] = -1
final_simplex[Face.NON_PCS_SLICE] = 1
initial_simplex = array([concatenate((x0[:i], final_simplex[i:]))
for i in range(self._dimensions + 1)], 'f')
options = {
'initial_simplex': initial_simplex
}
result = minimize(self.get_face_deviation, x0,
method='nelder-mead', options=options)
self.finish(Face.from_array(result))
def start(self):
x0 = self._initial_face.as_array.copy()
final_simplex = x0.copy()
final_simplex[Face.PCS_SLICE] += self.__offset
final_simplex[0:-Face.NON_PCS_COUNT:2] = 1
final_simplex[1:-Face.NON_PCS_COUNT:2] = -1
final_simplex[Face.NON_PCS_SLICE] = 1
initial_simplex = array([
concatenate((x0[:i], final_simplex[i:]))
for i in range(self._dimensions + 1)
], 'f')
options = {'initial_simplex': initial_simplex}
result = minimize(self.get_face_deviation,
x0,
method='nelder-mead',
options=options)
self.finish(Face.from_array(result))
def receive_image(self, image, index=None):
if index == 'init':
return
elif index == 'finish':
self.finish(self.__face)
return
self.__errors[tuple(self.__indices)] = self.get_image_deviation(image)
change_on = self.__inc_index()
if change_on == -1:
result = self.__convert_parameters()
parameters = self._initial_face.as_array
parameters[self.__levels] = result[-1][0]
self.__face = Face.from_array(parameters)
self.request_face(self.__face, 'finish')
return
self.__get_parameter(change_on=change_on)
def __calculate_result(self):
"""Get weighted sum of achieved parameters.
Normalize probabilities as their sum should be 1.
Then get sum of parameters got during iterations
multiplied by corresponding probabilities.
Form parameters of final face and finish the fitting procedure.
"""
max_difference = max(self.__differences)
normalized_differences = array(self.__differences) - float(
sum(
Decimal(diff - max_difference).exp()
for diff in self.__differences).ln())
params = [
sum(
Decimal(float(p[i])) * Decimal(diff).exp()
for diff, p in zip(normalized_differences, self.__parameters))
for i in self.__estimating_parameters
]
parameters = self._initial_face.as_array
parameters[self.__estimating_parameters] = params
self.finish(Face.from_array(parameters))
def construct_chain(configuration_filename, model):
fitting_settings = None
with open(configuration_filename) as config:
fitting_settings = json.load(config)
fitters = fitting_settings['fitters']
face_parameters = fitting_settings['input'].get('initial_face', {})
coefficients = face_parameters.get('coefficients', [])
directed_light = face_parameters.get('directed_light', (0., 0., 0.))
ambient_light = face_parameters.get('ambient_light', 0.)
initial_face = Face(coefficients=coefficients,
directed_light=directed_light,
ambient_light=ambient_light)
face_filename = get_datafile_path(fitting_settings['input']['input_image'])
image = Image.open(face_filename).convert('L')
original_data = array(image.getdata()).astype('f') / 255
image_data = original_data.reshape(image.size)[::-1, :].flatten()
image.close()
return FittersChain(fitters, image_data, model, initial_face=initial_face)
def calculate_reflection(self):
self.__step = 'reflection'
self.calculate_centroid()
self.__reflection = self.__centroid + self.__alpha * \
(self.__centroid - self.__end)
self.request_face(Face.from_array(self.__reflection))
def model():
view = View()
face = Face()
model = Model(view)
model.face = face
yield model
def Face():
__Face.set_initial_rotation(0, 0)
yield __Face
__Face.set_initial_rotation(0, 0)
args = parser.parse_args()
fitting_settings = None
with open(args.config) as config:
fitting_settings = json.load(config)
fitters = fitting_settings['fitters']
face_parameters = fitting_settings['input'].get('initial_face', {})
coefficients = face_parameters.get('coefficients', [])
directed_light = face_parameters.get('directed_light', (0., 0., 0.))
ambient_light = face_parameters.get('ambient_light', 0.)
initial_face = Face(coefficients=coefficients,
directed_light=directed_light,
ambient_light=ambient_light)
model_filename = get_datafile_path(fitting_settings['input']['input_image'])
image = Image.open(model_filename).convert('L')
original_data = array(image.getdata()).astype('f') / 255
image_data = original_data.reshape(image.size)[::-1, :].flatten()
image.close()
MFM.init()
view = View((500, 500))
model = Model(view)
model_input = ModelInput(model)
chain = FittersChain(fitters, image_data, model, initial_face=initial_face)
def start(self):
parameters = self._initial_face.as_array.copy()
for _ in range(self.__max_loops):
parameters = self.__iteration(parameters)
self.finish(Face.from_array(parameters))
def test_constructor_wrong_coefficients(value):
with raises(ValueError):
Face(coefficients=value)
def calculate_contraction(self):
self.__step = 'contraction'
self.__contraction = self.__centroid + self.__rho * \
(self.__parameters[-1] - self.__centroid)
self.request_face(Face.from_array(self.__contraction))
def __get_parameter(self, change_on=0):
value = self.__get_value(change_on, self.__indices[change_on])
self.__parameters[self.__levels[change_on]] = value
self.__face = Face.from_array(self.__parameters)
return self.get_face_deviation(self.__face)
def test_set_ambient_light():
face = Face()
face.ambient_light = 0
assert allclose(face.ambient_light, 0)
face.ambient_light = 1
assert allclose(face.ambient_light, 1)
def test_set_position():
face = Face()
face.position = (0, 0, 0)
assert allclose(face.position, (0, 0, 0))
face.position = (1, 1, 1)
assert allclose(face.position, (1, 1, 1))
def test_constructor_wrong_vector3d(name, value):
with raises(ValueError):
Face(**{name: value})
def calculate_expansion(self):
self.__step = 'expansion'
self.__expansion = self.__centroid + self.__gamma * \
(self.__reflection - self.__centroid)
self.request_face(Face.from_array(self.__expansion))
def test_constructor():
assert isinstance(Face(), Face)
def test_set_scale():
face = Face()
face.scale = (2, 2, 2)
assert allclose(face.scale, (2, 2, 2))
face.scale = (1, 1, 1)
assert allclose(face.scale, (1, 1, 1))