Ejemplo n.º 1
0
def replot_out_dots( radius, thetaRads, X, Y, params ):
        
    # Determine who's out of range
    if ( params['displayRegion'] == 'ring' ):
        outField = (radius >= params['outerRadiusUnits'])
        inField = (radius <= 0)
        out = outField + inField
    elif ( params['displayRegion'] == 'rect' ):
        gtMaxX = (X >= params['maxXunits'])
        ltMinX = (X <= params['minXunits'])
        gtMaxY = (Y >= params['maxYunits'])
        ltMinY = (Y >= params['minYunits'])
        outX = ( gtMaxX | ltMinX )
        outY = ( gtMaxY | gtMaxY )
        out = ( outX | outY )
    else:
        print "Invalid displayRegion"
   
    if params['debugMode']:
        print 'Out= ' + str( sum( outField ) ) + '| In= ' + str( sum( inField ) )+ ' | MaxX = ' + str( numpy.max( X ) )  + ' | MinX = ' + str( numpy.min( X ) ) + ' | MinR = ' + str( numpy.min(radius) ) 
        
    # Replot based on replotMode and moveMode
    if params['replotMode'] == 'wrap':
        if params['displayRegion'] == 'ring':
            if (params['moveMode'] == 'radial') or (params['moveMode'] == 'rotation') or (params['moveMode'] == 'random'):
                if out.any:
                    radius = numpy.mod( radius, params['outerRadiusUnits']  )
                X, Y = pol2cart( thetaRads, radius, units='rads' )
            elif (params['moveMode'] == 'laminar'):
                if out.any: # mirror reverse X, Y coordinates
                    X[ out ] = -1.0*X[out]
                    Y[ out ] = -1.0*Y[out]
                thetaRads, radius = cart2pol( X, Y, units='rad' )
    elif params['replotMode'] == 'replot-scaled-polar':
        if outField.any:
                radius[outField], thetaRads[outField], X[outField], Y[outField] = make_dots( sum( outField ), params, min=0., max = params['innerRadiusUnits'], distributionMode = 'scaled-polar' )
        if inField.any:
            radius[inField], thetaRads[inField], X[inField], Y[inField] = make_dots( sum( inField ), params, min=params['outerRadiusUnits'], max=params['outerRadiusUnits']+params['dotSpeedUnits'], distributionMode = 'scaled-polar' )

    elif params['replotMode'] == 'replot-radial':
        if out.any:
            radius[out], thetaRads[out], X[out], Y[out] = make_dots( sum( out ), params, min=0, max=params['outerRadiusUnits'], distributionMode = 'uniform-polar' )

    elif params['replotMode'] == 'replot-rect':
        if out.any:
            radius[out], thetaRads[out], X[out], Y[out] = make_dots( sum( out ), params, min=params['xMinUnits'], max=params['xMaxUnits'], distributionMode='uniform-rect' )

        # Convert changed X,Y to polar
        thetaRads, radius = cart2pol( X, Y, units='rad' )
    # end if replotMode
    
    return radius, thetaRads, X, Y
Ejemplo n.º 2
0
def dots_update(dotsX,
                dotsY,
                frameCount,
                dotSpeed=dotSpeed,
                frameDeathAfter=np.inf):
    # convert to polar coordinates
    dotsTheta, dotsRadius = cart2pol(dotsX, dotsY)
    # update radius
    dotsRadius = (dotsRadius + dotSpeed)
    # decide which dots die
    lgcOutFieldDots = np.zeros(len(dotsTheta), dtype='bool')
    if dotSpeed > 0:
        # create lgc for elems where radius too large
        lgcOutFieldDots = (dotsRadius >= FieldSizeRadius)
    elif dotSpeed < 0:
        # create lgc for elems where radius too small
        lgcOutFieldDots = (dotsRadius <= innerBorder)
    # create logical for where frameCount too high
    lgcFrameDeath = (frameCount >= frameDeathAfter)
    # combine logicals
    lgcDeath = np.logical_or(lgcOutFieldDots, lgcFrameDeath)
    # replace dead dots
    dotsRadius[lgcDeath] = np.random.uniform(innerBorder,
                                             FieldSizeRadius,
                                             size=sum(lgcDeath))
    dotsTheta[lgcDeath] = np.random.rand(sum(lgcDeath)) * 360
    # convert
    dotsX, dotsY = pol2cart(dotsTheta, dotsRadius)
    # increase frameCount for every elements
    frameCount += 1
    # set the counter for newborn dots to zero
    frameCount[lgcDeath] = 0
    return dotsX, dotsY, frameCount
Ejemplo n.º 3
0
def computeChaosPos(dir=0):
    if dir == -1:  # left
        directionRange1 = [-180, -20]
        directionRange2 = [20, 180]
    elif dir == 1:  # right
        directionRange1 = [-160, 0]
        directionRange2 = [0, 160]

    # Initial parameters
    dotsTheta = np.random.rand(nDots) * 360  # deg
    dotsRadius = (np.random.rand(nDots) ** 0.5) * fieldRadius  # in deg
    dotsX, dotsY = pol2cart(dotsTheta, dotsRadius)  # in deg
    XYpos = np.empty((nDots, 2, maxFrames))
    for iFrame in range(maxFrames):
        # choose direction
        dir1 = np.random.rand(int(nDots / 2)) * (directionRange1[1] - directionRange1[0]) + directionRange1[0]
        dir2 = np.random.rand(int(nDots / 2)) * (directionRange2[1] - directionRange2[0]) + directionRange2[0]
        dirAll = np.hstack((dir1, dir2))
        # update position
        dotsX, dotsY = dotsX + speedFrame * np.cos(dirAll), dotsY + speedFrame * np.sin(dirAll)
        # convert catesian to polar
        dotsTheta, dotsRadius = cart2pol(dotsX, dotsY)
        outFieldDots = (dotsRadius > fieldRadius)  # judge dots outside
        if outFieldDots.any():
            dotsRadius[outFieldDots] = np.random.rand(sum(outFieldDots)) * fieldRadius
            dotsTheta[outFieldDots] = np.random.rand(sum(outFieldDots)) * 360  # deg
        dotsX, dotsY = pol2cart(dotsTheta, dotsRadius)
        XYpos[:, 0, iFrame] = dotsX
        XYpos[:, 1, iFrame] = dotsY

    return XYpos
Ejemplo n.º 4
0
def makeCoherentOris(XYs, coherence, formAngle):
    nNew = XYs.shape[0]  # length along the first dimension
    newOris = random(nNew) * 180  # create a random array 0:180
    # select some elements to be coherent
    possibleIndices = range(nNew)  # create an array of indices...
    shuffle(possibleIndices)  # ...shuffle it'in-place' (without creating a new array)...
    coherentIndices = possibleIndices[0 : int(nNew * coherence)]  # ...and take first nnn elements
    # set the ori of the coherent elements
    theta, radius = cart2pol(XYs[:, 0], XYs[:, 1])  # get polar coordinates for elements
    newOris[coherentIndices] = theta[coherentIndices] + formAngle
    return newOris
Ejemplo n.º 5
0
def makeCoherentOris(XYs, coherence, formAngle):
    nNew = XYs.shape[0]#length along the first dimension
    newOris = random(nNew)*180 #create a random array 0:180
    #select some elements to be coherent
    possibleIndices = range(nNew)#create an array of indices...
    shuffle(possibleIndices) #...shuffle it'in-place' (without creating a new array)...
    coherentIndices = possibleIndices[0:int(nNew*coherence)]#...and take first nnn elements
    #set the ori of the coherent elements
    theta, radius = cart2pol(XYs[:,0], XYs[:,1]) #get polar coordinates for elements
    newOris[coherentIndices] = formAngle-theta[coherentIndices]
    return newOris
Ejemplo n.º 6
0
def dots_update_outward(dotsXout, dotsYout):
    # convert to polar coordinates
    dotsTheta, dotsRadius = cart2pol(dotsXout, dotsYout)
    #update radius
    dotsRadius = (dotsRadius + dotSpeed)
    #random radius where radius too large
    outFieldDots = (dotsRadius >= FieldSizeRadius)
    dotsRadius[outFieldDots] = np.random.rand(
        sum(outFieldDots)) * FieldSizeRadius
    # convert
    dotsXout, dotsYout = pol2cart(dotsTheta, dotsRadius)
    return dotsXout, dotsYout
Ejemplo n.º 7
0
def dots_update_inward(dotsXin, dotsYin):
    # convert to polar coordinates
    dotsTheta, dotsRadius = cart2pol(dotsXin, dotsYin)
    # update radius
    dotsRadius = (dotsRadius - dotSpeed)
    # random radius where radius too large
    outFieldDots = (dotsRadius <= 0)
    dotsRadius[outFieldDots] = (np.random.rand(sum(outFieldDots))**
                                0.5) * FieldSizeRadius
    # convert
    dotsXin, dotsYin = pol2cart(dotsTheta, dotsRadius)
    return dotsXin, dotsYin
Ejemplo n.º 8
0
def dots_update_lifetime(dotsX,
                         dotsY,
                         frameCount,
                         dotSpeed=dotSpeed,
                         frameDeathAfter=np.inf):
    # convert to polar coordinates
    dotsTheta, dotsRadius = cart2pol(dotsX, dotsY)
    # update radius
    dotsRadius = (dotsRadius + dotSpeed)
    # update frameCount
    frameCount += 1
    # prepare array for dots that will die from falling out
    lgcOutFieldDots = np.zeros(len(dotsTheta), dtype='bool')

    # decide which dots fall out during expansion
    if dotSpeed > 0:
        # create lgc for elems where radius too large (expansion)
        lgcOutFieldDots = (dotsRadius >= FieldSizeRadius)
    # decide which dots fall out during contraction
    elif dotSpeed < 0:
        # create lgc for elems where radius too small (contraction)
        lgcOutFieldDots = (dotsRadius <= innerBorder)

    # decide which dots will die because they got too old
    lgcFrameDeath = (frameCount >= frameDeathAfter)
    # combine logicals from dots that died due to fell out and high age
    lgcDeath = np.logical_or(lgcOutFieldDots, lgcFrameDeath)

    radiOffset.append(dotsRadius[lgcDeath])

    # calculate new radius for dots that died
    dotsRadius[lgcDeath] = np.sqrt(
        (np.square(FieldSizeRadius) - np.square(innerBorder)) *
        np.random.rand(sum(lgcDeath)) + np.square(innerBorder))

    radiOnset.append(dotsRadius[lgcDeath])

    # calculate new angle for all dots that died (from age or falling)
    dotsTheta[lgcDeath] = np.random.uniform(0, 360, sum(lgcDeath))

    # reset the counter for newborn dots that died of high age
    frameCount[lgcFrameDeath] = 0
    # reset the counter for newborn dots that died from falling out
    frameCount[lgcOutFieldDots] = np.random.uniform(
        0, dotLife, size=sum(lgcOutFieldDots)).astype(int)

    radiDensity.append(dotsRadius)

    # convert from polar to Cartesian
    dotsX, dotsY = pol2cart(dotsTheta, dotsRadius)

    return dotsX, dotsY, frameCount
Ejemplo n.º 9
0
def make_dots( nDots, params, min=-1, max=1, distributionMode='uniform-rect' ):
    if distributionMode == 'scaled-polar':      # Adjusts for density change due to outward radial motion
        r = numpy.random.rand(nDots)**(0.5)*(max - min) + min
        th = numpy.random.rand(nDots)*(2*numpy.pi)-numpy.pi
        X, Y = pol2cart( th, r, units='rad' )
    elif distributionMode == 'uniform-polar':
        r = numpy.random.rand(nDots)*(max - min) + min
        th = numpy.random.rand(nDots)*(2*numpy.pi)-numpy.pi
        X, Y = pol2cart( th, r, units='rad' )
    elif distributionMode == 'fixed-circle':
        th = numpy.random.rand(nDots)*(2*numpy.pi)-numpy.pi
        r = numpy.ones(nDots)*.95
        X, Y = pol2cart( th, r, units='rad' )
    elif distributionMode == 'hybrid-uniform-rect-polar': # dots of uniform density in circular region
        X, Y = numpy.random.rand(nDots)*(max-min)+min, numpy.random.rand(nDots)*(max-min)+min
        th, r = cart2pol( X, Y, units = 'rad' )
        outR = ( r >= params['outerRadiusUnits'] )
        r[ outR ] = numpy.random.rand(sum(outR))*params['outerRadiusUnits']
        X, Y = pol2cart( th, r, units='rad' )
    else : # default is random in [-1,1] and [-1,1] in Cartesian coordinates
        X, Y = numpy.random.rand( nDots )*(max - min) + min, numpy.random.rand( nDots )*(max - min) + min
        th, r = cart2pol( X, Y, units = 'rad' )
        
    return r, th, X, Y
Ejemplo n.º 10
0
def makeCoherentOris(XYs, coherence, formAngle):
    # length along the first dimension:
    nNew = XYs.shape[0]

    # random orientations:
    newOris = random(nNew) * 180

    # select some elements to be coherent
    possibleIndices = list(range(nNew))  # create an array of indices
    shuffle(possibleIndices)  # shuffle it 'in-place' (no new array)
    coherentIndices = possibleIndices[0:int(nNew * coherence)]

    # use polar coordinates; set the ori of the coherent elements
    theta, radius = cart2pol(XYs[:, 0], XYs[:, 1])
    newOris[coherentIndices] = formAngle - theta[coherentIndices]

    return newOris
Ejemplo n.º 11
0
def makeCoherentOris(XYs, coherence, formAngle):
    # length along the first dimension:
    nNew = XYs.shape[0]

    # random orientations:
    newOris = random(nNew) * 180

    # select some elements to be coherent
    possibleIndices = list(range(nNew))  # create an array of indices
    shuffle(possibleIndices)  # shuffle it 'in-place' (no new array)
    coherentIndices = possibleIndices[0: int(nNew * coherence)]

    # use polar coordinates; set the ori of the coherent elements
    theta, radius = cart2pol(XYs[: , 0], XYs[: , 1])
    newOris[coherentIndices] = formAngle - theta[coherentIndices]

    return newOris
Ejemplo n.º 12
0
def move_dots( r, th, X, Y, params ):
    if params['moveMode'] == 'radial':
        # Coherent 
        r[ params['cohIndex'] ] += params['dotSpeedUnits']
        X[ params['cohIndex'] ], Y[ params['cohIndex'] ] = pol2cart(th[ params['cohIndex'] ], r[ params['cohIndex'] ], units='rad')

        # Incoherent
        if params['nDots'] > params['nCoherent']:
            inCohIndex = numpy.invert( params['cohIndex'] )
            dTheta = numpy.random.rand(params['nDots']-params['nCoherent'])*numpy.pi*2.0
            X[ inCohIndex ] += params['dotSpeedUnits']*numpy.cos( dTheta )
            Y[ inCohIndex ] += params['dotSpeedUnits']*numpy.sin( dTheta )
            th[ inCohIndex ], r[ inCohIndex ] = cart2pol( X[ inCohIndex ], Y[ inCohIndex ], units ='rad' )
        # Normalize Cartesian and Polar coordinates
        # X, Y = pol2cart(th, r, units='rad')
    elif params['moveMode'] == 'rotation-eq-angle':
        # Coherent
        th[ params['cohIndex'] ] += params['dotSpeedUnits']
        X[ params['cohIndex'] ], Y[ params['cohIndex'] ] = pol2cart(th[ params['cohIndex'] ], r[ params['cohIndex'] ], units='rad')
        
        # Incoherent
        if params['nDots'] > params['nCoherent']:
            inCohIndex = numpy.invert( params['cohIndex'] )
            dTheta = numpy.random.rand(params['nDots']-params['nCoherent'])*numpy.pi*2.0
            X[ inCohIndex ] += params['dotSpeedUnits']*numpy.cos( dTheta )
            Y[ inCohIndex ] += params['dotSpeedUnits']*numpy.sin( dTheta )
            th[ inCohIndex ], r[ inCohIndex ] = cart2pol( X[ inCohIndex ], Y[ inCohIndex ], units ='rad' )
            
    elif params['moveMode'] == 'rotation-eq-spd':
        # Coherent
        X[ params['cohIndex'] ] += params['dotSpeedUnits']*numpy.sin( numpy.pi - th[ params['cohIndex'] ] )
        Y[ params['cohIndex'] ] += params['dotSpeedUnits']*numpy.cos( numpy.pi - th[ params['cohIndex'] ] )
        th[ params['cohIndex'] ], r[ params['cohIndex'] ] = cart2pol( X[ params['cohIndex'] ], Y[ params['cohIndex'] ], units ='rad' )
        
        # Incoherent
        if params['nDots'] > params['nCoherent']:
            inCohIndex = numpy.invert( params['cohIndex'] )
            dTheta = numpy.random.rand(params['nDots']-params['nCoherent'])*numpy.pi*2.0
            X[ inCohIndex ] += params['dotSpeedUnits']*numpy.cos( dTheta )
            Y[ inCohIndex ] += params['dotSpeedUnits']*numpy.sin( dTheta )
            th[ inCohIndex ], r[ inCohIndex ] = cart2pol( X[ inCohIndex ], Y[ inCohIndex ], units ='rad' )

    elif params['moveMode'] == 'laminar':
        # Coherent
        X[ params['cohIndex'] ] += params['dotSpeedUnits']*numpy.cos( params['laminarDirRads'] )
        Y[ params['cohIndex'] ] += params['dotSpeedUnits']*numpy.sin( params['laminarDirRads'] )
        th[ params['cohIndex'] ], r[ params['cohIndex'] ] = cart2pol( X[ params['cohIndex'] ], Y[ params['cohIndex'] ], units ='rad' )
        
        # Incoherent
        if params['nDots'] > params['nCoherent']:
            inCohIndex = numpy.invert( params['cohIndex'] )
            dTheta = numpy.random.rand(params['nDots']-params['nCoherent'])*numpy.pi*2.0
            X[ inCohIndex ] += params['dotSpeedUnits']*numpy.cos( dTheta )
            Y[ inCohIndex ] += params['dotSpeedUnits']*numpy.sin( dTheta )
            th[ inCohIndex ], r[ inCohIndex ] = cart2pol( X[ inCohIndex ], Y[ inCohIndex ], units ='rad' )
       
    elif params['moveMode'] == 'random':
        dTheta = numpy.random.rand(params['nDots'])*numpy.pi*2.0
        X += params['dotSpeedUnits']*numpy.cos( dTheta )
        Y += params['dotSpeedUnits']*numpy.sin( dTheta )
        th, r = cart2pol( X, Y, units ='rad' )
    # end if moveMode
    
    return r, th, X, Y
Ejemplo n.º 13
0
def dots_update_wrap(dotsX, dotsY, dotSpeed=dotSpeed):
    # convert to polar coordinates
    dotsTheta, dotsRadius = cart2pol(dotsX, dotsY)
    # update radius
    dotsRadius = (dotsRadius + dotSpeed)
    # prepare array for dots that will die from falling out
    lgcOutFieldDots = np.zeros(len(dotsTheta), dtype='bool')

    # decide which dots fall out during expansion
    if dotSpeed > 0:
        # create lgc for elems where radius too large (expansion)
        lgcOutFieldDots = (dotsRadius >= FieldSizeRadius)
        # how many dots should go in area A?
        numDotsAreaA = np.sum(
            np.random.choice(np.arange(2),
                             p=[1 - pAexp, pAexp],
                             size=np.sum(lgcOutFieldDots)))
        # get logical for area A
        lgcAdots = np.zeros(len(dotsTheta), dtype='bool')
        lgcAdots[np.where(lgcOutFieldDots)[0][:numDotsAreaA]] = True
        # calculate new radius for dots appearing in region A
        dotsRadius[lgcAdots] = innerBorder * np.sqrt(
            (np.square(alphaExp) - 1) * np.random.rand(sum(lgcAdots)) + 1)
        # get logical for area B
        lgcBdots = np.zeros(len(dotsTheta), dtype='bool')
        lgcBdots[np.where(lgcOutFieldDots)[0][numDotsAreaA:]] = True
        # calculate new radius for dots appearing in region B
        dotsRadius[lgcBdots] = np.sqrt(
            (np.square(FieldSizeRadius) - np.square(alphaExp) *
             np.square(innerBorder)) * np.random.rand(sum(lgcBdots)) +
            np.square(alphaExp) * np.square(innerBorder))

    # decide which dots fall out during contraction
    elif dotSpeed < 0:
        # create lgc for elems where radius too small (contraction)
        lgcOutFieldDots = (dotsRadius <= innerBorder)
        # how many dots should go in area A?
        numDotsAreaA = np.sum(
            np.random.choice(np.arange(2),
                             p=[1 - pAcontr, pAcontr],
                             size=np.sum(lgcOutFieldDots)))
        # get logical for area A
        lgcAdots = np.zeros(len(dotsTheta), dtype='bool')
        lgcAdots[np.where(lgcOutFieldDots)[0][:numDotsAreaA]] = True
        # calculate new radius for dots appearing in region A
        dotsRadius[lgcAdots] = Scontr * np.sqrt(
            (np.square(alphaContr) - 1) * np.random.rand(sum(lgcAdots)) + 1)
        # get logical for area B
        lgcBdots = np.zeros(len(dotsTheta), dtype='bool')
        lgcBdots[np.where(lgcOutFieldDots)[0][numDotsAreaA:]] = True
        # calculate new radius for dots appearing in region B
        dotsRadius[lgcBdots] = np.sqrt(
            (np.square(Scontr) - np.square(innerBorder)) *
            np.random.rand(sum(lgcBdots)) + np.square(innerBorder))

    # calculate new angle for all dots that died (from age or falling)
    dotsTheta[lgcOutFieldDots] = np.random.uniform(0, 360,
                                                   sum(lgcOutFieldDots))
    # convert from polar to Cartesian
    dotsX, dotsY = pol2cart(dotsTheta, dotsRadius)

    return dotsX, dotsY