Visual Attention Testing

    If I write 2, then 4, then 6, then we will feel good, because we know that next is 8. We can predict this, we are not in the hands of fate. However, unfortunately, this has nothing to do with the truth ...
    x / f Oxford Kills


    Task: to find the central figure among the gray figures around.

    This project - PsyMatchArea - was conceived as an alternative to the famous Schulte tables . With the same goals (training of visual peripheral attention), but with other, more “frostbitten” initial premises. First, it was necessary to get away from numbers and letters - symbols that are familiar to everyone almost from a manger and therefore are recognizable on the machine without the active involvement of consciousness in the process. Secondly, so that attention is replaced with memory as little as possible (and does not relax at all), it was necessary to ensure the corresponding “interference” - a change of position, flicker, overlap, etc.

    Multiple Interference Mode


    Probably the most interesting from the point of view of programming was to create an algorithm that would produce a fairly diverse set of abstract symbols of one type or another. For example, symbols of the “rune” type are grown as follows: the input algorithm is proposed to generate five consecutive connections with some topological “constraints” in the 3 x 3 nodal matrix (restriction on the number of intersections and increased likelihood of engagement on all sides of the matrix perimeter). If, within a certain number of attempts, the algorithm comes to a standstill, it exhibits "tolerance" and skips the last deadlock option (as they say, it has grown, it has grown).

    Rune Generator Code
    void CRunePattern::genSolidLink(int linkCount, int crossesCount)
    {
        if (this->isEmpty())
            return;
        int broadCharge = 5;
        while (broadCharge) {
            m_links.clear();
            QVector  dots;
            int currDot = qrand()%(m_cols*m_rows);
            for (int i = 0; i < linkCount; ++i)
            {
                dots.append(currDot);
                int crossCharge = 5;
                while (crossCharge) {
                    int nextDotCharge = 5;
                    int nextDot = qrand()%(m_cols*m_rows);
                    while (nextDotCharge && dots.contains(nextDot)) {
                        nextDot = qrand()%(m_cols*m_rows);
                        nextDotCharge --;
                    }
                    if (nextDotCharge) {
                        CDotLink newLink = CDotLink(currDot, nextDot);
                        if (this->hasCrossLink(newLink)) {
                            if (crossesCount) {
                                crossesCount --;
                            } else {
                                // find another link that is'nt crosses with others
                                crossCharge --;
                                continue; 
                            }
                        }
                        m_links.append(newLink);
                        currDot = nextDot;
                    }
                    break;
                }
            }
            int maxRow = -1;
            int minRow = m_rows;
            int maxCol = -1;
            int minCol = m_rows;
            for (int d = 0; d < dots.count(); ++d) {
                if (rowByDot(dots.at(d)) < minRow)
                    minRow = rowByDot(dots.at(d));
                if (rowByDot(dots.at(d)) > maxRow)
                    maxRow = rowByDot(dots.at(d));
                if (colByDot(dots.at(d)) < minCol)
                    minCol = colByDot(dots.at(d));
                if (colByDot(dots.at(d)) > maxCol)
                    maxCol = colByDot(dots.at(d));
            }
            if (minCol == 0 && minRow == 0 && 
                maxRow == m_rows - 1 && maxCol == m_cols - 1)
                break;
            broadCharge --;
            continue;
        }
    }
    

    At the moment, the program is capable of generating several types of characters: The


    following interference was also implemented:
    • Swap interference - shuffle shapes
    • Hide center pattern - disappearance of the central figure
    • Thrill interference - rattling figures
    • Color interference - color flicker (garland)
    • Cover interference - concentric circles

    In addition, it is possible to enable tooltips - Tip Settings (the desired shape is "highlighted" after the specified time).

    Settings interface


    After passing through the table, statistics are displayed. Horizontal guessing, vertical time. Green color - the correct answer, red - incorrect, yellow - there was a hint.

    Statistics display


    A couple of methodological notes. You should not look for a figure, scattering your gaze in all directions - it is, firstly, quickly exhausting and, secondly, it will not give anything in terms of the development of background attention. It is advisable to relax and disperse the locus of visual attention throughout the window, keeping the desired figure “in mind”. GitHub

    source code (Qt 4.8)
    Build under Win32

    Also popular now: