def test_SGC_blank_block(self):
        sgc = sr.StaticGratingCircle(monitor=self.monitor,
                                     indicator=self.indicator,
                                     background=0.,
                                     coordinate='degree',
                                     center=(0., 30.),
                                     sf_list=(0.04, ),
                                     ori_list=(90., ),
                                     con_list=(0.8, ),
                                     radius_list=(50., ),
                                     phase_list=(
                                         0.,
                                         180.,
                                     ),
                                     display_dur=0.1,
                                     midgap_dur=0.1,
                                     iteration=2,
                                     pregap_dur=0.,
                                     postgap_dur=0.,
                                     is_blank_block=True)
        all_conditions = sgc._generate_all_conditions()
        # print('\nSGC all_conditions:')
        # print('\n'.join([str(c) for c in all_conditions]))
        assert (all_conditions[-1] == (0., 0., 0., 0., 0.))

        frames_unique = sgc._generate_frames_for_index_display()
        for frame in frames_unique:
            assert (len(frame) == 7)
        # print('\nSGC frames_unique:')
        # print('\n'.join([str(f) for f in frames_unique]))
        assert (frames_unique[-1] == (1, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0))
        assert (frames_unique[-2] == (1, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0))

        _, index_to_display = sgc._generate_display_index()
        assert (len(index_to_display) == 66)
    def test_SGC_generate_frames_for_index_display(self):
        sgc = sr.StaticGratingCircle(monitor=self.monitor,
                                     indicator=self.indicator,
                                     background=0.,
                                     coordinate='degree',
                                     center=(0., 30.),
                                     sf_list=(0.02, 0.04, 0.08),
                                     ori_list=(0., 45., 90., 135.),
                                     con_list=(0.2, 0.5, 0.8),
                                     radius_list=(50., ),
                                     phase_list=(0., 90., 180., 270.),
                                     display_dur=0.25,
                                     midgap_dur=0.,
                                     iteration=2,
                                     pregap_dur=2.,
                                     postgap_dur=3.,
                                     is_blank_block=False)
        frames_unique = sgc._generate_frames_for_index_display()
        # print len(frames_unique)
        assert (len(frames_unique) == (3 * 4 * 3 * 4 * 2 + 1))
        for frame in frames_unique:
            assert (len(frame) == 7)

        sgc = sr.StaticGratingCircle(monitor=self.monitor,
                                     indicator=self.indicator,
                                     background=0.,
                                     coordinate='degree',
                                     center=(0., 30.),
                                     sf_list=(0.02, 0.04, 0.08),
                                     ori_list=(0., 90., 180., 270.),
                                     con_list=(0.2, 0.5, 0.8),
                                     radius_list=(50., ),
                                     phase_list=(0., 90., 180., 270.),
                                     display_dur=0.25,
                                     midgap_dur=0.,
                                     iteration=2,
                                     pregap_dur=2.,
                                     postgap_dur=3.,
                                     is_blank_block=False)
        frames_unique = sgc._generate_frames_for_index_display()
        # print len(frames_unique)
        assert (len(frames_unique) == (3 * 2 * 3 * 4 * 2 + 1))
 def test_SGC_generate_generate_display_index(self):
     sgc = sr.StaticGratingCircle(monitor=self.monitor, indicator=self.indicator, background=0.,
                                  coordinate='degree', center=(0., 30.), sf_list=(0.02, 0.04, 0.08),
                                  ori_list=(0., 45., 90., 135.), con_list=(0.2, 0.5, 0.8),
                                  radius_list=(50.,), phase_list=(0., 90., 180., 270.),
                                  display_dur=0.25, midgap_dur=0.1, iteration=2, pregap_dur=2.,
                                  postgap_dur=3.)
     frames_unique, index_to_display = sgc._generate_display_index()
     assert (max(index_to_display) == len(frames_unique) - 1)
     # print len(index_to_display)
     # print index_to_display
     assert (len(index_to_display) == 6342)
                                 background=background, center=dgc_center,
                                 sf_list=dgc_sf_list, tf_list=dgc_tf_list,
                                 dire_list=dgc_dire_list, con_list=dgc_con_list,
                                 radius_list=dgc_radius_list, block_dur=dgc_block_dur,
                                 midgap_dur=dgc_midgap_dur, iteration=dgc_iteration,
                                 is_smooth_edge=dgc_is_smooth_edge,
                                 smooth_width_ratio=dgc_smooth_width_ratio,
                                 smooth_func=dgc_smooth_func, is_blank_block=dgc_is_blank_block)
# =================================================================================

# ======================= Static Grating Cricle ===================================
sgc = stim.StaticGratingCircle(monitor=mon, indicator=ind, pregap_dur=pregap_dur,
                               postgap_dur=postgap_dur, coordinate=coordinate,
                               background=background, center=sgc_center,
                               sf_list=sgc_sf_list, ori_list=sgc_ori_list,
                               con_list=sgc_con_list, radius_list=sgc_radius_list,
                               phase_list=sgc_phase_list, display_dur=sgc_display_dur,
                               midgap_dur=sgc_midgap_dur, iteration=sgc_iteration,
                               is_smooth_edge=sgc_is_smooth_edge,
                               smooth_width_ratio=sgc_smooth_width_ratio,
                               smooth_func=sgc_smooth_func, is_blank_block=sgc_is_blank_block)
# =================================================================================

# =============================== Static Images ===================================
si = stim.StaticImages(monitor=mon, indicator=ind, pregap_dur=pregap_dur,
                       postgap_dur=postgap_dur, coordinate=coordinate,
                       background=background, img_center=si_img_center,
                       deg_per_pixel=si_deg_per_pixel, display_dur=si_display_dur,
                       midgap_dur=si_midgap_dur, iteration=si_iteration,
                       is_blank_block=si_is_blank_block)
# =================================================================================