You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: computeCnmfeSignalExtraction.m
    path of file: ./repos/ciatah/+ciapkg/+signal_extraction
    
    the code of the file until where you have to start completion: function [cnmfeAnalysisOutput] = computeCnmfeSignalExtraction(inputMovie,varargin)
    % Wrapper function for CNMF-E, update for most recent versions.
    % Biafra Ahanonu
    % started: 2018.10.20 [16:38:24]
    % Building off of demo_large_data_1p.m in CNMF-E github repo
    % Most recent commit tested on: https://github.com/epnev/ca_source_extraction/commit/187bbdbe66bca466b83b81861b5601891a95b8d1
    % https://github.com/epnev/ca_source_extraction/blob/master/demo_script_class.m
    % inputs
        % inputMovie - a string or a cell array of strings pointing to the movies to be analyzed (recomme
    
function for easier access in parent functions
        % 2021.08.08 [19:30:20] - Updated to handle CIAtah v4.0 switch to all functions inside ciapkg package.
    % TODO
        %

    import ciapkg.api.* % import CIAtah functions in ciapkg package API.

    % ========================
    % OVERALL
    % turn on parallel
    options.nonCNMF.parallel = 1;
    % Binary: 1 = run merging algorithms
    options.runMerge = 1;
    % Binary: 1 = remove false positives using CNMF-E algorithm
    options.runRemoveFalsePositives = 1;
    % ===COMPUTATION
    % Float: GB, memory space you allow to use in MATLAB
    options.memory_size_to_use = 32; %
    % Float: GB, memory space you allow to use in MATLAB
    options.memory_size_per_patch = 1.2; % 0.6
    % Int vector: patch size in pixels
    options.patch_dims = [128, 128]; % [64, 64]
    % ===SPATIAL
    % Int: pixel, gaussian width of a gaussian kernel for filtering the data. 0 means no filtering
    options.gSig = 3;
    % Int: pixel, neuron diameter
    options.gSiz = 11;
    % Int: spatial downsampling factor
    options.ssub = 1;
    % Binary: movie has dendrites?
    options.with_dendrites = true;
    % Int: expand kernel for HALS growing (default: 3) and expansion factor of ellipse (default: 3)
    options.updateA_bSiz = 5;
    % Char: hals, hals_thresh, lars, nnls
    options.spatial_algorithm = 'hals_thresh';
    % ===TEMPORAL
    % Int: temporal downsampling factor
    options.tsub = 1;
    % Int: frame rate
    options.Fs = 10;
    % Float: minimum spike size. When the value is negative, the actual threshold is abs(smin)*noise level
    options.deconv_smin = -5;
    % Int: maximum decay time (unit: frame);
    options.max_tau = 100;
    % Int: detrending the slow fluctuation. usually 1 is fine (no detrending)
    options.nk = 3;
    % ===BACKGROUND
    % Char: model of the background {'ring', 'svd'(default), 'nmf'}
    options.bg_model = 'ring';
    % Int: number of background sources for each patch (only be used in SVD and NMF model)
    options.nb = 1;
    % Int: when the ring model used, it is the radius of the ring used in the background model. otherwise, it's just the width of the overlapping area
    options.ring_radius = 18;
    % Int: downsample background for a faster speed
    options.bg_ssub = 1;
    % ===MERGING
    % Float: 0 to 1, thresholds for merging neurons; [spatial overlap ratio, temporal correlation of calcium traces, spike correlation]
    options.merge_thr = 0.65;
    % Char: method for computing neuron distances {'mean', 'max'}
    options.method_dist = 'max';
    % Int: minimum distances between two neurons. it is used together with merge_thr
    options.dmin = 5;
    % Int: merge neurons if their distances are smaller than dmin_only.
    options.dmin_only = 2;
    % Float vector: merge components with highly correlated spatial shapes (corr=0.8) and small temporal correlations (corr=0.1)
    options.merge_thr_spatial = [0.8, 0.4, -inf];
    % ===INITIALIZATION
    % Int: maximum number of neurons per patch. when K=[], take as many as possible.
    options.K = [];
    % Float: minimum local correlation for a seeding pixel
    options.min_corr = 0.8;
    % minimum peak-to-noise ratio for a seeding pixel
    options.min_pnr = 8;
    options.bd = 0;             % number of rows/columns to be ignored in the boundary (mainly for motion corrected data)
    options.use_parallel = true;    % use parallel computation for parallel computing
    options.show_init = true;   % show initialization results
    options.center_psf = true;  % set the value as true when the background fluctuation is large (usually 1p data)
    % set the value as false when the background fluctuation is small (2p)
    % ===Residual
    % Float: 0 to 1, minimum local correlation for initializing a neuron (default: 0.3)
    options.min_corr_res = 0.7;
    % Float: stands for minimum peak-to-noise ratio to look for a cell
    options.min_pnr_res = 6;
    % Char: method for initializing neurons from the residual. 'auto' or 'manual'
    options.seed_method_res = 'auto';
    % Binary: boolean, update noise level for each pixel
    options.update_sn = true;

    % get options
    options = getOptions(options,varargin);
    % ========================
    options

    % if cvx is not in the path, ask user for file
    runCvxSetup();

    % Make sure consistent
    options.bg_ssub = options.ssub;

    %% clear the workspace and select data
    % clear; clc; close all;

    %% choose data
    inputFilename = inputMovie;
    neuron = Sources2D();

    nam = get_fullname(inputFilename);          % this demo data is very small, here we just use it as an example
    nam = neuron.select_data(nam);  %if nam is [], then select data interactively

    % nams = {inputFilename};          % you can put all file names into a cell array; when it's empty, manually select files
    % nams = neuron.select_multiple_files(nams);  %if nam is [], then select data interactively

    %% parameters
    % -------------------------    COMPUTATION    -------------------------  %
    pars_envs = struct('memory_size_to_use', options.memory_size_to_use, ...   % GB, memory space you allow to use in MATLAB
        'memory_size_per_patch', options.memory_size_per_patch, ...   % GB, space for loading data within one patch
        'patch_dims', options.patch_dims);  %GB, patch size
    % pars_envs = struct('memory_size_to_use', 8, ...   % GB, memory space you allow to use in MATLAB
    %     'memory_size_per_patch', 0.5, ...   % GB, space for loading data within one patch
    %     'patch_dims', [64, 64],...  %GB, patch size
    %     'batch_frames', 1000);           % number of frames per batch

    % -------------------------      SPATIAL      -------------------------  %
    gSig = options.gSig;           % pixel, gaussian width of a gaussian kernel for filtering the data. 0 means no filtering
    gSiz = options.gSiz;          % pixel, neuron diameter
    ssub = options.ssub;           % spatial downsampling factor
    with_dend