|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import gradio as gr |
|
from modules.ui_components import FormRow, FormColumn |
|
from .defaults import get_gradio_html, DeforumAnimPrompts |
|
from .video_audio_utilities import direct_stitch_vid_from_frames |
|
from .gradio_funcs import upload_vid_to_interpolate, upload_pics_to_interpolate, ncnn_upload_vid_to_upscale, upload_vid_to_depth |
|
|
|
def create_gr_elem(d): |
|
|
|
|
|
obj_type_str = ''.join(word.title() for word in d["type"].split('_')) |
|
obj_type = getattr(gr, obj_type_str) |
|
|
|
|
|
params = {k: v for k, v in d.items() if k != "type" and v is not None} |
|
|
|
|
|
|
|
|
|
if 'type_param' in params: |
|
params['type'] = params.pop('type_param') |
|
|
|
return obj_type(**params) |
|
|
|
|
|
|
|
|
|
def get_tab_run(d, da): |
|
with gr.TabItem('Run'): |
|
with FormRow(): |
|
motion_preview_mode = create_gr_elem(d.motion_preview_mode) |
|
with FormRow(): |
|
sampler = create_gr_elem(d.sampler) |
|
steps = create_gr_elem(d.steps) |
|
with FormRow(): |
|
W = create_gr_elem(d.W) |
|
H = create_gr_elem(d.H) |
|
with FormRow(): |
|
seed = create_gr_elem(d.seed) |
|
batch_name = create_gr_elem(d.batch_name) |
|
with FormRow(): |
|
restore_faces = create_gr_elem(d.restore_faces) |
|
tiling = create_gr_elem(d.tiling) |
|
enable_ddim_eta_scheduling = create_gr_elem(da.enable_ddim_eta_scheduling) |
|
enable_ancestral_eta_scheduling = create_gr_elem(da.enable_ancestral_eta_scheduling) |
|
with gr.Row(variant='compact') as eta_sch_row: |
|
ddim_eta_schedule = create_gr_elem(da.ddim_eta_schedule) |
|
ancestral_eta_schedule = create_gr_elem(da.ancestral_eta_schedule) |
|
|
|
with gr.Accordion('Batch Mode, Resume and more', open=False): |
|
with gr.Tab('Batch Mode/ run from setting files'): |
|
with gr.Row(): |
|
override_settings_with_file = gr.Checkbox(label="Enable batch mode", value=False, interactive=True, elem_id='override_settings', |
|
info="run from a list of setting .txt files. Upload them to the box on the right (visible when enabled)") |
|
custom_settings_file = gr.File(label="Setting files", interactive=True, file_count="multiple", file_types=[".txt"], elem_id="custom_setting_file", visible=False) |
|
|
|
with gr.Tab('Resume Animation'): |
|
with FormRow(): |
|
resume_from_timestring = create_gr_elem(da.resume_from_timestring) |
|
resume_timestring = create_gr_elem(da.resume_timestring) |
|
with gr.Row(variant='compact') as pix2pix_img_cfg_scale_row: |
|
pix2pix_img_cfg_scale_schedule = create_gr_elem(da.pix2pix_img_cfg_scale_schedule) |
|
return {k: v for k, v in {**locals(), **vars()}.items()} |
|
|
|
def get_tab_keyframes(d, da, dloopArgs): |
|
with gr.TabItem('Keyframes'): |
|
with FormRow(): |
|
with FormColumn(scale=2): |
|
animation_mode = create_gr_elem(da.animation_mode) |
|
with FormColumn(scale=1, min_width=180): |
|
border = create_gr_elem(da.border) |
|
with FormRow(): |
|
diffusion_cadence = create_gr_elem(da.diffusion_cadence) |
|
max_frames = create_gr_elem(da.max_frames) |
|
|
|
with gr.Accordion('Guided Images', open=False, elem_id='guided_images_accord') as guided_images_accord: |
|
|
|
with gr.Accordion('*READ ME before you use this mode!*', open=False): |
|
gr.HTML(value=get_gradio_html('guided_imgs')) |
|
with FormRow(): |
|
use_looper = create_gr_elem(dloopArgs.use_looper) |
|
with FormRow(): |
|
init_images = create_gr_elem(dloopArgs.init_images) |
|
|
|
with gr.Accordion('Guided images schedules', open=False): |
|
with FormRow(): |
|
image_strength_schedule = create_gr_elem(dloopArgs.image_strength_schedule) |
|
with FormRow(): |
|
blendFactorMax = create_gr_elem(dloopArgs.blendFactorMax) |
|
with FormRow(): |
|
blendFactorSlope = create_gr_elem(dloopArgs.blendFactorSlope) |
|
with FormRow(): |
|
tweening_frames_schedule = create_gr_elem(dloopArgs.tweening_frames_schedule) |
|
with FormRow(): |
|
color_correction_factor = create_gr_elem(dloopArgs.color_correction_factor) |
|
|
|
with gr.Tabs(): |
|
with gr.TabItem('Strength'): |
|
with FormRow(): |
|
strength_schedule = create_gr_elem(da.strength_schedule) |
|
with gr.TabItem('CFG'): |
|
with FormRow(): |
|
cfg_scale_schedule = create_gr_elem(da.cfg_scale_schedule) |
|
with FormRow(): |
|
enable_clipskip_scheduling = create_gr_elem(da.enable_clipskip_scheduling) |
|
with FormRow(): |
|
clipskip_schedule = create_gr_elem(da.clipskip_schedule) |
|
with gr.TabItem('Seed'): |
|
with FormRow(): |
|
seed_behavior = create_gr_elem(d.seed_behavior) |
|
with FormRow() as seed_iter_N_row: |
|
seed_iter_N = create_gr_elem(d.seed_iter_N) |
|
with FormRow(visible=False) as seed_schedule_row: |
|
seed_schedule = create_gr_elem(da.seed_schedule) |
|
with gr.TabItem('SubSeed', open=False) as subseed_sch_tab: |
|
with FormRow(): |
|
enable_subseed_scheduling = create_gr_elem(da.enable_subseed_scheduling) |
|
subseed_schedule = create_gr_elem(da.subseed_schedule) |
|
subseed_strength_schedule = create_gr_elem(da.subseed_strength_schedule) |
|
with FormRow(): |
|
seed_resize_from_w = create_gr_elem(d.seed_resize_from_w) |
|
seed_resize_from_h = create_gr_elem(d.seed_resize_from_h) |
|
|
|
with gr.TabItem('Step'): |
|
with FormRow(): |
|
enable_steps_scheduling = create_gr_elem(da.enable_steps_scheduling) |
|
with FormRow(): |
|
steps_schedule = create_gr_elem(da.steps_schedule) |
|
|
|
with gr.TabItem('Sampler'): |
|
with FormRow(): |
|
enable_sampler_scheduling = create_gr_elem(da.enable_sampler_scheduling) |
|
with FormRow(): |
|
sampler_schedule = create_gr_elem(da.sampler_schedule) |
|
|
|
with gr.TabItem('Checkpoint'): |
|
with FormRow(): |
|
enable_checkpoint_scheduling = create_gr_elem(da.enable_checkpoint_scheduling) |
|
with FormRow(): |
|
checkpoint_schedule = create_gr_elem(da.checkpoint_schedule) |
|
|
|
with gr.Tabs(elem_id='motion_noise_etc'): |
|
with gr.TabItem('Motion') as motion_tab: |
|
with FormColumn() as only_2d_motion_column: |
|
with FormRow(): |
|
zoom = create_gr_elem(da.zoom) |
|
with FormRow(): |
|
angle = create_gr_elem(da.angle) |
|
with FormRow(): |
|
transform_center_x = create_gr_elem(da.transform_center_x) |
|
with FormRow(): |
|
transform_center_y = create_gr_elem(da.transform_center_y) |
|
with FormColumn() as both_anim_mode_motion_params_column: |
|
with FormRow(): |
|
translation_x = create_gr_elem(da.translation_x) |
|
with FormRow(): |
|
translation_y = create_gr_elem(da.translation_y) |
|
with FormColumn(visible=False) as only_3d_motion_column: |
|
with FormRow(): |
|
translation_z = create_gr_elem(da.translation_z) |
|
with FormRow(): |
|
rotation_3d_x = create_gr_elem(da.rotation_3d_x) |
|
with FormRow(): |
|
rotation_3d_y = create_gr_elem(da.rotation_3d_y) |
|
with FormRow(): |
|
rotation_3d_z = create_gr_elem(da.rotation_3d_z) |
|
|
|
with FormRow() as enable_per_f_row: |
|
enable_perspective_flip = create_gr_elem(da.enable_perspective_flip) |
|
with FormRow(visible=False) as per_f_th_row: |
|
perspective_flip_theta = create_gr_elem(da.perspective_flip_theta) |
|
with FormRow(visible=False) as per_f_ph_row: |
|
perspective_flip_phi = create_gr_elem(da.perspective_flip_phi) |
|
with FormRow(visible=False) as per_f_ga_row: |
|
perspective_flip_gamma = create_gr_elem(da.perspective_flip_gamma) |
|
with FormRow(visible=False) as per_f_f_row: |
|
perspective_flip_fv = create_gr_elem(da.perspective_flip_fv) |
|
|
|
with gr.TabItem('Noise'): |
|
with FormColumn() as noise_tab_column: |
|
with FormRow(): |
|
noise_type = create_gr_elem(da.noise_type) |
|
with FormRow(): |
|
noise_schedule = create_gr_elem(da.noise_schedule) |
|
with FormRow() as perlin_row: |
|
with FormColumn(min_width=220): |
|
perlin_octaves = create_gr_elem(da.perlin_octaves) |
|
with FormColumn(min_width=220): |
|
perlin_persistence = create_gr_elem(da.perlin_persistence) |
|
|
|
perlin_w = create_gr_elem(da.perlin_w) |
|
perlin_h = create_gr_elem(da.perlin_h) |
|
with FormRow(): |
|
enable_noise_multiplier_scheduling = create_gr_elem(da.enable_noise_multiplier_scheduling) |
|
with FormRow(): |
|
noise_multiplier_schedule = create_gr_elem(da.noise_multiplier_schedule) |
|
|
|
with gr.TabItem('Coherence', open=False) as coherence_accord: |
|
with FormRow(): |
|
color_coherence = create_gr_elem(da.color_coherence) |
|
color_force_grayscale = create_gr_elem(da.color_force_grayscale) |
|
with FormRow(): |
|
legacy_colormatch = create_gr_elem(da.legacy_colormatch) |
|
with FormRow(visible=False) as color_coherence_image_path_row: |
|
color_coherence_image_path = create_gr_elem(da.color_coherence_image_path) |
|
with FormRow(visible=False) as color_coherence_video_every_N_frames_row: |
|
color_coherence_video_every_N_frames = create_gr_elem(da.color_coherence_video_every_N_frames) |
|
with FormRow() as optical_flow_cadence_row: |
|
with FormColumn(min_width=220) as optical_flow_cadence_column: |
|
optical_flow_cadence = create_gr_elem(da.optical_flow_cadence) |
|
with FormColumn(min_width=220, visible=False) as cadence_flow_factor_schedule_column: |
|
cadence_flow_factor_schedule = create_gr_elem(da.cadence_flow_factor_schedule) |
|
with FormRow(): |
|
with FormColumn(min_width=220): |
|
optical_flow_redo_generation = create_gr_elem(da.optical_flow_redo_generation) |
|
with FormColumn(min_width=220, visible=False) as redo_flow_factor_schedule_column: |
|
redo_flow_factor_schedule = create_gr_elem(da.redo_flow_factor_schedule) |
|
with FormRow(): |
|
contrast_schedule = gr.Textbox(label="Contrast schedule", lines=1, value=da.contrast_schedule, interactive=True, |
|
info="adjusts the overall contrast per frame [neutral at 1.0, recommended to *not* play with this param]") |
|
diffusion_redo = gr.Slider(label="Redo generation", minimum=0, maximum=50, step=1, value=da.diffusion_redo, interactive=True, |
|
info="this option renders N times before the final render. it is suggested to lower your steps if you up your redo. seed is randomized during redo generations and restored afterwards") |
|
with FormRow(): |
|
|
|
reroll_blank_frames = create_gr_elem(d.reroll_blank_frames) |
|
reroll_patience = create_gr_elem(d.reroll_patience) |
|
|
|
with gr.TabItem('Anti Blur', elem_id='anti_blur_accord') as anti_blur_tab: |
|
with FormRow(): |
|
amount_schedule = create_gr_elem(da.amount_schedule) |
|
with FormRow(): |
|
kernel_schedule = create_gr_elem(da.kernel_schedule) |
|
with FormRow(): |
|
sigma_schedule = create_gr_elem(da.sigma_schedule) |
|
with FormRow(): |
|
threshold_schedule = create_gr_elem(da.threshold_schedule) |
|
with gr.TabItem('Depth Warping & FOV', elem_id='depth_warp_fov_tab') as depth_warp_fov_tab: |
|
|
|
depth_warp_msg_html = gr.HTML(value='Please switch to 3D animation mode to view this section.', elem_id='depth_warp_msg_html') |
|
with FormRow(visible=False) as depth_warp_row_1: |
|
use_depth_warping = create_gr_elem(da.use_depth_warping) |
|
|
|
leres_license_msg = gr.HTML(value=get_gradio_html('leres'), visible=False, elem_id='leres_license_msg') |
|
depth_algorithm = create_gr_elem(da.depth_algorithm) |
|
midas_weight = create_gr_elem(da.midas_weight) |
|
with FormRow(visible=False) as depth_warp_row_2: |
|
padding_mode = create_gr_elem(da.padding_mode) |
|
sampling_mode = create_gr_elem(da.sampling_mode) |
|
with FormRow(visible=False) as depth_warp_row_3: |
|
aspect_ratio_use_old_formula = create_gr_elem(da.aspect_ratio_use_old_formula) |
|
with FormRow(visible=False) as depth_warp_row_4: |
|
aspect_ratio_schedule = create_gr_elem(da.aspect_ratio_schedule) |
|
with FormRow(visible=False) as depth_warp_row_5: |
|
fov_schedule = create_gr_elem(da.fov_schedule) |
|
with FormRow(visible=False) as depth_warp_row_6: |
|
near_schedule = create_gr_elem(da.near_schedule) |
|
with FormRow(visible=False) as depth_warp_row_7: |
|
far_schedule = create_gr_elem(da.far_schedule) |
|
|
|
return {k: v for k, v in {**locals(), **vars()}.items()} |
|
|
|
def get_tab_prompts(da): |
|
with gr.TabItem('Prompts'): |
|
|
|
with gr.Accordion(label='*Important* notes on Prompts', elem_id='prompts_info_accord', open=False) as prompts_info_accord: |
|
gr.HTML(value=get_gradio_html('prompts')) |
|
with FormRow(): |
|
animation_prompts = gr.Textbox(label="Prompts", lines=8, interactive=True, value=DeforumAnimPrompts(), |
|
info="full prompts list in a JSON format. value on left side is the frame number") |
|
with FormRow(): |
|
animation_prompts_positive = gr.Textbox(label="Prompts positive", lines=1, interactive=True, placeholder="words in here will be added to the start of all positive prompts") |
|
with FormRow(): |
|
animation_prompts_negative = gr.Textbox(label="Prompts negative", value="nsfw, nude", lines=1, interactive=True, |
|
placeholder="words in here will be added to the end of all negative prompts") |
|
|
|
with gr.Accordion('Composable Mask scheduling', open=False): |
|
gr.HTML(value=get_gradio_html('composable_masks')) |
|
with FormRow(): |
|
mask_schedule = create_gr_elem(da.mask_schedule) |
|
with FormRow(): |
|
use_noise_mask = create_gr_elem(da.use_noise_mask) |
|
with FormRow(): |
|
noise_mask_schedule = create_gr_elem(da.noise_mask_schedule) |
|
|
|
return {k: v for k, v in {**locals(), **vars()}.items()} |
|
|
|
def get_tab_init(d, da, dp): |
|
with gr.TabItem('Init'): |
|
|
|
with gr.Tab('Image Init'): |
|
with FormRow(): |
|
with gr.Column(min_width=150): |
|
use_init = create_gr_elem(d.use_init) |
|
with gr.Column(min_width=150): |
|
strength_0_no_init = create_gr_elem(d.strength_0_no_init) |
|
with gr.Column(min_width=170): |
|
strength = create_gr_elem(d.strength) |
|
with FormRow(): |
|
init_image = create_gr_elem(d.init_image) |
|
with FormRow(): |
|
init_image_box = create_gr_elem(d.init_image_box) |
|
|
|
with gr.Tab('Video Init'): |
|
with FormRow(): |
|
video_init_path = create_gr_elem(da.video_init_path) |
|
with FormRow(): |
|
extract_from_frame = create_gr_elem(da.extract_from_frame) |
|
extract_to_frame = create_gr_elem(da.extract_to_frame) |
|
extract_nth_frame = create_gr_elem(da.extract_nth_frame) |
|
overwrite_extracted_frames = create_gr_elem(da.overwrite_extracted_frames) |
|
use_mask_video = create_gr_elem(da.use_mask_video) |
|
with FormRow(): |
|
video_mask_path = create_gr_elem(da.video_mask_path) |
|
|
|
with gr.Tab('Mask Init'): |
|
with FormRow(): |
|
use_mask = create_gr_elem(d.use_mask) |
|
use_alpha_as_mask = create_gr_elem(d.use_alpha_as_mask) |
|
invert_mask = create_gr_elem(d.invert_mask) |
|
overlay_mask = create_gr_elem(d.overlay_mask) |
|
with FormRow(): |
|
mask_file = create_gr_elem(d.mask_file) |
|
with FormRow(): |
|
mask_overlay_blur = create_gr_elem(d.mask_overlay_blur) |
|
with FormRow(): |
|
fill = create_gr_elem(d.fill) |
|
with FormRow(): |
|
full_res_mask = create_gr_elem(d.full_res_mask) |
|
full_res_mask_padding = create_gr_elem(d.full_res_mask_padding) |
|
with FormRow(): |
|
with FormColumn(min_width=240): |
|
mask_contrast_adjust = create_gr_elem(d.mask_contrast_adjust) |
|
with FormColumn(min_width=250): |
|
mask_brightness_adjust = create_gr_elem(d.mask_brightness_adjust) |
|
|
|
with gr.Accordion('Parseq', open=False): |
|
gr.HTML(value=get_gradio_html('parseq')) |
|
with FormRow(): |
|
parseq_manifest = create_gr_elem(dp.parseq_manifest) |
|
with FormRow(): |
|
parseq_use_deltas = create_gr_elem(dp.parseq_use_deltas) |
|
return {k: v for k, v in {**locals(), **vars()}.items()} |
|
|
|
def get_tab_hybrid(da): |
|
with gr.TabItem('Hybrid Video'): |
|
|
|
hybrid_msg_html = gr.HTML(value='Change animation mode to 2D or 3D to enable Hybrid Mode', visible=False, elem_id='hybrid_msg_html') |
|
|
|
with gr.Accordion("Info & Help", open=False): |
|
gr.HTML(value=get_gradio_html('hybrid_video')) |
|
|
|
with gr.Accordion("Hybrid Settings", open=True) as hybrid_settings_accord: |
|
with FormRow(): |
|
hybrid_composite = gr.Radio(['None', 'Normal', 'Before Motion', 'After Generation'], label="Hybrid composite", value=da.hybrid_composite, elem_id="hybrid_composite") |
|
with FormRow(): |
|
with FormColumn(min_width=340): |
|
with FormRow(): |
|
hybrid_generate_inputframes = create_gr_elem(da.hybrid_generate_inputframes) |
|
hybrid_use_first_frame_as_init_image = create_gr_elem(da.hybrid_use_first_frame_as_init_image) |
|
hybrid_use_init_image = create_gr_elem(da.hybrid_use_init_image) |
|
with FormRow(): |
|
with FormColumn(): |
|
with FormRow(): |
|
hybrid_motion = create_gr_elem(da.hybrid_motion) |
|
with FormColumn(): |
|
with FormRow(): |
|
with FormColumn(scale=1): |
|
hybrid_flow_method = create_gr_elem(da.hybrid_flow_method) |
|
with FormRow(): |
|
with FormColumn(): |
|
hybrid_flow_consistency = create_gr_elem(da.hybrid_flow_consistency) |
|
hybrid_consistency_blur = create_gr_elem(da.hybrid_consistency_blur) |
|
with FormColumn(): |
|
hybrid_motion_use_prev_img = create_gr_elem(da.hybrid_motion_use_prev_img) |
|
with FormRow(): |
|
hybrid_comp_mask_type = create_gr_elem(da.hybrid_comp_mask_type) |
|
with gr.Row(visible=False, variant='compact') as hybrid_comp_mask_row: |
|
hybrid_comp_mask_equalize = create_gr_elem(da.hybrid_comp_mask_equalize) |
|
with FormColumn(): |
|
hybrid_comp_mask_auto_contrast = gr.Checkbox(label="Comp mask auto contrast", value=False, interactive=True) |
|
hybrid_comp_mask_inverse = gr.Checkbox(label="Comp mask inverse", value=da.hybrid_comp_mask_inverse, interactive=True) |
|
with FormRow(): |
|
hybrid_comp_save_extra_frames = gr.Checkbox(label="Comp save extra frames", value=False, interactive=True) |
|
|
|
with gr.Accordion("Hybrid Schedules", open=False, visible=False) as hybrid_sch_accord: |
|
with FormRow() as hybrid_comp_alpha_schedule_row: |
|
hybrid_comp_alpha_schedule = create_gr_elem(da.hybrid_comp_alpha_schedule) |
|
with FormRow() as hybrid_flow_factor_schedule_row: |
|
hybrid_flow_factor_schedule = create_gr_elem(da.hybrid_flow_factor_schedule) |
|
with FormRow(visible=False) as hybrid_comp_mask_blend_alpha_schedule_row: |
|
hybrid_comp_mask_blend_alpha_schedule = create_gr_elem(da.hybrid_comp_mask_blend_alpha_schedule) |
|
with FormRow(visible=False) as hybrid_comp_mask_contrast_schedule_row: |
|
hybrid_comp_mask_contrast_schedule = create_gr_elem(da.hybrid_comp_mask_contrast_schedule) |
|
with FormRow(visible=False) as hybrid_comp_mask_auto_contrast_cutoff_high_schedule_row: |
|
hybrid_comp_mask_auto_contrast_cutoff_high_schedule = create_gr_elem(da.hybrid_comp_mask_auto_contrast_cutoff_high_schedule) |
|
with FormRow(visible=False) as hybrid_comp_mask_auto_contrast_cutoff_low_schedule_row: |
|
hybrid_comp_mask_auto_contrast_cutoff_low_schedule = create_gr_elem(da.hybrid_comp_mask_auto_contrast_cutoff_low_schedule) |
|
|
|
with gr.Accordion("Humans Masking", open=False, visible=False) as humans_masking_accord: |
|
with FormRow(): |
|
hybrid_generate_human_masks = create_gr_elem(da.hybrid_generate_human_masks) |
|
|
|
return {k: v for k, v in {**locals(), **vars()}.items()} |
|
|
|
def get_tab_output(da, dv): |
|
with gr.TabItem('Output', elem_id='output_tab'): |
|
|
|
with gr.Accordion('Video Output Settings', open=True): |
|
with FormRow() as fps_out_format_row: |
|
fps = create_gr_elem(dv.fps) |
|
with FormColumn(): |
|
with FormRow() as soundtrack_row: |
|
add_soundtrack = create_gr_elem(dv.add_soundtrack) |
|
soundtrack_path = create_gr_elem(dv.soundtrack_path) |
|
with FormRow(): |
|
skip_video_creation = create_gr_elem(dv.skip_video_creation) |
|
delete_imgs = create_gr_elem(dv.delete_imgs) |
|
delete_input_frames = create_gr_elem(dv.delete_input_frames) |
|
store_frames_in_ram = create_gr_elem(dv.store_frames_in_ram) |
|
save_depth_maps = create_gr_elem(da.save_depth_maps) |
|
make_gif = create_gr_elem(dv.make_gif) |
|
with FormRow(equal_height=True) as r_upscale_row: |
|
r_upscale_video = create_gr_elem(dv.r_upscale_video) |
|
r_upscale_model = create_gr_elem(dv.r_upscale_model) |
|
r_upscale_factor = create_gr_elem(dv.r_upscale_factor) |
|
r_upscale_keep_imgs = create_gr_elem(dv.r_upscale_keep_imgs) |
|
|
|
with gr.Tab('Frame Interpolation') as frame_interp_tab: |
|
with gr.Accordion('Important notes and Help', open=False, elem_id="f_interp_accord"): |
|
gr.HTML(value=get_gradio_html('frame_interpolation')) |
|
with gr.Column(): |
|
with gr.Row(): |
|
|
|
with gr.Column(min_width=110, scale=3): |
|
frame_interpolation_engine = create_gr_elem(dv.frame_interpolation_engine) |
|
with gr.Column(min_width=30, scale=1): |
|
frame_interpolation_slow_mo_enabled = create_gr_elem(dv.frame_interpolation_slow_mo_enabled) |
|
with gr.Column(min_width=30, scale=1): |
|
|
|
frame_interpolation_keep_imgs = create_gr_elem(dv.frame_interpolation_keep_imgs) |
|
with gr.Column(min_width=30, scale=1): |
|
frame_interpolation_use_upscaled = create_gr_elem(dv.frame_interpolation_use_upscaled) |
|
with FormRow(visible=False) as frame_interp_amounts_row: |
|
with gr.Column(min_width=180) as frame_interp_x_amount_column: |
|
|
|
frame_interpolation_x_amount = create_gr_elem(dv.frame_interpolation_x_amount) |
|
with gr.Column(min_width=180, visible=False) as frame_interp_slow_mo_amount_column: |
|
|
|
frame_interpolation_slow_mo_amount = create_gr_elem(dv.frame_interpolation_slow_mo_amount) |
|
with gr.Row(visible=False) as interp_existing_video_row: |
|
|
|
with gr.Accordion('Interpolate existing Video/ Images', open=False) as interp_existing_video_accord: |
|
with gr.Row(variant='compact') as interpolate_upload_files_row: |
|
|
|
vid_to_interpolate_chosen_file = gr.File(label="Video to Interpolate", interactive=True, file_count="single", file_types=["video"], |
|
elem_id="vid_to_interpolate_chosen_file") |
|
|
|
pics_to_interpolate_chosen_file = gr.File(label="Pics to Interpolate", interactive=True, file_count="multiple", file_types=["image"], |
|
elem_id="pics_to_interpolate_chosen_file") |
|
with FormRow(visible=False) as interp_live_stats_row: |
|
|
|
in_vid_frame_count_window = gr.Textbox(label="In Frame Count", lines=1, interactive=False, value='---') |
|
|
|
in_vid_fps_ui_window = gr.Textbox(label="In FPS", lines=1, interactive=False, value='---') |
|
|
|
out_interp_vid_estimated_fps = gr.Textbox(label="Interpolated Vid FPS", value='---') |
|
with FormRow() as interp_buttons_row: |
|
|
|
interpolate_button = gr.Button(value="*Interpolate Video*") |
|
interpolate_pics_button = gr.Button(value="*Interpolate Pics*") |
|
|
|
gr.HTML("* check your CLI for outputs *", elem_id="below_interpolate_butts_msg") |
|
|
|
interpolate_button.click(fn=upload_vid_to_interpolate, |
|
inputs=[vid_to_interpolate_chosen_file, frame_interpolation_engine, frame_interpolation_x_amount, frame_interpolation_slow_mo_enabled, |
|
frame_interpolation_slow_mo_amount, frame_interpolation_keep_imgs, in_vid_fps_ui_window]) |
|
interpolate_pics_button.click(fn=upload_pics_to_interpolate, |
|
inputs=[pics_to_interpolate_chosen_file, frame_interpolation_engine, frame_interpolation_x_amount, frame_interpolation_slow_mo_enabled, |
|
frame_interpolation_slow_mo_amount, frame_interpolation_keep_imgs, fps, add_soundtrack, soundtrack_path]) |
|
|
|
with gr.TabItem('Video Upscaling'): |
|
vid_to_upscale_chosen_file = gr.File(label="Video to Upscale", interactive=True, file_count="single", file_types=["video"], elem_id="vid_to_upscale_chosen_file") |
|
with gr.Column(): |
|
|
|
with FormRow() as ncnn_upload_vid_stats_row: |
|
ncnn_upscale_in_vid_frame_count_window = gr.Textbox(label="In Frame Count", lines=1, interactive=False, |
|
value='---') |
|
ncnn_upscale_in_vid_fps_ui_window = gr.Textbox(label="In FPS", lines=1, interactive=False, value='---') |
|
ncnn_upscale_in_vid_res = gr.Textbox(label="In Res", lines=1, interactive=False, value='---') |
|
ncnn_upscale_out_vid_res = gr.Textbox(label="Out Res", value='---') |
|
with gr.Column(): |
|
with FormRow() as ncnn_actual_upscale_row: |
|
ncnn_upscale_model = create_gr_elem(dv.r_upscale_model) |
|
ncnn_upscale_factor = create_gr_elem(dv.r_upscale_factor) |
|
ncnn_upscale_keep_imgs = create_gr_elem(dv.r_upscale_keep_imgs) |
|
ncnn_upscale_btn = gr.Button(value="*Upscale uploaded video*") |
|
ncnn_upscale_btn.click(fn=ncnn_upload_vid_to_upscale, |
|
inputs=[vid_to_upscale_chosen_file, ncnn_upscale_in_vid_fps_ui_window, ncnn_upscale_in_vid_res, ncnn_upscale_out_vid_res, ncnn_upscale_model, |
|
ncnn_upscale_factor, ncnn_upscale_keep_imgs]) |
|
|
|
with gr.TabItem('Vid2depth'): |
|
vid_to_depth_chosen_file = gr.File(label="Video to get Depth from", interactive=True, file_count="single", file_types=["video"], elem_id="vid_to_depth_chosen_file") |
|
with FormRow(): |
|
mode = gr.Dropdown(label='Mode', elem_id="mode", choices=['Depth (Midas/Adabins)', 'Anime Remove Background', 'Mixed', 'None (just grayscale)'], value='Depth (Midas/Adabins)') |
|
threshold_value = gr.Slider(label="Threshold Value Lower", value=127, minimum=0, maximum=255, step=1) |
|
threshold_value_max = gr.Slider(label="Threshold Value Upper", value=255, minimum=0, maximum=255, step=1) |
|
with FormRow(): |
|
thresholding = gr.Radio(['None', 'Simple', 'Simple (Auto-value)', 'Adaptive (Mean)', 'Adaptive (Gaussian)'], label="Thresholding Mode", value='None') |
|
with FormRow(): |
|
adapt_block_size = gr.Number(label="Block size", value=11) |
|
adapt_c = gr.Number(label="C", value=2) |
|
invert = gr.Checkbox(label='Closer is brighter', value=True, elem_id="invert") |
|
with FormRow(): |
|
end_blur = gr.Slider(label="End blur width", value=0, minimum=0, maximum=255, step=1) |
|
midas_weight_vid2depth = gr.Slider(label="MiDaS weight (vid2depth)", value=da.midas_weight, minimum=0, maximum=1, step=0.05, interactive=True, |
|
info="sets a midpoint at which a depth-map is to be drawn: range [-1 to +1]") |
|
depth_keep_imgs = gr.Checkbox(label='Keep Imgs', value=True, elem_id="depth_keep_imgs") |
|
with FormRow(): |
|
|
|
depth_btn = gr.Button(value="*Get depth from uploaded video*") |
|
with FormRow(): |
|
|
|
gr.HTML("* check your CLI for outputs") |
|
|
|
depth_btn.click(fn=upload_vid_to_depth, |
|
inputs=[vid_to_depth_chosen_file, mode, thresholding, threshold_value, threshold_value_max, adapt_block_size, adapt_c, invert, end_blur, midas_weight_vid2depth, depth_keep_imgs]) |
|
|
|
with gr.TabItem('Frames to Video') as stitch_imgs_to_vid_row: |
|
gr.HTML(value=get_gradio_html('frames_to_video')) |
|
with FormRow(): |
|
image_path = create_gr_elem(dv.image_path) |
|
ffmpeg_stitch_imgs_but = gr.Button(value="*Stitch frames to video*") |
|
ffmpeg_stitch_imgs_but.click(fn=direct_stitch_vid_from_frames, inputs=[image_path, fps, add_soundtrack, soundtrack_path]) |
|
|
|
return {k: v for k, v in {**locals(), **vars()}.items()} |