def _draw_version(self, layout):
arr = [
"Version {}, built {}".format(pkt.module().__version__,
pkt.module().build_time),
'The core library has been installed successfully'
]
draw_warning_labels(layout, arr, alert=False, icon='INFO')
def init_facebuilder(self, ver=Config.unknown_mod_ver):
latest_version = pkt.module().FaceBuilder.latest_face_version()
if ver == Config.unknown_mod_ver or ver > latest_version:
self.builder = pkt.module().FaceBuilder(latest_version)
self.version = latest_version
else:
self.builder = pkt.module().FaceBuilder(ver)
self.version = ver
self.builder_type = BuilderType.FaceBuilder
def mesh_update_accepted(headnum):
logger = logging.getLogger(__name__)
logger.debug('callbacks.update_mesh_geometry')
settings = get_main_settings()
head = settings.get_head(headnum)
if not head or not head.model_changed():
logger.debug('WRONG_HEAD OR MODEL NOT CHANGED')
return
head.apply_model_changes()
if not head.has_no_blendshapes():
names = [kb.name for kb in head.headobj.data.shape_keys.key_blocks[1:]]
action = disconnect_blendshapes_action(head.headobj)
logger.debug('blendshapes: {}'.format(names))
_update_mesh_now(headnum)
try:
counter = restore_facs_blendshapes(head.headobj,
head.model_scale, names)
logger.debug('blendshapes_restored: {}'.format(counter))
except pkt.module().UnlicensedException:
logger.error('UnlicensedException restore_facs_blendshapes')
warn = get_operator(Config.fb_warning_idname)
warn('INVOKE_DEFAULT', msg=ErrorType.NoLicense)
except Exception:
logger.error('UNKNOWN EXCEPTION restore_facs_blendshapes')
if action:
head.headobj.data.shape_keys.animation_data_create()
head.headobj.data.shape_keys.animation_data.action = action
else:
_update_mesh_now(headnum)
def test_download_latest_nightly(use_progress_callback):
try:
if use_progress_callback:
def testing_progress_callback(progress):
assert (testing_progress_callback.last_progress <= progress <=
1)
testing_progress_callback.last_progress = progress
testing_progress_callback.last_progress = 0
else:
testing_progress_callback = None
pkt.install_from_download(nightly=True,
progress_callback=testing_progress_callback)
if use_progress_callback:
assert (testing_progress_callback.last_progress == 1.0)
except Exception:
# can fail with no network
return
assert (pkt.is_installed())
pykeentools = pkt.module()
assert (isinstance(pykeentools.__version__, str))
pkt.uninstall()
def _get_facs_executor(obj, scale):
logger = logging.getLogger(__name__)
verts = _get_obj_verts(obj)
try:
fe = pkt.module().FacsExecutor(verts, scale)
except pkt.module().FacsLoadingException:
logger.error('CANNOT_LOAD_FACS: FacsLoadingException')
return None
except Exception as error:
logger.error('CANNOT_LOAD_FACS: Unknown Exception')
logger.error('info: {} -- {}'.format(type(error), error))
return None
if not fe.facs_enabled():
logger.error('CANNOT_LOAD_FACS: FACS are not enabled')
return None
return fe
def execute(self, context):
lm = pkt.module().FaceBuilder.license_manager()
res = lm.install_license_offline(self.lic_path)
if res is not None:
self.report({'ERROR'}, replace_newlines_with_spaces(res))
else:
self.report({'INFO'}, 'License installed')
return {'FINISHED'}
def execute(self, context):
lm = pkt.module().FaceBuilder.license_manager()
res = lm.install_floating_license(self.license_server,
self.license_server_port)
if res is not None:
self.report({'ERROR'}, replace_newlines_with_spaces(res))
else:
self.report({'INFO'}, 'Floating server settings saved')
return {'FINISHED'}
def _create_texture_builder_from_settings(settings):
tb = pkt.module().TextureBuilder()
tb.set_output_texture_size((settings.tex_width, settings.tex_height))
tb.set_face_angles_affection(settings.tex_face_angles_affection)
tb.set_uv_expand_percents(settings.tex_uv_expand_percents)
tb.set_back_face_culling(settings.tex_back_face_culling)
tb.set_equalize_brightness(settings.tex_equalize_brightness)
tb.set_equalize_colour(settings.tex_equalize_colour)
return tb
def on_mouse_move(self, context, mouse_x, mouse_y):
logger = logging.getLogger(__name__)
settings = get_main_settings()
headnum = self.get_headnum()
camnum = self.get_camnum()
head = settings.get_head(headnum)
headobj = head.headobj
cam = head.get_camera(camnum)
camobj = cam.camobj
kid = settings.get_keyframe(headnum, camnum)
self._pin_drag(kid, context, mouse_x, mouse_y)
fb = FBLoader.get_builder()
FBLoader.rigidity_setup()
fb.set_focal_length_estimation(head.auto_focal_estimation)
try:
fb.solve_for_current_pins(kid)
except pkt.module().UnlicensedException:
logger.error("MOVE PIN LICENSE EXCEPTION")
settings.force_out_pinmode = True
settings.license_error = True
FBLoader.out_pinmode(headnum, camnum)
return {'FINISHED'}
FBLoader.auto_focal_estimation_post(head, camobj)
# --------------
# Pin lag solve
# --------------
head = settings.get_head(headnum)
# Store in tmp previous state
head.tmp_serial_str = head.serial_str
cam.tmp_model_mat = cam.model_mat
# Save current state
head.set_serial_str(fb.serialize())
cam.set_model_mat(fb.model_mat(kid))
# --------------
FBLoader.rigidity_post()
FBLoader.place_cameraobj(kid, camobj, headobj)
coords.update_head_mesh(fb, headobj)
FBLoader.viewport().wireframer().init_geom_data(headobj)
FBLoader.viewport().wireframer().create_batches()
FBLoader.viewport().create_batch_2d(context)
# Try to redraw
if not bpy.app.background:
context.area.tag_redraw()
# Load 3D pins
FBLoader.viewport().update_surface_points(fb, headobj, kid)
return self.on_default_modal()
def execute(self, context):
logger = logging.getLogger(__name__)
settings = get_main_settings()
heads_deleted, cams_deleted = settings.fix_heads()
try:
obj = self.new_head()
except ModuleNotFoundError:
logger.error('ADD_HEAD_ERROR: ModuleNotFoundError')
warn = get_operator(Config.fb_warning_idname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktProblem)
return {'CANCELLED'}
except pkt.module().ModelLoadingException:
logger.error('ADD_HEAD_ERROR: ModelLoadingException')
warn = get_operator(Config.fb_warning_idname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktModelProblem)
return {'CANCELLED'}
except TypeError:
logger.error('ADD_HEAD_ERROR: TypeError')
warn = get_operator(Config.fb_warning_idname)
warn('INVOKE_DEFAULT', msg=ErrorType.CannotCreateObject)
return {'CANCELLED'}
except Exception:
logger.error('ADD_HEAD_ERROR: Exception')
warn = get_operator(Config.fb_warning_idname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktProblem)
return {'CANCELLED'}
attrs.add_to_fb_collection(obj) # link to FB objects collection
FBLoader.set_keentools_attributes(obj)
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(state=True)
bpy.context.view_layer.objects.active = obj
# bpy.ops.object.shade_smooth()
h = get_main_settings().heads.add()
h.headobj = obj
h.reset_sensor_size()
settings.current_headnum = settings.get_last_headnum()
FBLoader.save_fb_on_headobj(settings.current_headnum)
try:
a = context.area
# Try to show UI Panel
a.spaces[0].show_region_ui = True
except Exception:
pass
logger.debug('HEAD HAS BEEN SUCCESSFULLY CREATED')
return {'FINISHED'}
def mock_response():
response = lambda: None
response.description_url = 'https://keentools.io/downloads'
response.download_url = 'https://keentools.io/downloads'
response.message = "<h3>What's New in KeenTools 1.5.7</h3>\n" \
"<ul>\n " \
"<li>fixed performance issues in Nuke 12;</li>\n " \
"<li>pintooling performance improvements;</li>\n " \
"<li>fixed large frame numbers bug;</li>\n " \
"<li>fixed invisible model in macOS Catalina;</li>\n " \
"<li>minor fixes and improvements</li>\n" \
"</ul>\n<br />\n"
response.plugin_name = 'FaceBuilder'
response.version = pkt.module().Version(1, 5, 6)
return response
def frame_data_loader(kf_idx):
cam = head.cameras[camnums[kf_idx]]
w, h = cam.cam_image.size[:2]
img = np.rot90(
np.asarray(cam.cam_image.pixels[:]).reshape((h, w, 4)),
cam.orientation)
frame_data = pkt.module().texture_builder.FrameData()
frame_data.geo = fb.applied_args_model_at(cam.get_keyframe())
frame_data.image = img
frame_data.model = cam.get_model_mat()
frame_data.view = np.eye(4)
frame_data.projection = cam.get_projection_matrix()
return frame_data
def execute(self, context):
logger = logging.getLogger(__name__)
settings = get_main_settings()
heads_deleted, cams_deleted = settings.fix_heads()
try:
obj = self.new_head()
except ModuleNotFoundError:
warn = getattr(get_operators(), Config.fb_warning_callname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktProblem)
return {'CANCELLED'}
except pkt.module().ModelLoadingException:
warn = getattr(get_operators(), Config.fb_warning_callname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktModelProblem)
return {'CANCELLED'}
except Exception:
warn = getattr(get_operators(), Config.fb_warning_callname)
warn('INVOKE_DEFAULT', msg=ErrorType.PktProblem)
return {'CANCELLED'}
attrs.add_to_fb_collection(obj) # link to FB objects collection
FBLoader.set_keentools_version(obj) # Mark Keentools attribute
bpy.ops.object.select_all(action='DESELECT')
obj.select_set(state=True)
bpy.context.view_layer.objects.active = obj
# bpy.ops.object.shade_smooth()
h = get_main_settings().heads.add()
h.headobj = obj
h.mod_ver = FBLoader.get_builder_version()
h.reset_sensor_size()
h.save_cam_settings()
settings.current_headnum = settings.get_last_headnum()
try:
a = context.area
# Try to show UI Panel
a.spaces[0].show_region_ui = True
except Exception:
pass
pkt.reset_cached_is_installed()
logger.debug('HEAD HAS BEEN SUCCESSFULLY CREATED')
return {'FINISHED'}
class FaceBuilderCameraInput(pkt.module().FaceBuilderCameraInputI):
@classmethod
def _camera_at(cls, keyframe):
settings = get_main_settings()
head = settings.get_current_head()
assert head is not None
return head.get_camera_by_keyframe(keyframe)
def projection(self, keyframe):
camera = self._camera_at(keyframe)
assert camera is not None
return camera.get_projection_matrix()
def view(self, keyframe):
return np.eye(4)
def image_size(self, keyframe):
camera = self._camera_at(keyframe)
assert camera is not None
return camera.get_oriented_image_size()
def bake_tex(headnum, tex_name):
logger = logging.getLogger(__name__)
settings = get_main_settings()
head = settings.get_head(headnum)
if not head.has_cameras():
logger.debug("NO CAMERAS ON HEAD")
return False
camnums = [cam_idx for cam_idx, cam in enumerate(head.cameras)
if cam.use_in_tex_baking and \
_cam_image_data_exists(cam) and \
cam.has_pins()]
frames_count = len(camnums)
if frames_count == 0:
logger.debug("NO FRAMES FOR TEXTURE BUILDING")
return False
fb = _get_fb_for_bake_tex(headnum, head)
frame_data_loader = _create_frame_data_loader(settings, head, camnums, fb)
bpy.context.window_manager.progress_begin(0, 1)
class ProgressCallBack(pkt.module().ProgressCallback):
def set_progress_and_check_abort(self, progress):
bpy.context.window_manager.progress_update(progress)
return False
progress_callBack = ProgressCallBack()
built_texture = pkt.module().texture_builder.build_texture(
frames_count, frame_data_loader, progress_callBack,
settings.tex_height, settings.tex_width,
settings.tex_face_angles_affection, settings.tex_uv_expand_percents,
settings.tex_back_face_culling, settings.tex_equalize_brightness,
settings.tex_equalize_colour, settings.tex_fill_gaps)
bpy.context.window_manager.progress_end()
_create_bpy_texture_from_img(built_texture, tex_name)
return True
def _delete_found_pin(self, nearest, context):
logger = logging.getLogger(__name__)
settings = get_main_settings()
headnum = settings.current_headnum
camnum = settings.current_camnum
head = settings.get_head(headnum)
kid = settings.get_keyframe(headnum, camnum)
cam = head.get_camera(camnum)
camobj = cam.camobj
fb = FBLoader.get_builder()
fb.remove_pin(kid, nearest)
del FBLoader.viewport().spins[nearest]
logging.debug("PIN REMOVED {}".format(nearest))
FBLoader.rigidity_setup()
fb.set_focal_length_estimation(head.auto_focal_estimation)
try:
fb.solve_for_current_pins(kid)
except pkt.module().UnlicensedException:
settings.force_out_pinmode = True
settings.license_error = True
FBLoader.out_pinmode(headnum, camnum)
logger.error("PINMODE LICENSE EXCEPTION")
return {'FINISHED'}
FBLoader.auto_focal_estimation_post(head, camobj)
FBLoader.update_pins_count(headnum, camnum)
coords.update_head_mesh(fb, head.headobj)
FBLoader.update_all_camera_positions(headnum)
FBLoader.viewport().update_surface_points(fb, head.headobj, kid)
FBLoader.shader_update(head.headobj)
# Save result
FBLoader.fb_save(headnum, camnum)
manipulate.push_head_state_in_undo_history(head, 'Pin remove')
FBLoader.viewport().create_batch_2d(context)
return {"RUNNING_MODAL"}
def _draw_version(self, layout):
box = layout.box()
box.label(text="Version {}, built {}".format(
pkt.module().__version__,
pkt.module().build_time))
def _draw_license_info(self, layout):
layout.label(text='License info:')
box = layout.box()
lm = pkt.module().FaceBuilder.license_manager()
_multi_line_text_to_output_labels(box, lm.license_status_text(force_check=False))
box.row().prop(self, "lic_type", expand=True)
if self.lic_type == 'ONLINE':
box = layout.box()
row = box.split(factor=0.85)
row.prop(self, "license_id")
install_online_op = row.operator(preferences_operators.PREF_OT_InstallLicenseOnline.bl_idname)
install_online_op.license_id = self.license_id
elif self.lic_type == 'OFFLINE':
self.hardware_id = lm.hardware_id()
row = layout.split(factor=0.65)
row.label(text="Get an activated license file at our site:")
row.operator(
preferences_operators.PREF_OT_OpenManualInstallPage.bl_idname,
icon='URL')
box = layout.box()
row = box.split(factor=0.85)
row.prop(self, "hardware_id")
row.operator(preferences_operators.PREF_OT_CopyHardwareId.bl_idname)
row = box.split(factor=0.85)
row.prop(self, "lic_path")
install_offline_op = row.operator(preferences_operators.PREF_OT_InstallLicenseOffline.bl_idname)
install_offline_op.lic_path = self.lic_path
elif self.lic_type == 'FLOATING':
env = pkt.module().LicenseManager.env_server_info()
if env is not None:
self.license_server = env[0]
self.license_server_port = env[1]
self.license_server_lock = True
else:
self.license_server_lock = False
box = layout.box()
row = box.split(factor=0.35)
row.label(text="License Server host/IP")
if self.license_server_lock and self.license_server_auto:
row.label(text=self.license_server)
else:
row.prop(self, "license_server", text="")
row = box.split(factor=0.35)
row.label(text="License Server port")
if self.license_server_lock and self.license_server_auto:
row.label(text=str(self.license_server_port))
else:
row.prop(self, "license_server_port", text="")
if self.license_server_lock:
box.prop(self, "license_server_auto",
text="Auto server/port settings")
floating_install_op = row.operator(preferences_operators.PREF_OT_FloatingConnect.bl_idname)
floating_install_op.license_server = self.license_server
floating_install_op.license_server_port = self.license_server_port
def execute(self, context):
hardware_id = pkt.module().FaceBuilder.license_manager().hardware_id()
context.window_manager.clipboard = hardware_id
self.report({'INFO'}, 'Hardware ID is in clipboard!')
return {'FINISHED'}
def solve(cls, headnum, camnum):
def _exception_handling(headnum, msg, license_err=True):
logger = logging.getLogger(__name__)
logger.error(msg)
if settings.pinmode:
settings.force_out_pinmode = True
settings.license_error = license_err
cls.out_pinmode(headnum)
def _unfix_all(fb, head):
for cam in head.cameras:
fb.set_focal_length_fixed_at(cam.get_keyframe(), False)
def _fix_all_except_this(fb, head, exclude_kid):
for cam in head.cameras:
fb.set_focal_length_fixed_at(cam.get_keyframe(),
cam.get_keyframe() != exclude_kid)
def _unfix_not_in_groups(fb, head):
for cam in head.cameras:
fb.set_focal_length_fixed_at(
cam.get_keyframe(),
cam.is_in_group()
or not cam.auto_focal_estimation)
def _auto_focal_estimation_mode_and_fixes():
mode = 'FB_ESTIMATE_VARYING_FOCAL_LENGTH'
if head.smart_mode():
if camera.auto_focal_estimation:
if camera.is_in_group():
for cam in head.cameras:
fb.set_focal_length_fixed_at(
cam.get_keyframe(),
cam.image_group != camera.image_group
or not cam.auto_focal_estimation)
mode = 'FB_ESTIMATE_STATIC_FOCAL_LENGTH'
else: # image_group in (-1, 0)
for cam in head.cameras:
fb.set_focal_length_fixed_at(
cam.get_keyframe(),
cam.image_group > 0
or not cam.auto_focal_estimation)
mode = 'FB_ESTIMATE_VARYING_FOCAL_LENGTH'
else:
_unfix_not_in_groups(fb, head)
mode = 'FB_ESTIMATE_VARYING_FOCAL_LENGTH'
else: # Override all
if head.manual_estimation_mode == 'all_different':
_unfix_all(fb, head)
mode = 'FB_ESTIMATE_VARYING_FOCAL_LENGTH'
elif head.manual_estimation_mode == 'current_estimation':
_fix_all_except_this(fb, head, kid)
mode = 'FB_ESTIMATE_VARYING_FOCAL_LENGTH'
elif head.manual_estimation_mode == 'same_focus':
_unfix_all(fb, head)
mode = 'FB_ESTIMATE_STATIC_FOCAL_LENGTH'
elif head.manual_estimation_mode == 'force_focal':
for cam in head.cameras:
fb.update_projection_mat(cam.get_keyframe(),
cam.get_custom_projection_matrix(head.focal))
fb.update_image_size(cam.get_keyframe(),
cam.get_oriented_image_size())
mode = 'FB_FIXED_FOCAL_LENGTH_ALL_FRAMES'
else:
assert(False), 'Unknown mode: {}'.format(
head.manual_estimation_mode)
return mode
def _update_camera_focal_post():
focal = cls.get_keyframe_focal(kid)
camera.camobj.data.lens = focal
camera.focal = focal
settings = get_main_settings()
head = settings.get_head(headnum)
camera = head.get_camera(camnum)
kid = camera.get_keyframe()
fb = cls.get_builder()
cls.rigidity_setup()
fb.set_use_emotions(head.should_use_emotions())
mode = _auto_focal_estimation_mode_and_fixes()
fb.set_focal_length_estimation_mode(mode)
try:
fb.solve_for_current_pins(kid)
except pkt.module().UnlicensedException:
_exception_handling(headnum, 'SOLVE LICENSE EXCEPTION')
return False
except pkt.module().InvalidArgumentException:
_exception_handling(headnum, 'SOLVE NO KEYFRAME EXCEPTION',
license_err=False)
return False
except Exception as err:
_exception_handling(headnum,
'SOLVE UNKNOWN EXCEPTION: {}'.format(str(err)),
license_err=False)
return False
_update_camera_focal_post()
return True
def load_csv_animation_to_blendshapes(obj, filepath):
logger = logging.getLogger(__name__)
try:
fan = pkt.module().FacsAnimation()
read_facs, ignored_columns = fan.load_from_csv_file(filepath)
facs_names = pkt.module().FacsExecutor.facs_names
except pkt.module().FacsLoadingException as err:
logger.error('CANNOT_LOAD_CSV_ANIMATION: {}'.format(err))
return {
'status': False,
'message': str(err),
'ignored': [],
'read_facs': []
}
except Exception as err:
logger.error('CANNOT_LOAD_CSV_ANIMATION!: {} {}'.format(
type(err), err))
return {
'status': False,
'message': str(err),
'ignored': [],
'read_facs': []
}
action_name = os.path.splitext(os.path.basename(filepath))[0]
blendshapes_action = _get_safe_blendshapes_action(obj, action_name)
scene = bpy.context.scene
fps = scene.render.fps
start = scene.frame_current
if not fan.timecodes_enabled():
fps = 1
keyframes = [start + x * fps for x in fan.keyframes()]
if len(keyframes) > 0:
start_keyframe = keyframes[0]
end_keyframe = keyframes[-1]
else:
start_keyframe = 0
end_keyframe = -1
for name in facs_names:
blendshape_fcurve = _get_safe_action_fcurve(
blendshapes_action, 'key_blocks["{}"].value'.format(name), index=0)
_cleanup_keys_in_interval(blendshape_fcurve, start_keyframe,
end_keyframe)
if name in read_facs:
anim_data = [x for x in zip(keyframes, fan.at_name(name))]
_put_anim_data_in_fcurve(blendshape_fcurve, anim_data)
_snap_keys_in_interval(blendshape_fcurve, start_keyframe,
end_keyframe)
else:
_add_zero_keys_at_start_and_end(blendshape_fcurve, start_keyframe,
end_keyframe)
obj.data.update()
if len(keyframes) > 0:
_extend_scene_timeline(keyframes[-1])
logger.info('FACS CSV-Animation file: {}'.format(filepath))
logger.info('Timecodes enabled: {}'.format(fan.timecodes_enabled()))
if len(ignored_columns) > 0:
logger.info('Ignored columns: {}'.format(ignored_columns))
if len(read_facs) > 0:
logger.info('Read facs: {}'.format(read_facs))
return {
'status': True,
'message': 'ok',
'ignored': ignored_columns,
'read_facs': read_facs
}
class ProgressCallBack(pkt.module().ProgressCallback):
def set_progress_and_check_abort(self, progress):
bpy.context.window_manager.progress_update(progress)
return False
def init_bodybuilder(self, ver=Config.unknown_mod_ver):
self.builder = pkt.module().BodyBuilder()
self.builder_type = BuilderType.BodyBuilder
self.version = ver
def test_non_loaded_uninstalled_load():
if pkt.loaded():
return
pkt.uninstall()
with pytest.raises(ImportError):
pkt.module()
def get_update_checker(cls):
pykeentools = pkt.module()
platform = 'Blender'
ver = pykeentools.Version(*bpy.app.version)
uc = pykeentools.UpdatesChecker.instance(platform, ver)
return uc
def execute(self, context):
hardware_id = pkt.module().FaceBuilder.license_manager().hardware_id()
bpy.ops.wm.url_open(url=Config.manual_install_url + '#' + hardware_id)
return {'FINISHED'}
def _check_facs_available(count):
return pkt.module().FacsExecutor.facs_available(count)
def update_camera_params(cls, head):
""" Update when some camera parameters changes """
logger = logging.getLogger(__name__)
logger.debug("UPDATE CAMERA PARAMETERS")
settings = get_main_settings()
scene = bpy.context.scene
# Check scene consistency
heads_deleted, cams_deleted = settings.fix_heads()
headnum = -1
for i, h in enumerate(settings.heads):
if head == h:
headnum = i
if headnum < 0:
return
rx = scene.render.resolution_x
ry = scene.render.resolution_y
# NoneBuilder for auto-select builder class
fb = cls.new_builder(BuilderType.NoneBuilder, head.mod_ver)
cls.load_only(headnum)
max_index = -1
max_pins = -1
for i, c in enumerate(head.cameras):
kid = c.get_keyframe()
cls.set_camera_projection(
head.focal, head.sensor_width, rx, ry)
# We are looking for keyframe that has maximum pins
if c.has_pins():
if max_pins < c.pins_count:
max_index = kid
max_pins = c.pins_count
c.camobj.data.lens = head.focal
c.camobj.data.sensor_width = head.sensor_width
c.camobj.data.sensor_height = head.sensor_height
# Setup Rigidity only for FaceBuilder
FBLoader.rigidity_setup()
# Activate Focal Estimation
fb.set_focal_length_estimation(head.auto_focal_estimation)
if max_index >= 0:
try:
# Solver
fb.solve_for_current_pins(max_index)
logger.debug("SOLVED {}".format(max_index))
except pkt.module().UnlicensedException:
logger.error("LICENSE PROBLEM")
settings.force_out_pinmode = True
settings.license_error = True
except Exception:
logger.error("SOLVER PROBLEM")
settings.force_out_pinmode = True
# Head Mesh update
coords.update_head_mesh(fb, head.headobj)
if settings.pinmode:
cls.fb_redraw(headnum, settings.current_camnum)
cls.update_all_camera_positions(headnum)
cls.save_only(headnum)
def get_latest_version(self):
if self.builder_type in {BuilderType.NoneBuilder,
BuilderType.FaceBuilder}:
return pkt.module().FaceBuilder.latest_face_version()
else:
return Config.unknown_mod_ver
