recorded meandering in analytics: December 2013

Two weeks ago on the way home from work, an excessively aggressive driver was dodging through traffic behind me. It was night, but like all obnoxious drivers, the headlights were of the luminous, distracting blue-white ilk. Jumping lanes, aggressive acceleration, higher top speed. At the next light, we were lined up with three or so cars in front of both of us, on a two lane road.

On the green, I accelerated gently and kept my pace at the speed of traffic. The blue-white headlight car ,jumped on the bumper of the car ahead, accelerating aggressively and quickly jumping lanes (to no advantage). At the next red light, he was only one car ahead despite his strategy.

Got me thinking. Does an aggressive driving strategy pay off on surface streets?

Using the pygame module (the Python equivalent of Java's processing), I've modeled a surface street as six stoplight objects spread at random distances apart. The function that turns the crank here is screen.get_at, which finds the RGB color scheme at a specified (x,y) location on the grid. Each car object (white rectangles) looks at its current location and ahead of it to find potential obstacles and modifies its speed to avoid crashes.

"Stoplights" are implemented through the redzones, which slow the speed of the car. If the car reaches the end of the redzone, it stops. The green or red lines to the left of the lane indicate the light status.

The cars with the small blue rectangles are the "racing" cars. They start at the same location and speed, but have different initialization values for acceleration and max speed. At the end of the course, the time elapsed from start to finish is recorded.

The results of five simulations:

(slow left lane car, fast right lane car)

[279, 282], [257, 290], [203, 316], [208, 298], [239, 291]

how much faster?

[1% faster, 12% faster, 56% faster, 43% faster, 22% faster]

I still need to include the ability of the car to change lanes. Comparing a stupid driver with a stupid and aggressive driver isn't very interesting.

The end questions I want to answer:

1. How much does varying traffic volume, speed differential between fast and slow cars and the length of red lights affect the course time?

2. Establish a metric that weighs the value of quickly completing the course against moderate acceleration and top speed, and find a strategy for optimizing that metric.

Here is the code. I'll clean it up later.

import pygame
import random
from random import choice

#------------car class------------
class car:
    def __init__(auto,laneChoice,y,speed,accel,speedLimit,raceCar):
        auto.laneNumber=laneChoice
        auto.x=lanes[auto.laneNumber]
        auto.y=y
        auto.speed=speed
        auto.accel=accel
        auto.speedLimit=speedLimit
        auto.raceCar=raceCar
        auto.timeToFinish=0
        auto.oneTime=0
    def draw(auto):
        if (auto.y%height<=laneWidth):
            pygame.draw.rect(screen,(255,255,255,255),(auto.x,auto.y%height,
                            laneWidth*.5,-(auto.y%height)))
            pygame.draw.rect(screen,(255,255,255,255),
                        (lanes[auto.laneNumber-2],((auto.y-laneWidth)%height),
                         laneWidth*.5,(height-(auto.y-laneWidth)%height)))
        if (auto.y%height>laneWidth):
            pygame.draw.rect(screen,(255,255,255,255),(auto.x,auto.y%height,
                             laneWidth*.5,-laneWidth))
        if (auto.raceCar==1):
            pygame.draw.rect(screen,(0,0,255,255),((auto.x+(laneWidth*.5)),auto.y%height,
                            (-10),(-laneWidth*.5)))
#==========================Car Movement===========
    def move(auto):
        heightChecker=0
        if ((auto.y%height)>=500):
            heightChecker=1
            
        checkAhead=1
        posSet=0
##---------This part of the move looks only for WHITE CARS-----------
##Look ahead two lanewidths. Stop while loop if a white pixel is found.
        while (screen.get_at((int(auto.x),int((auto.y+checkAhead)%height)))!=(255,255,255,255)
        and checkAhead<=(laneWidth*2)):
            checkAhead=checkAhead+1
            
##If the next car is within a lanewidth, don't move forward.
        if (checkAhead<=laneWidth):
            auto.y=auto.y
            posSet=1
            
##If the next car is within two lanewidths (but not one), and in a redlight zone, cut
## the speed to 20 percent.
        if (screen.get_at((int(auto.x),int((auto.y+checkAhead-1)%height)))==(255,0,0,255)
        and (screen.get_at((int(auto.x),int((auto.y+checkAhead)%height)))==(255,255,255,255))
        and (posSet==0)):
            if (auto.speed>3):
                auto.speed=auto.speed*.5
            else:
                auto.speed=5
            auto.y=auto.y+auto.speed
            posSet=1
            
#------------/End looking for WHITE CARS.

#If the next pixel is red,
        if (screen.get_at((int(auto.x),int((auto.y+1)%height)))==(255,0,0,255)
        and (posSet==0)):

#run a while loop that determines where the end of the stopzone is.
            checkAhead=1
            while (screen.get_at((int(auto.x),int((auto.y+checkAhead)%height)))!=(0,0,0,255)):
                checkAhead=checkAhead+1
# if the light ends in less than 20 pixels, the car stops.
            if (checkAhead<=10):
                auto.y=auto.y
                posSet=1
            else:
                auto.speed=auto.speed*.9
                auto.y=auto.y+auto.speed
                posSet=1

if (posSet==0):
            if (auto.speed<=auto.speedLimit):
                auto.speed=auto.speed+auto.accel
            else:
                auto.speed=auto.speed
            auto.y=auto.y+auto.speed
            
        if ((auto.y%height)<=100 and heightChecker==1):
            if (auto.laneNumber==10):
                auto.laneNumber=auto.laneNumber=0
            elif (auto.laneNumber==11):
                auto.laneNumber=auto.laneNumber=1
            else:
                auto.laneNumber=auto.laneNumber+2
            auto.x=lanes[auto.laneNumber]
    def raceTimer(auto,index):
        
        auto.timeToFinish=auto.timeToFinish+1
        if ((auto.y>=(height*6) and auto.oneTime==0)):
            auto.oneTime=1
            timerPair[index]=auto.timeToFinish
        
#===============Stoplights=================
class stoplight:
    def __init__(light,x,y,stopFreq):
        light.x=x
        light.y=y
        light.stopFreq=stopFreq
        light.status=choice([0,1])
    def checkStatus(light):
        if (counter%light.stopFreq==0):
            if (light.status==1):
                light.status=0
            elif (light.status==0):
                light.status=1
        elif (counter%light.stopFreq==0 & light.status==0):
            light.status=1
    def draw(light):
        if (light.status==0):
            pygame.draw.rect(screen,(255,0,0),(light.x,light.y-laneWidth*5,laneWidth*2,laneWidth*5))
            pygame.draw.line(screen,(255,0,0),(light.x-4,light.y),(light.x-4,light.y+laneWidth*2),4)
        if (light.status==1):
            pygame.draw.line(screen,(0,255,0),(light.x-4,light.y),(light.x-4,light.y+laneWidth*2),4)
#---------End Stoplight Class--------------

#-----------Lane Class_--------
class lane:
    def __init__(lane,x):
        lane.x=x
    def draw(lane):
        pygame.draw.rect(screen,(0,0,0),(lane.x,0, laneWidth*2,height))     
        pygame.draw.line(screen,(255,255,0,255),(lane.x+(laneWidth),0),
                         (lane.x+(laneWidth),height))
#-----------End Lane Class---------

def drawLanes():
    lane1.draw()
    lane3.draw()
    lane5.draw()
    lane7.draw()
    lane9.draw()
    lane11.draw()
def checkLights():
    lightOne.checkStatus()
    lightTwo.checkStatus()
    lightThree.checkStatus()
    lightFour.checkStatus()
    lightFive.checkStatus()
    lightSix.checkStatus()
def drawLights():
    lightOne.draw()
    lightTwo.draw()
    lightThree.draw()
    lightFour.draw()
    lightFive.draw()
    lightSix.draw()

#------------Initializing--
height=600
width=600
numObstacleCars=20
heightValues=[]
for j in range(0,height-50):
    heightValues.append(j)

pixList=[]
for u in range(int(.3*height),int(.7*height)):
    pixList.append(u)

timerPairs=[]
for v in range(0,5):
    screen=pygame.display.set_mode((width,height))
    clock=pygame.time.Clock()
    laneWidth=int(round(.05*width,0))
    laneOne=int(.05*width)
    laneTwo=int(.1*width)
    laneThree=int(.2*width)
    laneFour=int(.25*width)
    laneFive=int(.35*width)
    laneSix=int(.4*width)
    laneSeven=int(.5*width)
    laneEight=int(.55*width)
    laneNine=int(.65*width)
    laneTen=int(.7*width)
    laneEleven=int(.85*width)
    laneTwelve=int(.9*width)

laneOne_car=int(.05*width+3)
    laneTwo_car=int(.1*width+3)
    laneThree_car=int(.2*width+3)
    laneFour_car=int(.25*width+3)
    laneFive_car=int(.35*width+3)
    laneSix_car=int(.4*width+3)
    laneSeven_car=int(.5*width+3)
    laneEight_car=int(.55*width+3)
    laneNine_car=int(.65*width+3)
    laneTen_car=int(.7*width+3)
    laneEleven_car=int(.85*width+3)
    laneTwelve_car=int(.9*width+3)

lanes=[laneOne_car,laneTwo_car,laneThree_car,laneFour_car,laneFive_car,
           laneSix_car,laneSeven_car,laneEight_car,laneNine_car,laneTen_car,
           laneEleven_car,laneTwelve_car]

lane1=lane(laneOne)
    lane2=lane(laneTwo)
    lane3=lane(laneThree)
    lane4=lane(laneFour)
    lane5=lane(laneFive)
    lane6=lane(laneSix)
    lane7=lane(laneSeven)
    lane8=lane(laneEight)
    lane9=lane(laneNine)
    lane10=lane(laneTen)
    lane11=lane(laneEleven)
    lane12=lane(laneTwelve)
    lightOne=stoplight(laneOne,choice(pixList),20)
    lightTwo=stoplight(laneThree,choice(pixList),20)
    lightThree=stoplight(laneFive,choice(pixList),20)
    lightFour=stoplight(laneSeven,choice(pixList),20)
    lightFive=stoplight(laneNine,choice(pixList),20)
    lightSix=stoplight(laneEleven,choice(pixList),20)
    carOne=car(laneChoice=0,y=50,speed=4,accel=2,speedLimit=20,raceCar=1)
    carTwo=car(laneChoice=1,y=50,speed=4,accel=1,speedLimit=15,raceCar=1)
    yChoices=[]
    xChoices=[]
    for u in range(0,numObstacleCars):
        xChoice=choice([j for j in range(0,len(lanes)-1)])
        yChoice=choice(heightValues)
        if (screen.get_at((lanes[xChoice], yChoice))!=(255,255,255,255)):
            overlap=0
            yChanging=yChoice
            while (overlap==0):
                yChanging=yChanging+1
                if (screen.get_at((xChoice,yChanging))==(255,255,255,255)):
                    overlap=1
                if (screen.get_at((xChoice,yChanging))==(0,0,255,255)):
                    overlap=1
                if (yChanging==yChoice+10):
                    yChoices.append(yChoice)
                    xChoices.append(xChoice)
                    overlap=1

obstructCars=[car(laneChoice=xChoices[j],y=yChoices[j],speed=7,accel=2,speedLimit=15, raceCar=0) for j in range(numObstacleCars)]

counter=0
    speedLimit=20
    timerPair=[0,0]
    running=True
    while running:
        counter=counter+1
        screen.fill((255,255,255))
        drawLanes()
        checkLights()
        drawLights()
        for oneCar in obstructCars:
            oneCar.draw()
        carOne.draw()
        carTwo.draw()
        carOne.move()
        carTwo.move()
        for oneCar in obstructCars:
            oneCar.move()
        carOne.raceTimer(0)
        carTwo.raceTimer(1)
        if (carOne.oneTime==1 and carTwo.oneTime==1):
            running=False
        pygame.display.flip()
        clock.tick(40)

event=pygame.event.poll()
        if event.type==pygame.QUIT:
            running=False
    timerPairs.append(timerPair)
print timerPairs
pygame.quit()

recorded meandering in analytics

Monday, December 9, 2013

The Benefits of Aggressive Driving: First Result

Thursday, December 5, 2013

The Benefits of Aggressive Driving: Simulation Employing Python OOP

Tuesday, December 3, 2013

Postmortem on General Moly Speculation