psychopy 2024.2.5__py3-none-any.whl → 2025.1.1__py3-none-any.whl

psychopy/tests/test_hardware/test_CRS_BitsSharp.py

@@ -1,67 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Thu May  8 10:46:41 2014
-
-@author: jon.peirce
-"""
-import pytest
-from psychopy import visual, core
-
-
-def test_bitsSharp():
-    try:
-        from psychopy.hardware.crs import BitsSharp
-    except (ModuleNotFoundError, ImportError):
-        return
-
-    win = visual.Window(screen=0, fullscr=True, useFBO=True, autoLog=True)
-    win.setGamma(1.0) #make sure gfx card LUT is identity
-    #initialise BitsSharp
-    try:
-        bits = BitsSharp(win=win, mode='color++')
-    except ImportError:
-        pytest.skip("crs.BitsSharp: could not initialize. possible:\nfrom serial.tools import list_ports\n"
-           "ImportError: No module named tools")
-
-    if not bits.OK:
-        win.close()
-        pytest.skip("No BitsSharp connected")
-        
-    print(bits.info)
-
-    #switch to status screen (while keeping in mono 'mode')
-    bits.getVideoLine(lineN=1, nPixels=1)
-    core.wait(5) #wait for status mode to take effect
-
-    #create a stimulus to check luminance values
-    screenSqr = visual.GratingStim(win,tex=None, mask=None,
-               size=2)
-
-    print('\n  up from zero:')
-    bit16 = (2.0 ** 16) - 1
-    for frameN in range(5):
-        intensity = frameN / bit16
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    print('\n  down from 1:')
-    for frameN in range(5):
-        intensity = 1 - (frameN / bit16)
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    print('\n  check the middle::')
-    for intensity in [0.5, 0.5 + (1 / bit16)]:
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    bits.mode = "color++" #get out of status screen

psychopy/tests/test_hardware/test_CRS_BitsSharp.py.orig

@@ -1,68 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Thu May  8 10:46:41 2014
-
-@author: jon.peirce
-"""
-import pytest
-from psychopy import visual, core
-from psychopy.hardware import crs
-
-
-def test_bitsSharp():
-    win = visual.Window(screen=1, fullscr=True, useFBO=True, autoLog=True)
-    win.setGamma(1.0) #make sure gfx card LUT is identity
-    #initialise BitsSharp
-    try:
-        bits = crs.BitsSharp(win=win, mode='color++')
-    except ImportError:
-        pytest.skip("crs.BitsSharp: could not initialize. possible:\nfrom serial.tools import list_ports\n"
-           "ImportError: No module named tools")
-
-    if not bits.OK:
-        win.close()
-        pytest.skip("No BitsSharp connected")
-        
-    print(bits.info)
-
-    #switch to status screen (while keeping in mono 'mode')
-    bits.getVideoLine(lineN=1, nPixels=1)
-    core.wait(5) #wait for status mode to take effect
-
-<<<<<<< HEAD
-    #createa  stimulus to check luminance values
-    screenSqr = visual.GratingStim(win, tex=None, mask=None, size=2)
-=======
-    #create a stimulus to check luminance values
-    screenSqr = visual.GratingStim(win,tex=None, mask=None,
-               size=2)
->>>>>>> release
-
-    print('\n  up from zero:')
-    bit16 = (2.0 ** 16) - 1
-    for frameN in range(5):
-        intensity = frameN / bit16
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    print('\n  down from 1:')
-    for frameN in range(5):
-        intensity = 1 - (frameN / bit16)
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    print('\n  check the middle::')
-    for intensity in [0.5, 0.5 + (1 / bit16)]:
-        screenSqr.color = intensity * 2 - 1  # psychopy is -1:1
-        screenSqr.draw()
-        win.flip()
-        pixels = bits.getVideoLine(lineN=1, nPixels=2)
-        print(pixels[0], pixels[1], intensity)
-
-    bits.mode = "color++" #get out of status screen

psychopy/tests/test_hardware/test_CRS_bitsShaders.py

@@ -1,110 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Dec 15 15:22:48 2014
-
-@author: lpzjwp
-"""
-from psychopy import visual
-from psychopy.tools import systemtools
-from psychopy.tests import skip_under_vm
-import numpy as np
-
-try:
-    from PIL import Image
-except ImportError:
-    import Image
-
-
-array=np.array
-#expectedVals = {'bits++':{}, 'mono++':{}, 'color++':{}}
-expectedVals = {
-    'color++': {1024: {'lowG': array([  0,  64,   0, 192,   1,  64,   1, 192,   2,  64]),
-        'highR': array([ 62, 192,  63,  64,  63, 192]),
-        'lowR': array([  0,  64,   0, 192,   1,  64,   1, 192,   2,  64]),
-        'highG': array([ 62, 192,  63,  64,  63, 192])},
-        65535: {'lowG': array([0, 1, 0, 3, 0, 5, 0, 7, 0, 9]),
-        'highR': array([  0, 251,   0, 253,   0, 255]),
-        'lowR': array([0, 1, 0, 3, 0, 5, 0, 7, 0, 9]),
-        'highG': array([  0, 251,   0, 253,   0, 255])},
-        255.0: {'lowG': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-        'highR': array([250, 251, 252, 253, 254, 255]),
-        'lowR': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-        'highG': array([250, 251, 252, 253, 254, 255])}},
-    'mono++':{1024: {'lowG': array([  0,  64, 128, 192,   0,  64, 128, 192,   0,  64]),
-        'highR': array([62, 62, 62, 63, 63, 63]),
-        'lowR': array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2]),
-        'highG': array([128, 192, 255,  64, 128, 192])},
-        65535: {'lowG': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-        'highR': array([0, 0, 0, 0, 0, 0]),
-        'lowR': array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-        'highG': array([250, 251, 252, 253, 254, 255])},
-        255.0: {'lowG': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-        'highR': array([250, 251, 252, 253, 254, 255]),
-        'lowR': array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
-        'highG': array([250, 251, 252, 253, 254, 255])}},
-    'bits++': {
-        1024: {'lowG': array([106, 136,  19,  25, 115,  68,  41, 159,   0,   0]),
-        'highR': array([119, 118, 120, 119, 121, 120]),
-        'lowR': array([ 36,  63,   8, 211,   3, 112,  56,  34,   0,   0]),
-        'highG': array([119, 118, 120, 119, 121, 120])},
-        65535: {'lowG': array([106, 136,  19,  25, 115,  68,  41, 159,   0,   0]),
-        'highR': array([119, 118, 120, 119, 121, 120]),
-        'lowR': array([ 36,  63,   8, 211,   3, 112,  56,  34,   0,   0]),
-        'highG': array([119, 118, 120, 119, 121, 120])},
-        255.0: {'lowG': array([106, 136,  19,  25, 115,  68,  41, 159,   0,   0]),
-        'highR': array([119, 118, 120, 119, 121, 120]),
-        'lowR': array([ 36,  63,   8, 211,   3, 112,  56,  34,   0,   0]),
-        'highG': array([119, 118, 120, 119, 121, 120])}}}
-
-@skip_under_vm
-def test_bitsShaders():
-    try:
-        from psychopy.hardware.crs.bits import BitsSharp
-    except (ModuleNotFoundError, ImportError):
-        return
-
-    win = visual.Window([1024, 768], fullscr=0, screen=1, useFBO=True,
-                        autoLog=True)
-
-    bits = BitsSharp(win, mode='bits++', noComms=True)
-
-    # draw a ramp across the screenexpectedVals = range(256)
-    w, h = win.size
-    intended = list(range(256))
-    testArrLums = np.resize(intended,
-                            [256, 256]) / 127.5 - 1  # NB psychopy uses -1:1
-    stim = visual.ImageStim(win, image=testArrLums,
-                            size=[256, h], pos=[128 - w / 2, 0], units='pix',
-                            )
-    expected = np.repeat(intended, 3).reshape([-1, 3])
-
-    # stick something in the middle for fun!
-    gabor = visual.GratingStim(win, mask='gauss', sf=3, ori=45, contrast=0.5)
-    gabor.autoDraw = True
-
-    #a dict of dicts for expected vals
-    for mode in ['bits++', 'mono++', 'color++']:
-        bits.mode=mode
-        for finalVal in [255.0, 1024, 65535]:
-            thisExpected = expectedVals[mode][finalVal]
-
-            intended = np.linspace(0.0,1,256)*255.0/finalVal
-            stim.image = np.resize(intended,[256,256])*2-1 #NB psychopy uses -1:1
-
-            stim.draw()
-            #fr = np.array(win._getFrame(buffer='back').transpose(Image.ROTATE_270))
-            win.flip()
-            fr = np.array(win._getFrame(buffer='front').transpose(Image.ROTATE_270))
-            if not systemtools.isVM_CI():
-                assert np.all(thisExpected['lowR'] == fr[0:10, -1, 0])
-                assert np.all(thisExpected['lowG'] == fr[0:10, -1, 1])
-                assert np.all(thisExpected['highR'] == fr[250:256, -1, 0])
-                assert np.all(thisExpected['highG'] == fr[250:256, -1, 1])
-
-                print('R', repr(fr[0:10,-1,0]), repr(fr[250:256,-1,0]))
-                print('G', repr(fr[0:10,-1,1]), repr(fr[250:256,-1,0]))
-            #event.waitKeys()
-
-
-if __name__=='__main__':
-    test_bitsShaders()

psychopy/tests/test_visual/test_image.py.orig

@@ -1,219 +0,0 @@
-from pathlib import Path
-
-from psychopy import visual, colors, core
-from .test_basevisual import _TestUnitsMixin
-from psychopy.tests.test_experiment.test_component_compile_python import _TestBoilerplateMixin
-from .. import utils
-
-from ..utils import TESTS_DATA_PATH
-
-
-class TestImage(_TestUnitsMixin, _TestBoilerplateMixin):
-    """
-    Test that images render as expected. Note: In BaseVisual tests, image colors will look different than
-    seems intuitive as foreColor will be set to `"blue"`.
-    """
-    def setup(self):
-        self.win = visual.Window()
-        self.obj = visual.ImageStim(
-            self.win,
-            str(Path(TESTS_DATA_PATH) / 'testimage.jpg'),
-            colorSpace='rgb1',
-        )
-
-    def test_anchor_flip(self):
-        """
-        Check that flipping the image doesn't flip the direction of the anchor
-        """
-        # Setup obj
-        self.obj.units = "height"
-        self.obj.pos = (0, 0)
-        self.obj.size = (0.5, 0.5)
-        self.obj.anchor = "bottom left"
-        # Flip vertically
-        self.obj.flipVert = True
-        self.obj.flipHoriz = False
-        # Check
-        self.win.flip()
-        self.obj.draw()
-        # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / "test_image_flip_anchor_vert.png")
-        utils.compareScreenshot("test_image_flip_anchor_vert.png", self.win, crit=7)
-        # Flip horizontally
-        self.obj.flipVert = False
-        self.obj.flipHoriz = True
-        # Check
-        self.win.flip()
-        self.obj.draw()
-        # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / "test_image_flip_anchor_horiz.png")
-        utils.compareScreenshot("test_image_flip_anchor_horiz.png", self.win, crit=7)
-
-<<<<<<< HEAD
-    def test_aspect_ratio(self):
-        """
-        Test that images set with one or both dimensions as None maintain their aspect ratio
-        """
-        cases = [
-            # norm 1:1
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, 2), "units": "norm",
-             "tag": "default_xNone_yFull"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (2, None), "units": "norm",
-             "tag": "default_xFull_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, None), "units": "norm",
-             "tag": "default_xNone_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": None, "units": "norm",
-             "tag": "default_None"},
-            # height 1:1
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, 1), "units": "height",
-             "tag": "default_xNone_yFull"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (1 / self.win.size[1] * self.win.size[0], None), "units": "height",
-             "tag": "default_xFull_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, None), "units": "height",
-             "tag": "default_xNone_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": None, "units": "height",
-             "tag": "default_None"},
-            # pix 1:1
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, self.win.size[1]), "units": "pix",
-             "tag": "default_xNone_yFull"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (self.win.size[0], None), "units": "pix",
-             "tag": "default_xFull_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": (None, None), "units": "pix",
-             "tag": "default_xNone_yNone"},
-            {"img": "default.png", "aspect": (1, 1),
-             "size": None, "units": "pix",
-             "tag": "default_None"},
-        ]
-        for case in cases:
-            # Set image
-            self.obj.image = case['img']
-            # Set size
-            self.obj.units = case['units']
-            self.obj.size = case['size']
-            # Check that aspect ratio is still correct
-            assert self.obj.aspectRatio == case['aspect']
-            # Check that image looks as expected
-            self.obj.draw()
-            filename = f"test_image_aspect_{case['tag']}.png"
-            # self.win.getMovieFrame(buffer='back').save(Path(utils.TESTS_DATA_PATH) / filename)
-            utils.compareScreenshot(Path(utils.TESTS_DATA_PATH) / filename, self.win, crit=7)
-            self.win.flip()
-=======
-
-class TestImageAnimation:
-    """
-    Tests for using ImageStim to create frame animations
-    """
-    @classmethod
-    def setup_class(cls):
-        nFrames = 16
-        # Define array of sizes/desired frame rates
-        cls.cases = [
-            {'size': 6 ** 2, 'fps': 16},
-            {'size': 8 ** 2, 'fps': 16},
-            {'size': 10 ** 2, 'fps': 8},
-            {'size': 12 ** 2, 'fps': 2},
-        ]
-        # Create frames
-        for i, case in enumerate(cls.cases):
-            size = case['size']
-            # Create window and shapes
-            win = visual.Window(size=(size, size), color='purple')
-            shape1 = visual.ShapeStim(win,
-                                      pos=(0.2, 0.2), size=(0.5, 0.5),
-                                      lineWidth=size * 0.1,
-                                      fillColor='red', lineColor='green',
-                                      )
-            shape2 = visual.ShapeStim(win,
-                                      pos=(-0.2, -0.2), size=(0.5, 0.5),
-                                      lineWidth=size * 0.1,
-                                      fillColor='blue', lineColor='yellow'
-                                      )
-
-            frames = []
-
-            for thisFrame in range(nFrames):
-                # Cycle window hue
-                win.color = colors.Color(
-                    (win._color.hsv[0] + 360 * thisFrame / nFrames, win._color.hsv[1], win._color.hsv[2]),
-                    'hsv'
-                )
-                # Cycle shape hues
-                shape1._fillColor.hsv = (
-                    shape1._fillColor.hsv[0] + 360 * thisFrame / nFrames, shape1._fillColor.hsv[1],
-                    shape1._fillColor.hsv[2]
-                )
-                shape1._borderColor.hsv = (
-                    shape1._borderColor.hsv[0] - 360 * thisFrame / nFrames, shape1._borderColor.hsv[1],
-                    shape1._borderColor.hsv[2]
-                )
-                shape2._fillColor.hsv = (
-                    shape2._fillColor.hsv[0] + 360 * thisFrame / nFrames, shape2._fillColor.hsv[1],
-                    shape2._fillColor.hsv[2]
-                )
-                shape2._borderColor.hsv = (
-                    shape2._borderColor.hsv[0] - 360 * thisFrame / nFrames, shape2._borderColor.hsv[1],
-                    shape2._borderColor.hsv[2]
-                )
-                # Rotate shapes
-                shape1.ori = shape1.ori + 360 * thisFrame / nFrames
-                shape2.ori = shape2.ori - 360 * thisFrame / nFrames
-                # Render
-                win.flip()
-                shape1.draw()
-                shape2.draw()
-                # Get frame
-                frame = win.getMovieFrame(buffer='back')
-                frames.append(
-                    frame
-                )
-
-            # Cleanup
-            win.close()
-            del shape1
-            del shape2
-            # Update case
-            cls.cases[i]['frames'] = frames
-
-    def test_fps(self):
-        """
-        Check that images can be updated sufficiently fast to create frame animations
-        """
-        # Create clock
-        clock = core.Clock()
-        # Try at each size
-        for case in self.cases:
-            size = case['size']
-            # Make window and image
-            win = visual.Window(size=(size, size))
-            img = visual.ImageStim(win, units='pix', size=(size, size))
-            # Iterate through frames
-            refr = []
-            for frame in case['frames']:
-                # Reset clock
-                clock.reset()
-                # Set image contents
-                img.image = frame
-                # Update
-                img.draw()
-                win.flip()
-                # Store time taken
-                refr.append(clock.getTime())
-            # Print frame rate for this size
-            fps = round(1 / max(refr))
-            assert fps > case['fps'], (
-                f"Max frame rate for {size}x{size} animations should be at least {case['fps']}, but was {fps}"
-            )
-            # Cleanup
-            win.close()
-            del img
->>>>>>> 14bdb82f9dac0abd734f48d14e74d67e0eb3cc50