def __init__(self,ID,color='r'):

self.ID=ID

self.date=[]

self.lon=[]

self.lat=[]

self.color=color

self.Windows=[]

def readData(self,header,data,fixLon=True):

"""Reads data from array.

Reads in data and subsequently standardizes data and finally computes movement stats.

Args:

header (list): Header list.

data (nunmpy.ndarray): Array with GPS data.

Keyword Args:

fixLon (bool): Fixes sign error in longitude of GPS data.

"""

idx=np.where(data[:,header.index("id")].astype(int)==self.ID)[0]

self.date=data[:,header.index("date")][idx] # Still need to convert this to datetime

self.lat=data[:,header.index("lat")].astype(float)[idx]

self.lon=data[:,header.index("lon")].astype(float)[idx]

if fixLon and max(self.lon)>180:

self.lon=self.lon-360.

self.standardizeData()

self.computeMoveStats()

#self.findRestPeriods(meth='kMeans')

#self.findRestPeriods(meth='thresh')

def standardizeData(self):

"""Standardizes data by converting data to cartesian coordinates, distances between coordinates and timestamps to datetime objects.

"""

self.toCartesian()

self.computeDistances()

self.toDateTime()

def computeMoveStats(self):

"""Computes basic stats of GPS data.

Including:

* Duration of timesteps.

* Velocities.

* Movement angles.

"""

self.computeDeltaT()

self.computeVelocity()

self.computeAngle()

def findPartitions(self,n):

"""Partitions GPS data into n+1 subsets.

Args:

n (int): Number of subsets.

Returns:

tuple: Tuple containing:

* list: List of subsets (windows).

* lust: Indices that define windows.

"""

# Create random numbers

N=len(self.dt)

I=bam.getIncreasingRandInt(n,N)

# Close intervals

I=np.array(list(I)+[N])

# Array of windows

windows=[]

Idxs=[]

# Create indices interval

k=0

for i in I:

idxs=np.arange(k,i)

k=i

windows.append(window(idxs,self))

Idxs.append(idxs)

return windows,idxs

def findNPartitions(self,n,N):

"""Creates N partitions of GPS data into n+1 subsets.

Args:

n (int): Number of subsets.

N (int): Number of partitions.

Returns:

list: List of Windowsets.

"""

Windows=[]

Idxs=[]

for i in range(N):

w,I=self.findPartitions(n)

Windows.append(windowSet(w,I,self))

return Windows

def computeWindowClusters(self,n,N,show=False,add=True,nbouts=3):

"""Bins movement data in time windows and performs clustering by movement stats.

Args:

n (int): Number of windows of the dataset.

N (int): Number of window sets to be created.

Keyword Args:

show (bool): Show cluster plots.

add (bool): Add new window sets.

nbouts (int): Number of clusters/bouts/

Returns:

list: List of window sets.

"""

if add:

self.Windows=self.Windows+self.findNPartitions(n,N)

else:

self.Windows=self.findNPartitions(n,N)

for w in self.Windows:

w.performKMeans(nbouts=nbouts)

if show:

self.showClusters()

return self.Windows

def computeRangedWindowClusters(self,nMin,nMax,N,show=False,add=True,nbouts=3,printStatus=True):

"""Bins movement data in time windows and performs clustering by movement stats for a range of different window sizes.

Args:

nMin (int): Minimal number of windows of the dataset.

nMax (int): Maximal number of windows of the dataset.

N (int): Number of window sets to be created.

Keyword Args:

show (bool): Show cluster plots.

add (bool): Add new window sets.

nbouts (int): Number of clusters/bouts/

Returns:

list: List of window sets.

"""

ns=np.arange(nMin,nMax)

for n in ns:

print "Computing window set with n = ", n ," windows."

self.Windows=self.computeWindowClusters(n,N,show=show,add=add,nbouts=nbouts)

return self.Windows

def findBestWindowSet(self):

"""Returns the optimal partition of all window sets by minimal kmean scores.

Returns:

window.windowSet: Optimal window set.

"""

scores=[]

for w in self.Windows:

scores.append(w.kMeansScore)

return self.Windows[scores.index(min(scores))]

def showClusters(self,axes=None):

# Get number of window sets

N=len(self.Windows)

# Compute number of plots displayed

Nx=int(np.ceil(N/2.))

Ny=int(np.floor(N/2.))

# Show scatter plot for each window set

proj=N*['3d']

fig,axes=pm.makeSubplot([Nx,Ny],proj=proj)

for i,w in enumerate(self.Windows):

w.plotClusters(ax=axes[i],var='dta')

# Show labeled trajectories for each set

fig,axes=pm.makeSubplot([Nx,Ny])

for i,w in enumerate(self.Windows):

w.showClustersOnTracks(ax=axes[i])

def plotLonLatTraj(self,ax=None,onMap=True,lw=2):

"""Plots trajectory in lon/lat of this specific dataset.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes or basemap to plot in.

onMap (bool): Plot on map.

lw (str): Linewidth of plot.

color (str): Color of trajectory.

Returns:

matplotlib.axes: Modified axes.

"""

ax=pm.plotLonLatTraj(self.lon,self.lat,ax=ax,onMap=onMap,color=self.color,lw=lw)

return ax

def plotCartTraj(self,ax=None,vel=[],showVel=True,centered=True,showCenter=True):

"""Plots cartesian trajectory of specific dataset.

.. note:: Creates new figure if axes is not specified.

Args:

x (numpy.ndarray): Array with x-coordinates.

y (numpy.ndarray): Array with y-coordinates.

Keyword Args:

ax (matplotlib.axes): Axes to plot in.

vel (list): List of velocities or other values.

showVel (bool): Show velocities.

centered (bool): Show centered coordinates.

showCenter (bool): Display center.

Returns:

matplotlib.axes: Modified axes.

"""

if centered:

x=np.array(self.xC)

y=np.array(self.yC)

else:

x=np.array(self.x)

y=np.array(self.y)

if showVel and len(vel)==0:

vel=self.v

if centered:

pm.plotCartTraj(x,y,ax=ax,vel=vel,showVel=showVel,centered=centered,showCenter=showCenter,center=[0,0,0],color=self.color)

else:

pm.plotCartTraj(x,y,ax=ax,vel=vel,showVel=showVel,centered=centered,showCenter=showCenter,center=self.center,color=self.color)

return ax

def toCartesian(self,r=6378137,e=8.1819190842622e-2,h=0):

"""Converts the GPS data to cartesian coordinates."""

self.x,self.y,self.z=gps.toCartesian(self.lat,self.lon,r=r,e=e,h=h)

def centerCartesian(self,c):

"""Centers cartesian coordinates around center.

Args:

c (list): Coordinates of center.

"""

self.xC=self.x-c[0]

self.yC=self.y-c[1]

self.flipCoords()

#self.transform2KM(self.xC,self.yC)

self.center=-1*np.array(c)/1000.

def flipCoords(self):

"""Multiplies all coordinates by -1 such that lon/lat plots look the same as cartesian."""

self.xC=-1*self.xC

self.yC=-1*self.yC

def transform2KM(self,x,y):

"""Transforms distances to km.

Args:

x (numpy.ndarray): Cartesian x-coordinates in m.

y (numpy.ndarray): Cartesian y-coordinates in m.

Returns:

tuple: Tuple containing:

* numpy.ndarray: x-coordinates in km.

* numpy.ndarray: y-coordinates in km.

"""

return x/1000.,y/1000.

def computeDistances(self):

"""Computes distances of all steps."""

self.d=gps.computeDistances(self.x,self.y)

def toDateTime(self):

"""Converts dates to datetime objects."""

self.date=list(self.date)

self.date=[datetime.strptime(t, '%Y-%m-%d %H:%M:%S') for t in self.date]

def computeAngle(self):

"""Computes all turning angles."""

angles=[]

# Get directions

for i in range(len(self.x)-2):

# Define movement vectors

vec1=np.array([self.x[i+1]-self.x[i],self.y[i+1]-self.y[i]])

vec2=np.array([self.x[i+2]-self.x[i+1],self.y[i+2]-self.y[i+1]])

# Compute angles

angle = bam.direcAngle(vec1,vec2)

angles.append(angle)

self.angles=angles

return self.angles

def computeDeltaT(self):

"""Computes deltaT between timepoints in seconds."""

self.dt=[]

for i in range(len(self.date)-1):

t=self.date[i+1]-self.date[i]

self.dt.append(t.seconds)

self.t=[self.dt[0]]

for d in self.dt[1:]:

self.t.append(self.t[-1]+d)

self.dt=np.array(self.dt)

self.t=np.array(self.t)

def computeVelocity(self):

"""Computes velocity for each step."""

self.v=self.d/np.array(self.dt)

#def showBouts(self,ax):

#self.findBouts()

#ax.scatter(self.dt,self.d,c=self.bouts.labels_)

#plt.draw()

#def findBouts(self,meth='kMeans',nBouts=3):

#self.bouts=stats_module.performKMeans(self.dt,self.d,nBouts)

#print len(np.where(self.bouts.labels_>1.5)[0])

#print len(np.where(self.bouts.labels_>0.5)[0])

#def findRestPeriods(self,meth='thresh',thresh=3600.):

#if meth=='thresh':

#restIdx=np.where(self.dt>thresh)[0]

#if meth=='PCA':

#stats_module.performPCA(self.dt,self.d,2)

#if meth=='kMeans':

#x=stats_module.performKMeans(self.dt,self.d,2)

#restIdx=np.where(x.labels_>0.1)[0]

#self.restIdx=restIdx

#def showAllPlots(self):

#"""Shows all plots for one individual."""

## Create figure

#fig,axes=pm.makeSubplot([3,5],sup="Individual "+str(self.ID))

## Draw map

#m=pm.drawMap(axes[0])

## Plot trajectories into basemap

#self.plotLonLatTraj(m)

## Plot trajectories in cartesian coordinates

#self.plotCartTraj(axes[1])

## Histogram over distances

#self.plotDHist(axes[2])

## Histogram over velocities

#self.plotVHist(axes[3])

#self.plotDvsV(axes[4])

#self.plotDOverT(axes[5])

#self.plotVOverT(axes[6])

#self.plotPhiOverT(axes[7])

#self.plotPhivsV(axes[8])

#self.plotPhivsD(axes[9])

#self.plotDT(axes[10])

#self.plotDTvsD(axes[11])

#def plotDHist(self,ax,bins=100):

#"""Creates histogram of steplength distribution of individual."""

#ax=self.plotHist(ax,self.d,bins=bins,xlabel="Stepsize (m)",ylabel="Frequency",title="Overall stepsizes")

#plt.draw()

#return ax

#def plotVHist(self,ax,bins=100):

#"""Creates histogram of speed distribution of individual."""

#self.plotHist(ax,self.v,bins=bins,xlabel="Velocity (m/s)",ylabel="Frequency",title="Overall velocities")

#plt.draw()

#return ax

#def plotHist(self,ax,x,bins=100,xlabel="",ylabel="",title=""):

#"""Histogram plotting function."""

#pm.setLabels(ax,xlabel=xlabel,ylabel=ylabel,title=title)

#ax.hist(x,bins=bins)

#return ax

#def makeVSPlot(self,ax,vX,vY,scaleX=1,scaleY=1,xlabel="",ylabel="",title="",color=None):

#"""Creates scatter plot of two variables against each other."""

#if color==None:

#color=self.color

#ax.scatter(np.array(vX)/scaleX,np.array(vY)/scaleY,color=color)

#pm.setLabels(ax,xlabel=xlabel,ylabel=ylabel,title=title)

#return ax

#def makeOverPlot(self,ax,vX,vY,scaleX=1,scaleY=1,xlabel="",ylabel="",title="",color=None):

#"""Creates line plot of two variables against each other."""

#if color==None:

#color=self.color

#ax.plot(np.array(vX)/scaleX,np.array(vY)/scaleY,color=color)

#pm.setLabels(ax,xlabel=xlabel,ylabel=ylabel,title=title)

#return ax

#def plotDvsV(self,ax):

#"""Creates scatter plot showing steplength vs speed of individual."""

#self.makeVSPlot(ax,self.d,self.v,xlabel="Stepsize (m)",ylabel="Velocity (m/s)",title="D vs V")

#def plotDOverT(self,ax):

#"""Creates line plot showing time vs distance of individual."""

#self.makeOverPlot(ax,self.t,self.d,scaleX=3600.,xlabel="Time (h)",ylabel="Stepsize (m)",title="Stepsize over Time")

#def plotVOverT(self,ax):

#"""Creates line plot showing time vs velocity of individual."""

#self.makeOverPlot(ax,self.t,self.v,scaleX=3600.,xlabel="Time (h)",ylabel="Velocity (m/s)",title="Velocity over Time")

#def plotPhiOverT(self,ax):

#"""Creates line plot showing time vs angles of individual."""

#self.makeOverPlot(ax,self.t[1:],self.angles,scaleX=3600.,xlabel="Time (h)",ylabel="Phi (radians)",title="Turning angles over Time")

#def plotDTvsD(self,ax):

#"""Creates scatter plot showing dt vs steplength of individual."""

#self.makeVSPlot(ax,self.dt,self.d,scaleX=3600.,xlabel="Duration (h)",ylabel="Stepsize (m)",title="DT vs D")

#def plotPhivsV(self,ax):

#"""Creates scatter plot showing angles vs velocity of individual."""

#self.makeVSPlot(ax,self.angles,self.v[:-1],xlabel="Turning angle (radians)",ylabel="Velocity (m/s)",title="Phi vs V")

#def plotPhivsD(self,ax):

#"""Creates scatter plot showing angles vs steplengths of individual."""

#self.makeVSPlot(ax,self.angles,self.d[:-1],xlabel="Turning angle (radians)",ylabel="Distance (m)",title="Phi vs D")

#def plotDT(self,ax):

#"""Creates scatter plot showing angles vs steplengths of individual."""

#self.makeOverPlot(ax,np.arange(len(self.dt)),self.dt,scaleX=100.,scaleY=3600.,xlabel="Timepoint (100s)",ylabel="Time inbetween (h)",title="Datapoint vs. DeltaT")

#def cleanUpData(self):

## Create figure

#fig,axes=pm.makeSubplot([2,2],sup="Individual "+str(self.ID),proj=[None,None,None,'3d'])

## Scatter of kmeans

#axes[0].scatter(self.dt[self.restIdx],self.d[self.restIdx],color='r')

#axes[0].scatter(np.delete(self.dt, self.restIdx),np.delete(self.d, self.restIdx),color='b')

##

#vel=np.zeros(np.shape(self.dt))

#vel[self.restIdx]=1

#self.plotCartTraj(axes[1],vel=vel)

#plt.draw()

##self.showBouts(axes[2])

#print len(self.angles)

#print self.dt.shape

##raw_input()

#axes[3].scatter(self.dt,self.d,[0]+list(self.angles))

#plt.draw()

#raw_input()

#def swoopWin(self,lenWin=60.*60.):

#wins=[]

#win=[]

#sumT=0

#for i,t in enumerate(self.dt):

#sumT=sumT+t

#if sumT>lenWin:

#win=[i]

#wins.append(win)

#sumT=t

#else:

#win.append(i)

def __init__(self):

self.data={}

self.IDs=[]

def loadFile(self,fn):

"""Loads GPS data from file and creates a GPSData object for each individual.

Args:

fn (str): Path to gps data text file.

"""

# Load data

self.rawData=np.loadtxt(fn,dtype=str,delimiter=',')

self.header=bam.removeQuotationMarksFromArr(list(self.rawData[0]))

# Sort by individual

self.data=self.getIndividuals()

def getIndividuals(self):

"""Finds individuals in data and assigns data into dict and GPS data."""

# Create dict

newdata={}

# Get list of IDs

self.IDs=np.unique(self.rawData[1:,self.header.index("id")]).astype(int)

# Create list of colors

colors=self.getColors()

for i,ID in enumerate(self.IDs):

g=GPSData(ID,color=colors[i])

g.readData(self.header,self.rawData[1:])

newdata[ID]=g

self.data=newdata

return self.data

def centerCartesian(self,c):

"""Centers all GPS datasets around center.

Args:

c (list): Coordinates of center.

"""

for ID in self.IDs:

self.data[ID].centerCartesian(c)

def getColors(self,cpick='jet'):

"""Creates a list of distinct colors for each individual.

Keyword Args:

cpick (str): Colormap to pick colors from.

Returns:

list: List of colors.

"""

# Get number of individuals

n=len(self.IDs)

return pm.getColors(n,cpick=cpick)

def collectProp(self,prop):

"""Collects defined property from all individuals.

Args:

prop (str): Name of property.

Returns:

list: Collected properties.

"""

p=[]

for ID in self.IDs:

p=p+list(getattr(self.data[ID],prop))

return p

def collectDistances(self):

"""Collects all distances of all individuals.

Returns:

list: Collected distances.

"""

return self.collectProp('d')

def collectVelocities(self):

"""Collects all velocities of all individuals.

Returns:

list: Collected distances.

"""

return self.collectProp('v')

def collectAngles(self):

"""Collects all angles of all individuals.

Returns:

list: Collected angles.

"""

return self.collectProp('angles')

def collectDeltaTs(self):

"""Collects all angles of all individuals.

Returns:

list: Collected angles.

"""

return self.collectProp('dt')

def propHist(self,prop,ax=None,bins=100,xlabel="",ylabel="",title="",xlim=[],ylim=[]):

"""Creates a histogram of a specific property.

.. note:: Creates new figure if axes is not specified.

Args:

p (list): List of values to make hist of.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

xlabel (str): Label of x-axis.

ylabel (str): Label of y-axis.

title (str): Plot title.

xlim (list): Limits of x-axis.

ylim (list): Limits of y-axis.

Returns:

matplotlib.axes: Modified axes.

"""

# Collect property

p=self.collectProp(prop)

# Make hist

ax=pm.plotHist(p,ax=ax,bins=bins,xlabel=xlabel,ylabel=ylabel,title=title,xlim=xlim,ylim=ylim)

return ax

def plotDHist(self,ax=None,bins=100):

"""Creates a histogram of all distances of all individuals.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

matplotlib.axes: Modified axes.

"""

ax=self.propHist('d',ax=ax,bins=bins,xlabel="Stepsize (m)",ylabel="Frequency",title="Overall stepsizes")

return ax

def plotVHist(self,ax=None,bins=100):

"""Creates a histogram of all velocities of all individuals.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

matplotlib.axes: Modified axes.

"""

ax=self.propHist('v',ax=ax,bins=bins,xlabel="Velocity (m/s)",ylabel="Frequency",title="Overall velocities")

return ax

def plotAnglesHist(self,ax=None,bins=100):

"""Creates a histogram of all angles of all individuals.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

matplotlib.axes: Modified axes.

"""

ax=self.propHist('angles',ax=ax,bins=bins,xlabel="Angle (radians)",ylabel="Frequency",title="Overall angles")

return ax

def plotDeltaTHist(self,ax=None,bins=100):

"""Creates a histogram of all delta ts of all individuals.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

matplotlib.axes: Modified axes.

"""

ax=self.propHist('dt',ax=ax,bins=bins,xlabel="dt (s)",ylabel="Frequency",title="Overall dt")

return ax

def showStats(self,axes=[],bins=100):

"""Creates four histograms showing overall movement stats of all dataset.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

list: List of modified axes.

"""

# Create axes if not specified

if len(axes)!=4:

fig,axes=pm.makeSubplot([2,2])

self.plotDHist(ax=axes[0],bins=bins)

self.plotVHist(ax=axes[1],bins=bins)

self.plotAnglesHist(ax=axes[2],bins=bins)

self.plotDeltaTHist(ax=axes[3],bins=bins)

return axes

def plotLonLatTraj(self,ax=None,onMap=True,lw=2):

"""Plots trajectory in lon/lat for all datasets.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes or basemap to plot in.

onMap (bool): Plot on map.

lw (str): Linewidth of plot.

Returns:

matplotlib.axes: Modified axes.

"""

for ID in self.IDs:

ax=self.data[ID].plotLonLatTraj(ax=ax,onMap=onMap,lw=lw)

return ax

def plotCartTraj(self,ax=None,showVel=True,centered=True,showCenter=True):

"""Plots cartesian trajectory for all datasets.

.. note:: Creates new figure if axes is not specified.

Args:

x (numpy.ndarray): Array with x-coordinates.

y (numpy.ndarray): Array with y-coordinates.

Keyword Args:

ax (matplotlib.axes): Axes to plot in.

showVel (bool): Show velocities.

centered (bool): Show centered coordinates.

showCenter (bool): Display center.

Returns:

matplotlib.axes: Modified axes.

"""

for ID in self.IDs:

ax=self.data[ID].plotCartTraj(ax=ax,showVel=showVel,centered=centered,showCenter=showCenter)

return ax

def showData(self,axes=[],lw=2,onMap=True,bins=100,showVel=False,centered=True,showCenter=False):

"""Shows basic stats histograms and movement trajectories of all data sets.

.. note:: Creates new figure if axes is not specified.

Keyword Args:

ax (matplotlib.axes): Axes.

bins (int): Number of bins.

Returns:

list: List of modified axes.

"""

# Create axes if not specified

if len(axes)!=6:

fig,axes=pm.makeSubplot([3,2])

if onMap:

ax=pm.drawMap(axes[0])

self.plotLonLatTraj(ax=ax,onMap=onMap,lw=lw)

self.plotCartTraj(ax=axes[1],showVel=showVel,centered=centered,showCenter=showCenter)

self.showStats(axes=axes[2:])

return axes