Pencils Down!! Just done with the last commit. Thanks Bart for all the help. Working under you was fun, especially the independence in directing the project. Thanks Joe Rayhawk for the IT assistance. This sure was fun, I never thought I could do sponsored research so early :). I would also like to acknowledge Swadhin Pradhan, an MS student and Prof. Niloy Ganguly, my mentor at IIT Kharagpur, for their guidance and with whom I'll be continuing this project and probably to greater heights.

Updated the server and phone code to do run incrementally. Push notification daemon running as a crontab job on the server... Will start testing from tomorrow.

Implemented code to update the landmarks based on the location update from the user. Now writing a PHP daemon which basically checks the database for any new notifications that can be sent out to an active user using Google Cloud Messaging.

Included code on the server and phone to send and receive push notifications using Google Cloud Messaging. Now, have to write code which sends these notifications automatically if some update occurs with respect to landmarks.

Updated the Matlab code to do localization in increments. Now moving on to send push notifications containing information regarding the nearest landmark- it's comments. Using the Google Cloud Messaging Service to do this.

Updated the phone app to log the sensor data every few minutes to the server. Now, moving on to the Matlab code to process these increments of data.

Updated the phone application to maintain a session with a server. Login data is stored on SQLite server on the phone. Had to change the database from postgres to mysql on the Server as the PHP readily available from apt-get does not support postgres connect functions. Now, moving on to implement incremental localization on the server. This can be done by storing the intermediate results in a matlab object and retrieving that as and when updates in location are received from the phone.

Updated the repo to include the Java Visualization application [This runs on the server and helps the mall owner to look into the data generated by each of the traces. Improvements to this will be done later]. Now, making the phone app session based, in order to implement incremental localization.

Update: Built a primitive Java application to help visualize the traces on the server, generate heat map and annotate the map with comments... Will update it with more interactive elements later, currently only images of the heat map and numbered comments are plotted on a graph. Now...moving on to implement the more important  incremental localization. This will enable us to update the location periodically, which inturn help us push data to the phone.

Sorry for the lack of updates this last week... Caught a viral infection while relocating and couldn't work much for this past week.

Localization update: Apply pedometer algorithm based on the activity recognized. There is visible change in location traced. For example when the mobile user stands and turns, the minor peaks created in the acceleration dimension was resulting a large change in coordinates. These false steps have now been identified due to its low variance in acceleration.

Now started working on a Java desktop application with Matlab component as its backend to visualize the data and analytics generated.

Updated the code to rotate the location trace, thereby changing the orientation as and when landmarks are encountered. This way the coordinates of the the mall map will converge.

Implemented testing of dummy landmarks, now moving on to changing orientation along with position at landmarks.

Timeline of the work in the next 4 weeks:
1. Today - 4th August
     Improve Location accuracy: This involves

• Correcting orientation of the location trace when landmarks are encountered [ currently just the vector difference is added to the future values to correct the location].
• Test with dummy landmarks entered into the database. These dummy landmarks are encountered when the "Tick" button is pressed along the trace.
• Minimize error while turning or stationary. The pedometer algorithm seems to introduce a large error when the person is not walking. This will be done by detecting if the person is walking or not and accordingly decide to apply the algorithm or not.

2. 5th August - 11th August

    Build a desktop application to visualize the analytics got so far, for the mall owner

• This involves going through all the images generated on the server by the landmarks generated.
• Heat map of the mall according to the landmarks generated
• Going through the comments / ratings left by the users at the various landmarks

3. 12th August - 18th August

  Implement Incremental Localization:

• Currently the phone app does not maintain a session with the server
• Instead of updating the information at the end of logging, it periodically logs the data with the server.
• The server stores the result of each log and carries on as and when it receives the information

4. 19th August - 25th August

Push data to the phone

• When the phone logs the data periodically, it receives a response regarding the comments/ ratings of the landmarks nearby.
• A brief description of the offers/ discounts near the landmarks is also downloaded

Fixed app crashes by changing decreasing the sensor polling rate from FASTEST to that suitable for UI and other UI modifications. Also, started testing in my apartment with a couple of seed landmarks. The option to tick is added to derive the error in the approximate location. The whole mechanism is now automated. Will perform multiple tests tomorrow and come up with the accuracy of the system.

Updated the code (server and phone) to get the seed landmarks and correct the location according to it. Next step would be to test this with a proof of concept map of a shopping mall. Will simulate that in my apartment and will get back to you with the results tomorrow.

Done with the server side of detecting the seed landmarks. An approach similar to the one mentioned in the Unloc paper implemented in getSeedLandmarks.m... Now working on the phone app to allow the users to annotate with these initial landmarks and their location. This strictly speaking has to be done by one user initially [ like the owner of the mall]. But subsequent users will be given this option also. Inducting these user annotated landmarks as actual landmarks will be up to the owner to decide. 

Started working on gathering the initial seed landmarks in a mall. Adding the option of recording the sensor signature of the landmark, and then manually annotating its location thereafter to the phone app. This way, the user has a bunch of landmarks to start with, thereby increasing location accuracy. Also, to check if we are close to a seed landmark, a signature comparison module has to be built. This is different from the ones for Organic landmarks where inter-cluster distance is the metric to determine if we are close to one of those landmarks.

Thresholds for landmark identification is now updated such that only clusters which are better than the 80th percentile values are accepted as stable landmarks.

The whole process of finding landmarks, stabilizing them and annotating the comments with the nearest landmark is now automated.

A couple of issues need to be addressed to ensure correctness of landmark detection. I found them interesting after observations from preliminary testing:
1. The thresholds which determine whether a cluster is a landmark [intra-cluster area closeness + sensor feature closeness], a landmark is a stable one [inter-cluster closeness] have to be learnt over time. Initially they were hard-coded to some value suitable for the conditions under which they were tested.

Solution: To learn them from the clusters got. For example an 80 percentile value of cluster-nearness taken as threshold.

2. Seed Landmark detection module, which the paper argued to be non-essential over a period of time; does in fact affect the initial accuracy of the system. We need to identify these (initial seed) sensor signatures like going up a lift, etc.

Solution: To use a tree like structure to identify the signatures of each place (like in page 6 of the paper).

Implementing the first solution now, should be done with the second one also by Wednesday. Also, I'll be starting testing with my new phone Google Nexus 4 from today. [ This should give us an idea of what these latest smartphones are capable of, with respect to collecting sensor data].

Changed the primitive stabilization algorithm. Initially was combining closely located landmarks irrespective of their feature values. Now there is a threshold to check for their closeness in feature space as well. Also made changes to populate the landmark database accordingly. 

Also, I have to make a design choice regarding storing the landmark data. Performance wise, is it better to have a database or maintain a Matlab object storing a stable set of landmarks? Currently I have both implemented, but will phase out one of them.

Done with integrating the stabilization of landmarks code. So the feedback loop to increase accuracy of landmarks is complete. Have to tweak the thresholds for combination of clusters after performing experiments. So the basic code is up and running...(Also committed the latest Matlab code to the git repository). 

Done updating the code to populate the landmark and comments database. Now started with integrating the 'stabilization of landmarks' code to fully automate the Kalman filter approach.

Installed Matlab, jdbc driver and made connection to the postgresql server. The tables are available in the database 'sample'. Now making changes in the code to insert landmarks, comments and user info in the database. This will automate the process of storing landmarks and seeing if they're converging to stable ones.

Written the basic code for annotation of comments with the nearest landmark after querying the database. Using a JDBC driver to connect to Postgresql on Matlab. Code currently running on local system. Will upload it to the server tomorrow after setting up Matlab on it.

Tested the Matlab code on my local machine with the same data. It is way faster (50x) than Octave. So, moving on to Matlab. Until I set it up on the server (waiting for the ISO); I'll be looking into storing the clusters created, in a MySQL database. I've created the tables for Landmarks, Comments, Users and Metadata. I'm connecting to the database using a JDBC driver.

Today, I'll start writing the code for annotating a particular comment/rating with its nearest landmark.

Sorry for the delay between my posts. I was stuck in getting the octave modules to run on the server.  A couple of bugs held me back for the past 1-2 weeks.

1. Found some bugs in the kmeans module of octave. The processing of the optional parameters was not working if one of those parameters was missing. Also, the parameter 'start' now takes user defined initial seeding for the clustering. Wrong usage of 'lower' and 'tolower' functions in the file. Note that Octave is running slowly on the system, so debugging it is also becoming tedious (~5m per simulation). Other options like Matlab will also have to be looked into, to compare performance in real-time.

2. The issue of permissions/paths to generate the required files in the /var/www/data directory and process them using octave programatically.

3. The app was earlier tested on an older version of android. I ran it on Galaxy S2 this week and found that network operations like multipart-upload cannot be done on the main thread. So moved that part of the code to AsyncTask. Now the app is running smoothly with less crashes.

Now, the server code is running without any error, but is taking a long time to finish clustering (~10-15 min per data folder). 
Internet was down yesterday in my place. So, could not work on the server part. Updated the phone app to take comments and ratings as input. These will be sent to the server along with the other sensors' data when the user has opted to stop logging the information.

Finished with setting up Octave and other things required on the PSU Virtual Machine. Also setup postGIS, which is a geographical extension of PostGreSQL. On the android client side, now the app is posting all the sensors' data to the apache server running on the VM. Now, I'm ready to run the octave scripts on the data and store the landmarks in a geo-database. [Schema is not yet decided]. Also, started working on the UI of the android app to take comments and reviews from the user.

Matlab code has been ported to Octave. Initial results are coming up, but extensive testing on large data sets have to be done. Existing server and android code have also uploaded. I also changed the github repository to https://github.com/ananthbalashankar/landmarkerGSoC which has all the 3 code modules. I decided to run adhoc octave [like a process] on the PHP server. This will be done once the VM is setup for the server. (Octave is currently running slowly on my system.)

Started porting the Landmark detection code from Matlab to Octave! Getting to know the support that community driven development can give. This week's aim would be to get the PHP server running and validating the results got so far with some basic experiments on the phone.

The official coding phase of GSoC has begun! I am excited to start the first phase of work. This blog will contain daily updates of the work done on that day, along with some observations and results got so far. I will be developing an application which helps in building the database for real-time Mall analytics for the large number of mall-goers with smartphones. This in-turn will help to get real-time updates and reviews about the activities of the mall. You can see the code developed so far at this git repository.