def sample_period()

in dvd_generation/filters/dialogue_filters.py [0:0]


def sample_period(dialogue, template, scene_struct, turn_dependencies, metadata, used_periods):
    last_unique_obj_idx = template['prior_unique_obj']
    cutoff = template['cutoff']
    
    if len(dialogue)==0 or template['interval_type'] == 'none' or \
        (len(dialogue)>0 and dialogue[-1]['template']['interval_type'] == 'none'):
        period_idx = sample_period_idx(dialogue, template, scene_struct, used_periods, 
                                       turn_dependencies, last_unique_obj_idx) 
        template['used_periods'] = copy.deepcopy(used_periods)
        return period_idx 
    
    else:
        last_template = dialogue[-1]['template']
        prior_period = last_template['used_periods'][-1]
        #original_period = copy.deepcopy(prior_period)
        prior_interval = last_template['interval_type']
        last_question_type = last_template['nodes'][-1]['type']
        curr_interval = template['interval_type']
        curr_question_type = template['nodes'][-1]['type']        
        curr_periods = scene_struct[intervals_to_periods[curr_interval]]
        # special tags fo special cases e.g. among those actions ..., during this activities, ....
        tag, prior_period = sample_among_prior_actions(dialogue, scene_struct, prior_period, cutoff)
        if tag == '': tag, prior_period = sample_unique_answer_action(dialogue, scene_struct, prior_period, cutoff)
        if tag != '':
            template['new_prior_period'] = prior_period
        while(True):
            while(True): 
                sampled = random.choice(metadata['turn_dependencies']['temporal'])
                # avoid cases without temporal localization (i.e. none) when tag is not empty 
                if sample_by_prop(not_none_temporal_dependency_p) and tag!='' and sampled=='none':
                    continue
                break 

            turn_dependencies['temporal'] = sampled if sampled=='none' else tag+sampled
            prior_temporal_dependency = dialogue[-1]['turn_dependencies']['temporal']
            
            if sampled == 'none':
                period_idx = sample_period_idx(dialogue, template, scene_struct, used_periods, 
                                               turn_dependencies, last_unique_obj_idx)
                template['used_periods'] = copy.deepcopy(used_periods)
                return period_idx 
            
            elif sampled == 'during': 
                # Avoid asking count/exist if previous turn is also count/exist 
                # this is to avoid redudant questions being asked in contiguous turns 
                if 'count' in last_question_type or 'exist' in last_question_type \
                    and ('count' in curr_question_type or 'exist' in curr_question_type):
                    continue 
                # Limit to one repetition of prior period only to avoid confusion 
                if prior_temporal_dependency in ['during', 'excluding', 'before', 'after', 'video_update']: 
                    continue  
                # if prior period is during a whole video, skip
                if prior_period == (None, cutoff):
                    continue 
                if prior_period not in curr_periods:
                    # atomic interval set is a subset of compositional interval set, so it's okay to skip
                    if prior_interval == 'compositional' and curr_interval == 'atomic': continue 
                    pdb.set_trace()
                period_idx = curr_periods.index(prior_period)
                used_periods.append(prior_period)
                template['used_periods'] = copy.deepcopy(used_periods)
                return period_idx
            
            elif sampled in ['before', 'after']:
                # to avoid confusion, before and after cannot go after an excluding, before, after type of interval 
                if prior_temporal_dependency in ['excluding', 'before', 'after', 'during', 'video_update']: 
                    continue 
                # if prior period is during a whole video, skip
                if prior_period == (None, cutoff):
                    continue 
                period_idx, new_period = sample_relative_period(curr_periods, used_periods, prior_period, 
                                                                curr_interval, sampled, cutoff, scene_struct)
                if period_idx == -1: continue 
                used_periods.append(new_period)
                template['used_periods'] = copy.deepcopy(used_periods)
                return period_idx 
            
            '''
            elif sampled == 'excluding':
                # TODO: implement excluding when cutoff is not None ? 
                if cutoff is not None:
                    continue 
                # Limit to one repetition of prior period only
                if prior_temporal_dependency in ['during', 'before', 'after', 'excluding']: 
                    continue       
                # if prior period is during a whole video, skip
                if prior_period == (None, cutoff):
                    continue 
                # excluding is only for compositional interval 
                if curr_interval == 'atomic': 
                    continue 
                if prior_period not in curr_periods:
                    pdb.set_trace()
                period_idx = curr_periods.index(prior_period)
                used_periods.append(prior_period)
                template['used_periods'] = copy.deepcopy(used_periods)
                return period_idx   
            '''