diff --git a/.travis.yml b/.travis.yml
index 9fe215a..275106d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,6 +1,5 @@
 language: python
 python:
-  - "3.4"
   - "3.5"
 # command to install dependencies
 install: "pip install -r requirements.txt"
@@ -9,10 +8,8 @@ env:
   - DATABASE_URL="postgres://yaddqlhbmweddl:SxBfLvKcO9Vj2b3tcFLYvLcv9m@ec2-54-243-47-46.compute-1.amazonaws.com:5432/d520svb6jevb35" COOKIE_SECRET="password"
 # command to run tests
 script: cd json_api && pytest
-
+# TODO: unless we can get sauce working properly, then remove
 addons:
   sauce_connect:
     username: "brainspell"
     access_key: "56abf217-04be-441a-b624-1f889a4e237f"
-
-
diff --git a/Dockerfile b/Dockerfile
index a8e68d6..1add4aa 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -1,5 +1,6 @@
 FROM python:3
 ADD . /brainspell-neo
+ADD . /database_dumps/brainspell.pgsql
 WORKDIR /brainspell-neo 
 EXPOSE 5000
 ENV PATH /opt/conda/envs/brainspell/bin:$PATH
diff --git a/docker-compose.yml b/docker-compose.yml
index 3201cbf..52de6a1 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -1,8 +1,14 @@
 version: '2'
+
 services:
+  db:
+    image: postgres
   web:
     build: .
-    ports:
-     - "5000:5000"
+    command: python3 json_api/brainspell.py 
     volumes:
-     - .:/brainspell-neo
\ No newline at end of file
+      - .:/brainspell-neo
+    ports:
+      - "5000:5000"
+    depends_on:
+      - db
\ No newline at end of file
diff --git a/ideas.txt b/ideas.txt
index adc5755..09bd3cc 100644
--- a/ideas.txt
+++ b/ideas.txt
@@ -1,27 +1,14 @@
 Consider:
-- add-article-manual endpoint, which allows users to add articles that aren’t on PubMed. (potentially make PMID optional)
-- Make "add article" UI.
-- Maybe an endpoint to get the titles (or all of the information) for a set of PMIDs.
 - A validation for articles before they're sent to the bulk-add endpoint.
 - A cron job to automatically update DOIs.
 
-
-Github Functionality 
-- Check in search and random whether an article is already in a collection 
-- Store Collection names and articles associated in database 
-	- Use that to generate Widgets 
-- Integrate User pages 
-- Store collections in userId in the database 
-- Store the PMID’s in each collection as well. 
-- Integrate the two login systems 
-- Add notes in each Article in the collection 
+GitHub:
+- Potentially add notes in each article in the collection 
 - Paginate the collections page 
-- The bar should be a database request
+- The bar should be a database request (what does this mean?)
 
 Potentially reimplement:
 - Tables: reimplement using jQuery Datatables 
-
 - Brain Browser: a tool for visualization of translucent images that can take advantage of multi-core systems 
-
-- Continuous Activation Graphic:
+- Continuous Activation Graphic
 - Brainsprite: a tool that uses PNG files to show activation with depth 
\ No newline at end of file
diff --git a/json_api/.DS_Store b/json_api/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/json_api/.DS_Store differ
diff --git a/json_api/article_helpers.py b/json_api/article_helpers.py
index e569cbc..140318a 100644
--- a/json_api/article_helpers.py
+++ b/json_api/article_helpers.py
@@ -6,15 +6,28 @@
 import Bio
 from Bio import Entrez, Medline
 from Bio.Entrez import efetch, esearch, parse, read
+from torngithub import json_encode
 
 from models import *
-from search_helpers import get_article_object
 
 Entrez.email = "neel@berkeley.edu"
 
 # BEGIN: article helper functions
 
 
+def get_article_object(query):
+    """ Get a single article PeeWee object. """
+
+    search = Articles.select().where(Articles.pmid == query)
+    return search.execute()
+
+
+def get_all_articles():
+    """ Get all article objects in the database. """
+
+    return Articles.select().execute()
+
+
 def update_authors(pmid, authors):
     """ Update the authors for an article. """
 
@@ -79,10 +92,9 @@ def toggle_vote(pmid, topic, username, direction):
         direction,
         "name")
 
-    query = Articles.update(
+    Articles.update(
         metadata=metadata).where(
-        Articles.pmid == pmid)
-    query.execute()
+        Articles.pmid == pmid).execute()
 
 
 def vote_stereotaxic_space(pmid, space, username):
@@ -107,10 +119,9 @@ def vote_stereotaxic_space(pmid, space, username):
         "type": space
     })
 
-    query = Articles.update(
+    Articles.update(
         metadata=target).where(
-        Articles.pmid == pmid)
-    query.execute()
+        Articles.pmid == pmid).execute()
 
 
 def vote_number_of_subjects(pmid, subjects, username):
@@ -135,26 +146,24 @@ def vote_number_of_subjects(pmid, subjects, username):
         "value": subjects
     })
 
-    query = Articles.update(
+    Articles.update(
         metadata=target).where(
-        Articles.pmid == pmid)
-    query.execute()
+        Articles.pmid == pmid).execute()
 
 
-def add_user_tag(user_tag, id):
+def add_user_tag(user_tag, pmid):
     """ Add a custom user tag to the database. """
 
     main_target = next(
         Articles.select(
             Articles.metadata).where(
-            Articles.pmid == id).execute())
+            Articles.pmid == pmid).execute())
     target = eval(main_target.metadata)
     if target.get("user"):
         target["user"].append(user_tag)
     else:
         target["user"] = [user_tag]
-    query = Articles.update(metadata=target).where(Articles.pmid == id)
-    query.execute()
+    Articles.update(metadata=target).where(Articles.pmid == pmid).execute()
 
 
 def get_number_of_articles():
@@ -170,45 +179,48 @@ def add_pmid_article_to_database(article_id):
     Given a PMID, use external APIs to get the necessary article data
     in order to add the article to our database.
     """
-
-    pmid = str(article_id)
-    handle = efetch("pubmed", id=[pmid], rettype="medline", retmode="text")
-    records = list(Medline.parse(handle))
-    records = records[0]
-    article_info = {}
-    article_info["title"] = records.get("TI")
-    article_info["PMID"] = pmid
-    article_info["authors"] = ', '.join(records.get("AU"))
-    article_info["abstract"] = records.get("AB")
-    article_info["DOI"] = getDOI(records.get("AID"))
-    article_info["experiments"] = ""
-    article["metadata"] = str({"meshHeadings": []})
-    article["reference"] = None
-    identity = ""
-    try:
-        article_info["experiments"] = {
-            "locations": eval(
-                urllib.request.urlopen(
-                    "http://neurosynth.org/api/studies/peaks/" +
-                    str(pmid) +
-                    "/").read().decode())["data"]}
-        k = article_info["experiments"]["locations"]
-        for i in range(len(k)):
-            if len(k[i]) == 4:
-                identity = k[0]
-                k[i] = k[i][1:]
-            k[i] = ",".join([str(x) for x in (k[i])])
-    except BaseException:
-        pass
-    article_info["id"] = identity
-    article_info["experiments"] = [article_info["experiments"]]
-    Articles.create(abstract=article_info["abstract"],
-                    authors=article_info["authors"],
-                    doi=article_info["DOI"],
-                    experiments=article_info["experiments"],
-                    pmid=article_info["PMID"],
-                    title=article_info["title"])
-    return article_info
+    if len(list(get_article_object(article_id))) == 0:
+        pmid = str(article_id)
+        handle = efetch("pubmed", id=[pmid], rettype="medline", retmode="text")
+        records = list(Medline.parse(handle))
+        records = records[0]
+        if "TI" not in records:
+            return False  # catch bad PMIDs
+        article_info = {}
+        article_info["title"] = records["TI"]
+        article_info["PMID"] = pmid
+        article_info["authors"] = ', '.join(records["AU"])
+        article_info["abstract"] = records["AB"]
+        article_info["DOI"] = getDOI(records["AID"])
+        article_info["experiments"] = ""
+        article_info["metadata"] = str({"meshHeadings": []})
+        article_info["reference"] = None
+        identity = ""
+        try:
+            article_info["experiments"] = {
+                "locations": eval(
+                    urllib.request.urlopen(
+                        "http://neurosynth.org/api/studies/peaks/" +
+                        str(pmid) +
+                        "/").read().decode())["data"]}
+            k = article_info["experiments"]["locations"]
+            for i in range(len(k)):
+                if len(k[i]) == 4:
+                    identity = k[0]
+                    k[i] = k[i][1:]
+                k[i] = ",".join([str(x) for x in (k[i])])
+        except BaseException:
+            pass
+        article_info["id"] = identity
+        article_info["experiments"] = [article_info["experiments"]]
+        Articles.insert(abstract=article_info["abstract"],
+                        authors=article_info["authors"],
+                        doi=article_info["DOI"],
+                        experiments=article_info["experiments"],
+                        pmid=article_info["PMID"],
+                        title=article_info["title"]).execute()
+        return True
+    return False
 
 
 def getDOI(lst):
@@ -362,7 +374,7 @@ def add_coordinate_row(pmid, exp, coords, row_number=-1):
     else:
         elem["locations"].insert(row_number, row_list)
     Articles.update(
-        experiments=experiments).where(
+        experiments=json_encode(experiments)).where(
         Articles.pmid == pmid).execute()
 
 
@@ -398,9 +410,7 @@ def add_table_through_text_box(pmid, values):
 def update_table_vote(tag_name, direction, table_num, pmid, column, username):
     """ Update the vote on an experiment tag for a given user. """
 
-    article_obj = Articles.select(
-        Articles.experiments).where(
-        Articles.pmid == pmid).execute()
+    article_obj = get_article_object(pmid)
     article_obj = next(article_obj)
     article_obj = eval(article_obj.experiments)
 
@@ -418,7 +428,6 @@ def update_table_vote(tag_name, direction, table_num, pmid, column, username):
 
     article_obj[table_num] = table_obj
 
-    query = Articles.update(
+    Articles.update(
         experiments=article_obj).where(
-        Articles.pmid == pmid)
-    query.execute()
+        Articles.pmid == pmid).execute()
diff --git a/json_api/base_handler.py b/json_api/base_handler.py
index f80c7cc..9314bf4 100644
--- a/json_api/base_handler.py
+++ b/json_api/base_handler.py
@@ -93,7 +93,8 @@ def process(self, response, args)
     the "asynchronous" boolean, decorating your "process" function with
     @tornado.gen.coroutine, and calling self.finish_async when your
     function finishes execution (MANDATORY). Then, any blocking code
-    should be decorated with @run_on_executor.
+    should be decorated with @run_on_executor. (Make sure that you import
+    run_on_executor with `from tornado.concurrent import run_on_executor`.)
 
     asynchronous :: True | False
 
diff --git a/json_api/github_collections.py b/json_api/github_collections.py
index ad1c743..80da6ea 100644
--- a/json_api/github_collections.py
+++ b/json_api/github_collections.py
@@ -6,6 +6,7 @@
 
 import hashlib
 import os
+import re
 from base64 import b64encode
 
 import tornado
@@ -16,8 +17,8 @@
 from tornado.httputil import url_concat
 from torngithub import json_decode, json_encode
 
+from article_helpers import get_article_object
 from base_handler import *
-from search_helpers import *
 from user_account_helpers import *
 
 # BEGIN: read environment variables
@@ -132,7 +133,7 @@ def get_user_repos(http_client, access_token):
         access_token=access_token) for i in range(2, max_pages + 1)]
 
     for repo in repos_list:
-        data.extend(res.body)
+        data.extend(repo.body)
 
     raise tornado.gen.Return(data)
 
diff --git a/json_api/json_api.py b/json_api/json_api.py
index e6628b5..218631c 100644
--- a/json_api/json_api.py
+++ b/json_api/json_api.py
@@ -1,5 +1,9 @@
 # JSON API classes
 
+import statistics
+
+from tornado.concurrent import run_on_executor
+
 import brainspell
 from article_helpers import *
 from base_handler import *
@@ -22,6 +26,76 @@ def process(self, response, args):
         return response
 
 
+# BEGIN: statistics API endpoints
+
+
+class CollectionSignificanceEndpointHandler(BaseHandler):
+    """
+    Take one or two collections, and calculate the significance of the peaks in the first collection at each (x, y, z) coordinate
+    with respect to the second collection, or with respect to the rest of the database.
+
+    Return a dictionary of coordinates in the collection, mapped to their p-values, with the insignificant results filtered out.
+    """
+
+    parameters = {
+        "collection_name": {
+            "type": str
+        },
+        "other_collection": {
+            "type": str,
+            "default": "null",
+            "description": "Another collection to run this significance test against. If not specified, then the test will be run against the entire database."
+        },
+        "width": {
+            "type": int,
+            "default": 5,
+            "description": "The width for each coordinate that we'll check for significance."
+        },
+        "threshold": {
+            "type": float,
+            "default": .001,
+            "description": "The threshold that we'll use to account for multiple comparisons using Benjamini–Hochberg"
+        }
+    }
+
+    endpoint_type = Endpoint.PUSH_API
+
+    collection_does_not_exist = "According to Brainspell's database, that user doesn't own a collection with the name {0}. Try syncing with GitHub if this isn't accurate. (/json/collections, set force_github_refresh to 1)"
+
+    asynchronous = True
+
+    @run_on_executor
+    def get_significance(self, pmids, other_pmids, width, threshold):
+        return statistics.significance_from_collections(
+            pmids, other_pmids, width, threshold)
+
+    @tornado.gen.coroutine
+    def process(self, response, args):
+        user_collections = get_brainspell_collections_from_api_key(args["key"])
+        # ensure that collection exists
+        if args["collection_name"] in user_collections:
+            pmids = user_collections[args["collection_name"]]["pmids"]
+            other_pmids = None
+            if args["other_collection"] != "null":
+                if args["other_collection"] in user_collections:
+                    other_pmids = user_collections[args["other_collection"]]["pmids"]
+                else:
+                    response["success"] = 0
+                    response["description"] = self.collection_does_not_exist.format(
+                        args["other_collection"])
+                    return response
+            # at this point, we can assume that we have either one set of PMIDs
+            # and None, or two sets of PMIDs
+            response["significance_grid"] = yield self.get_significance(pmids, other_pmids, width=args["width"], threshold=args["threshold"])
+        else:
+            # collection doesn't exist
+            response["success"] = 0
+            response["description"] = self.collection_does_not_exist.format(
+                args["collection_name"])
+
+        self.finish_async(response)
+
+
 # BEGIN: search API endpoints
 
 
@@ -132,10 +206,14 @@ def process(self, response, args):
         return response
 
 
-class AddArticleFromSearchPageEndpointHandler(BaseHandler):
-    """ Add an article to our database via PMID (for use on the search page) """
+class AddArticleEndpointHandler(BaseHandler):
+    """
+    Fetch PubMed and Neurosynth data using a user-specified PMID, and add
+    the article to our database. Do not add repeats.
+    """
+
     parameters = {
-        "new_pmid": {
+        "pmid": {
             "type": str
         }
     }
@@ -143,7 +221,10 @@ class AddArticleFromSearchPageEndpointHandler(BaseHandler):
     endpoint_type = Endpoint.PUSH_API
 
     def process(self, response, args):
-        add_pmid_article_to_database(args["new_pmid"])
+        success = add_pmid_article_to_database(args["pmid"])
+        response["success"] = success
+        if success == 0:
+            response["description"] = "Either that PMID is not valid, or the article already exists in our database."
         return response
 
 
@@ -212,31 +293,6 @@ def process(self, response, args):
         return response
 
 
-class AddArticleEndpointHandler(BaseHandler):
-    """
-    Fetch PubMed and Neurosynth data using a user-specified PMID, and add
-    the article to our database.
-    """
-
-    parameters = {
-        "pmid": {
-            "type": str
-        }
-    }
-
-    endpoint_type = Endpoint.PUSH_API
-
-    def process(self, response, args):
-        article_obj = getArticleData(args["pmid"])
-        request = Articles.insert(abstract=article_obj["abstract"],
-                                  doi=article_obj["DOI"],
-                                  authors=article_obj["authors"],
-                                  experiments=article_obj["coordinates"],
-                                  title=article_obj["title"])
-        request.execute()
-        return response
-
-
 class SetArticleAuthorsEndpointHandler(BaseHandler):
     """ Edit the authors of an article. """
 
diff --git a/json_api/search_helpers.py b/json_api/search_helpers.py
index 84b2dca..bfe0727 100644
--- a/json_api/search_helpers.py
+++ b/json_api/search_helpers.py
@@ -101,13 +101,6 @@ def formatted_search(query, start, param=None, experiments=False):
             *fields).where(match).limit(numberResults).offset(start).execute()
 
 
-def get_article_object(query):
-    """ Get a single article PeeWee object. """
-
-    search = Articles.select().where(Articles.pmid == query)
-    return search.execute()
-
-
 def generate_circle(coordinate):  # Coordinate of form "-26,54,14"
     """ Specify a range around a given coordinate to search the database. """
 
diff --git a/json_api/static/html/account.html b/json_api/static/html/account.html
index 917ac16..856205c 100644
--- a/json_api/static/html/account.html
+++ b/json_api/static/html/account.html
@@ -3,9 +3,13 @@
 {% block header %}
 
     <title>Brainspell v2 - My Github</title>
-
+    <!-- jQuery Version 1.11.1 -->
+    <script src="static/js/jquery.js"></script>
     <!-- Bootstrap Core CSS -->
     <link href="/static/css/bootstrap.min.css" rel="stylesheet">
+    <link rel="stylesheet" href="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.6.2/css/bootstrap-select.min.css" />
+    <script src="//cdnjs.cloudflare.com/ajax/libs/bootstrap-select/1.6.2/js/bootstrap-select.min.js"></script>
+
 
 
 {% end %}
@@ -19,6 +23,7 @@
           <div class="col-lg-12 text-center">
               <h1>Brainspell Collections</h1>
               <p class="lead">Your open, curated classification of neuroimaging literature.</p>
+              <p class="lead"><a onclick="forceRefresh(); this.disable=true;" id="refreshBtn">Sync With Github.</a></p>
               <form data-toggle="validator" role="form" action="javascript:createCollection()" id="new_collection">
               <div class="input-group has-feedback">
                  <input type="text" name="name" id="new-collection-name" style="width:20%"  pattern="^[_A-z0-9]{1,}$" minlength="3" placeholder="Name" class="form-control" required>
@@ -30,36 +35,104 @@ <h1>Brainspell Collections</h1>
               </div>
              </form>
           </div>
-          <div class="col-lg-12" style="padding-top:20px;">
-            <input type="submit" id="refreshBtn" class="btn btn-default" onclick="forceRefresh(); this.disabled = true;" value="Sync with GitHub" />
-          </div>
-      </div>
 
-      <div class="row">
-    <div class="col-lg-12 text-center">
-      <h2>My Collections</h2>
-    </div>
+
+      <div class="row container-fluid">
   </div>
 
-  <div class="row container" id="collections-container">Loading... This might take a while.</div>
-  </div>  <!-- /.container -->
+  <div class="row container" id="collections-container"><p style="padding-top:20px;">Loading... This might take a while.</p></div></div>  <!-- /.container -->
+
+
+      <div class="row container" style="padding-top:20px; padding-bottom:20px;">
+            <div id="no-significance" style="color:red;padding-bottom:20px;display:none;">No significant results.</div>
+            <button class="btn btn-default" id="widgetOption" style="display:none;" onclick="this.style.display = 'none'; $('#widgetsHolder').fadeIn();">Show widgets</button>
+            <div id="widgetsHolder" style="margin-top:15px;">
+              <!-- StereotaxicViewer -->
+              <span style="display:inline-block; float: left;">
+                  <table style="border:1px solid lightGrey;padding:5px">
+                      <tr>
+                      <td>
+                          <canvas id="brainCanvas"  style="width:250px;height:300px;background-color:black"></canvas>
+                      </td>
+                      </tr>
+                      <tr>
+                      <td>
+                          <button class="btn btn-default" onclick="changeView('sagittal')">Sag</button>
+                          <button class="btn btn-default" onclick="changeView('coronal')">Cor</button>
+                          <button class="btn btn-default" onclick="changeView('axial')">Axi</button>
+                          <input type="range" name="slice" oninput="changeSlice(this.value)"style="width:100%;vertical-align:middle"/>
+                      </td>
+                      </tr>
+                  </table>
+              </span>
+              <!-- /StereotaxicViewer -->
+
+              &nbsp;
+
+              <!-- MeshViewer -->
+              <span style="position: absolute; display:inline-block">
+                  <table style="margin: 0; border:1px solid lightGrey;padding:5px">
+                      <tr>
+                      <td>
+                          <div style="width:320px;height:340px" id="meshCanvas"></div>
+                      </td>
+                      </tr>
+                      <tr>
+                      <td>
+                          <input type="range" name="level" oninput="changeLevel(this.value)"style="width:100%;vertical-align:middle"/>
+                      </td>
+                      </tr>
+                  </table>
+              </span>
+              <!-- /MeshViewer -->
+          </div>
+      </div>
 
 
 
-    <!-- jQuery Version 1.11.1 -->
-    <script src="static/js/jquery.js"></script>
 
     <!-- Bootstrap Core JavaScript -->
     <script src="static/js/bootstrap.min.js"></script>
 
     <script src="http://cdn.rawgit.com/1000hz/bootstrap-validator/master/dist/validator.min.js"></script>
 
+
+    <!-- Translucent Viewer -->
+    <script src="/static/js/three.min.js"></script>
+    <script src="/static/js/detector.js"></script>
+    <script src='/static/js/subdivision-modifier.js'></script>
+    <script src="/static/js/PLYLoader.js"></script>
+    <script src="/static/js/trackball-controls.js"></script>
+    <script src="/static/js/search-widgets.js"></script>
+
     <script>
+
+    initSearch(1);
+    document.getElementById("widgetsHolder").style.display = "none"; // hide the widgets initially; need to initially show in DOM for translucent to work
+
+
+
+
+    function htmlEncode(value){
+      return $('<div/>').text(value).html();
+    }
+
     function generateCollectionsContainer(list) {
       console.log(list);
 
       var contents = '<div class="panel-group" id="accordion" role="tablist" aria-multiselectable="true">';
 
+      var collectionSelector = "<select name='collectionSelect' class='form-control'>";
+
+      for (var i = 0; i < list.length; i++) {
+        collectionSelector = collectionSelector + "<option value='" + htmlEncode(list[i]["name"]) + "'>" + htmlEncode(list[i]["name"]) + "</option>";
+      }
+
+      collectionSelector1 = collectionSelector + "</select>"
+      collectionSelector2 = collectionSelector + "<option value='-1'>Rest of database</option></select>";
+
+      contents = "<div style='padding-bottom:20px'></div>";
+
       for (var i = 0; i < list.length; i++) {
         var collectionObj = list[i];
         contents = contents + '<div class="panel panel-default">\
@@ -67,17 +140,12 @@ <h2>My Collections</h2>
               <h4 class="panel-title">\
               <a role="button" data-toggle="collapse" data-parent="#accordion" href="#collapse' + i + '" aria-expanded="' + (i == 0) + '" aria-controls="collapse'+i+'">\
                 '+collectionObj["name"]+'\
-              </a>\
-            </h4>\
-          <div>\
-            '+collectionObj["description"];
+              </a></h4><div>'+collectionObj["description"];
         for (var j = 0; j < list[i]["contributors"].length; j++) {
             var contributorObj = list[i]["contributors"][j];
             contents = contents + '<img class="img-circle pull-right" src="'+contributorObj["avatar_url"]+'" width="25px" height="25px">';
         }
-        contents = contents + '</div>\
-\
-        </div>\
+        contents = contents + '</div></div>\
         <div id="collapse'+i+'" class="panel-collapse collapse';
         if (i == 0) contents = contents + " in ";
          contents = contents + '" role="tabpanel" aria-labelledby="heading'+i+'">\
@@ -88,14 +156,21 @@ <h4 class="panel-title">\
               '+articleObj["reference"]+'\
               <br>';
         }
-        contents = contents + '\
-          </div>\
-        </div>\
-      </div>';
+        contents = contents + '</div></div></div>';
       }
-      
+
       contents = contents + '</div>';
+      contents += "<div id='sig' class='container row'>";
+      contents += "<div id='inner'>";
+      contents += "<h4 style='text-align:center'>Significance</h4>";
+      contents += "<p style='text-align:center'>Is the appearence of peaks in your collection significant? Run a significance test to evaluate.</p>"
+      block1 = "<div id='one' class='col-md-5'>" + "Collection 1: " + collectionSelector1 + "</div>";
+      block2 = "<div id'two' class='col-md-5'>" + "Collection 2: " + collectionSelector2 + "</div>";
+      contents += "</div>";
+      contents += block1 + block2 + "<div id='submitter' class='col-md-2'><br><input type='button' class='btn btn-default' id='significanceBtn' onclick='significance(this)' value='Significance test'></div>";
 
+      contents += "</div>";
+      contents += "<p id='advanced' style='padding-top:10px;'><a onclick='showAdvanced();'>Advanced Parameters</a></p>";
       if (list.length == 0) {
         contents = "You have no collections."
       }
@@ -128,6 +203,53 @@ <h4 class="panel-title">\
           generateCollectionsContainer(JSON.parse(o["responseText"])["collections"]);
         });
     }
+    function showAdvanced() {
+        $("#advanced").hide();
+        $("#one").attr("class","col-md-6");
+        $("#two").attr("class","col-md-6");
+        $("#inner").append($("<div>", {"class":"col-md-6"}).append($("<input>",{"placeholder":"Width","class":"form-control","type":"text","id":"width"})));
+        $("#inner").append($("<div>", {"class":"col-md-5"}).append($("<input>",{"placeholder":"Threshold","class":"form-control","type":"text","id":"threshold"})));
+
+    }
+    function significance(btn) {
+      $(btn).attr("disabled", "disabled");
+      $("#no-significance").css("display", "none");
+      var colNames = document.getElementsByName("collectionSelect");
+      var col1 = colNames[0].value;
+      var col2 = colNames[1].value;
+      var thresh = $("#threshold").val();
+      var w = $("#width").val();
+      if (col2 == "-1") {
+        col2 = "null";
+      }
+      $.ajax({
+          type: "POST",
+          url: "/json/collection-significance",
+          data: {
+              "key": "{{api_key}}",
+              "collection_name": col1,
+              "other_collection": col2,
+              "width": w == "" || w === undefined ? 5 : JSON.parse(w),
+              "threshold": thresh == "" || thresh === undefined ? .001 : parseFloat(thresh)
+          }
+      }).complete(function(o) {
+        var significant_coordinates_dict = JSON.parse(o["responseText"])["significance_grid"];
+        // this is a dict with keys as string tuples "(x, y, z)", values as p-values (e.g., .004)
+        // you only need the keys.
+        console.log(significant_coordinates_dict);
+        // generate brain widget
+        loadLocationsFromDict(significant_coordinates_dict);
+        if (Object.keys(significant_coordinates_dict).length === 0) {
+          // if there are no significant results, indicate this
+          $("#no-significance").css("display", "block");
+        }
+        // TODO: potentially display the p-values
+        $(btn).removeAttr("disabled");
+      });
+
+    }
+
+
 
     function createCollection() {
         $.ajax({
@@ -152,6 +274,7 @@ <h4 class="panel-title">\
             location.reload();
         });
       }
+
     </script>
 
 {% end %}
diff --git a/json_api/static/html/base.html b/json_api/static/html/base.html
index cb4f219..61cb4f9 100644
--- a/json_api/static/html/base.html
+++ b/json_api/static/html/base.html
@@ -26,6 +26,7 @@
     </script>
     <!-- Bootstrap Core CSS -->
     <link href="/static/css/bootstrap.min.css" rel="stylesheet">
+
     <!-- HTML5 Shim and Respond.js IE8 support of HTML5 elements and media queries -->
     <!-- WARNING: Respond.js doesn't work if you view the page via file:// -->
     <!--[if lt IE 9]>
diff --git a/json_api/static/html/search.html b/json_api/static/html/search.html
index b6e820a..9be8db2 100755
--- a/json_api/static/html/search.html
+++ b/json_api/static/html/search.html
@@ -167,14 +167,13 @@ <h1>Brainspell</h1>
             var name = $.trim($('#new_pmid').val());
             var pattern = new RegExp("[0-9]{8}");
             if (pattern.test(name)) {
-                alert("OK!");
                 
                 // TODO: make an add-article UI
                $.ajax({
                 type: "POST",
-                url: "/json/add-article-from-search-page",
+                url: "/json/add-article",
                 data: {
-                    "new_pmid": name,
+                    "pmid": name,
                     "key": "{{api_key}}"
                 }
             }).complete(function() {
@@ -186,6 +185,12 @@ <h1>Brainspell</h1>
             }
         }
 
+        // add replaceAll (used below)
+        String.prototype.replaceAll = function(search, replacement) {
+            var target = this;
+            return target.replace(new RegExp(search, 'g'), replacement);
+        };
+
         function saveCollection() {
             var articles = [];
             $.each($("input[name='collection']:checked"), function(){
@@ -193,18 +198,7 @@ <h1>Brainspell</h1>
                 articles.push($(this).val());
             });
 
-            // TODO: this should not allow spaces
-            collectionName = prompt("Enter the collection name:", "").trim();
-            /*
-            for (var i = 0; i < articles.length; i++) {
-                // TODO: use bulk-add-to-collection
-                $.post("/json/add-to-collection?"+$.param({pmid: articles[i],
-                name:collectionName,
-                github_access_token:"{{github_access_token}}",
-                key:"{{api_key}}"}), function(data, err){
-                    console.log(data);
-            });
-            */
+            collectionName = prompt("Enter the collection name:", "").trim().replaceAll(" ", "-");
             $.post("/json/add-to-collection?"+$.param({pmid: JSON.stringify(articles),
                 bulk_add:1,
                 name:collectionName,
@@ -213,18 +207,6 @@ <h1>Brainspell</h1>
                     console.log(data);
             });
 
-//            //Collection is brainspell-collection-Trial4 and PMID is 19560547
-//            for (var i = 0; i < articles.length; i++) {
-//                $.ajax({
-//                    type: "POST",
-//                    url: "/add-to-collection",
-//                    data: {
-//                        "pmid": "" + articles[i],
-//                        "collection": "brainspell-collection-" + collectionName
-//                    }
-//                })
-//            }
-
         }
 
         // brain widgets
diff --git a/json_api/static/html/view-article.html b/json_api/static/html/view-article.html
index f318103..852a4b7 100755
--- a/json_api/static/html/view-article.html
+++ b/json_api/static/html/view-article.html
@@ -87,7 +87,7 @@ <h1>Brainspell</h1>
       , hwaccel: false // Whether to use hardware acceleration
       , position: 'absolute' // Element positioning
       };
-
+    {% if api_key %}
       var target = document.getElementById('github_collections_div');
       var spinner = new Spinner(opts).spin(target);
       //console.log(spinner);
@@ -124,6 +124,7 @@ <h1>Brainspell</h1>
         $("#github_collections").select2({placeholder: response.statusText});
         $("#github_collections").prop("disabled", true)
       });
+    {% end %}
 
         //Generates the popup widget when a vote element is clicked
       // TODO: might be worth making a class for popup, or potentially putting it in its own file
diff --git a/json_api/static/js/search-widgets.js b/json_api/static/js/search-widgets.js
index 0815400..62a844f 100644
--- a/json_api/static/js/search-widgets.js
+++ b/json_api/static/js/search-widgets.js
@@ -38,13 +38,13 @@ function setSearchString(str)
 {
 	searchString=str;
 }
-function initSearch() {
-	configureInterface();
+function initSearch(account_page = 0) {
+	if (account_page == 0) configureInterface();
 	configureTemplateImage();
 	configureLocationsImage();
 	loadTemplate();
 	initTranslucent();
-	loadLocations();
+	if (account_page == 0) loadLocations();
 }
 function configureInterface() {
 	$('#toggle-selection').click(function() {
@@ -309,6 +309,71 @@ function loadTemplate()
 	//console.log("[loadTemplate] template started loading");
 	
 }	
+function loadLocationsFromDict(coordsDict)
+{
+	// takes a dictionary, where the keys are tuples of the form "(x, y, z)"
+	var i;
+	
+	// init query volume
+	for(i=0;i<LR*PA*IS;i++)
+		sum[i]=0;
+
+	// configure roi
+	var	R=3;
+	var	roi=new Array();
+	var	nroi=0;
+	for(x=-R;x<=R;x++)
+	for(y=-R;y<=R;y++)
+	for(z=-R;z<=R;z++)
+	if(x*x+y*y+z*z<=R*R)
+	{
+		roi[nroi*3+0]=x;
+		roi[nroi*3+1]=y;
+		roi[nroi*3+2]=z;
+		nroi++;
+	}
+
+	var ii,refs=[],nrefs=0;
+	nLocationsLoaded=0;
+	flagLocationsLoaded=0;
+	var jj=refs[ii];
+
+	var coordsDictLength = 0;
+	// update the sum[] volume
+	var i,j,k,coord=new Array();
+	for(var coordTuple in coordsDict) {
+		coordsDictLength += 1;
+		coord = coordTuple.replace("(", "").replace(")", "").split(",");
+		coord[0]=Math.floor(coord[0]/4+22);
+		coord[1]=Math.floor(coord[1]/4+31);
+		coord[2]=Math.floor(coord[2]/4+17.5);
+		for(k=0;k<nroi;k++)
+		{
+			x=Math.floor(roi[k*3+0]+coord[0]);
+			y=Math.floor(roi[k*3+1]+coord[1]);
+			z=Math.floor(roi[k*3+2]+coord[2]);
+			if(x>=0&&x<LR && y>=0&&y<PA && z>=0&&z<IS)
+			{
+				sum[z*PA*LR+y*LR+x]+=1;
+				if(sum[z*PA*LR+y*LR+x]>max)
+					max=sum[z*PA*LR+y*LR+x];
+			}
+		}
+	}
+
+	if (coordsDictLength > 0) {
+		$("#widgetOption").css("display", "inline");
+		$("#widgetOption").text("Show widgets");
+		document.getElementById("widgetOption").disabled = false;
+		
+		// refresh the image
+		drawImages();
+		updateTranslucent();
+	}
+	else {
+		$("#widgetOption").css("display", "none");
+	}
+}
 function loadLocations()
 {
 	var i;
diff --git a/json_api/statistics.py b/json_api/statistics.py
new file mode 100644
index 0000000..4c8409a
--- /dev/null
+++ b/json_api/statistics.py
@@ -0,0 +1,230 @@
+""" A set of statistical functions for analyzing collections, papers, etc. """
+
+import collections
+import operator
+
+import scipy.stats as st
+from torngithub import json_decode
+
+from article_helpers import get_all_articles, get_article_object
+
+
+class Brain:
+    """ A 3D representation of the peaks of a paper, or collection of papers """
+
+    # TODO: once working, potentially switch to NumPy arrays
+    def init_brain_grid(self):
+        """ Create a 3-dimensional representation of the brain. """
+
+        # because there are far more coordinate locations that there are peaks, the
+        # following approach isn't wise
+        """
+        self.brain_grid = []
+        for i in range(0, 200):
+            self.brain_grid.append([])
+            for j in range(0, 200):
+                self.brain_grid[i].append([])
+                for k in range(0, 200):
+                    self.brain_grid[i][j].append(0) # initialize to all zeros
+        """
+        # better off using a hash map
+        self.brain_grid = collections.defaultdict(lambda: 0)
+
+    def __init__(self, total_samples=1):
+        self.init_brain_grid()
+        # indicating the number of PMIDs that this brain represents
+        self.total_samples = total_samples
+
+    def grid(self):
+        """ Return a dict representation of the brain grid. """
+
+        # again, the following approach is possible, but costly.
+        # if we want to eventually return an actual array, we can do that
+        """
+        grid_repr = []
+        for i in range(0, 200):
+            self.grid_repr.append([])
+            for j in range(0, 200):
+                self.grid_repr[i].append([])
+                for k in range(0, 200):
+                    self.grid_repr[i][j].append(0)  # initialize to all zeros
+
+        for coord in self.brain_grid:
+            try:
+                grid_repr[coord[0] + 100][coord[1] +
+                                          100][coord[2] + 100] = self.brain_grid[coord]
+            except BaseException:
+                # a coordinate fell outside of the range {(-100, 99), (-100,
+                # 99), (-100, 99)}
+                pass
+
+        return self.grid_repr
+        """
+        # convert to string keys to be JSON serialized
+        string_dict = {}
+        for k in self.brain_grid:
+            string_dict[str(k)] = self.brain_grid[k]
+        return string_dict
+
+    def insert_at_location(self, value, x, y, z, width=1):
+        """ Insert "value" at the corresponding location of the brain grid.
+
+        Take a "width" parameter, which specifies the width of the cube of
+        coordinates to affect. """
+
+        half_width = (width - 1) // 2
+
+        top_left_x = x - half_width
+        top_left_y = y - half_width
+        top_left_z = z - half_width
+
+        # start from the top left corner, and insert a "cube" of "value"s
+        for i in range(2 * half_width + 1):
+            for j in range(2 * half_width + 1):
+                for k in range(2 * half_width + 1):
+                    self.brain_grid[(i + top_left_x, j +
+                                     top_left_y, k + top_left_z)] = value
+
+    def sum(self, other):
+        """ Take a Brain, and upsert its entries into this current brain. Merge process is the sum of two entries. """
+
+        other_grid = other.grid()
+
+        for coord in other_grid:
+            self.brain_grid[coord] += other_grid[coord]
+
+        self.total_samples += other.total_samples
+
+    def transform_to_z_scores(self, other):
+        """ Take another brain, and calculate the z-score of each coordinate in this brain with respect to the other brain. """
+        for k in self.brain_grid:
+            # z = (p1hat - p2hat) / sqrt(phat * (1 - phat) * (1 / n1 + 1 / n2))
+            # : phat = (n1 * p1hat + n2 * p2hat) / (n1 + n2)
+            p1hat = self.brain_grid[k] / self.total_samples
+            p2hat = other.brain_grid[k] / other.total_samples
+            n1 = self.total_samples
+            n2 = other.total_samples
+            # assumes that (n1 + n2) != 0; will never occur,
+            # since the existence of k => self.total_samples >= 1
+            phat = (n1 * p1hat + n2 * p2hat) / (n1 + n2)
+            self.brain_grid[k] = (p1hat - p2hat) / \
+                ((phat * (1 - phat) * (1 / n1 + 1 / n2))**(.5))
+
+    def transform_to_p_values(self):
+        """ Tranform a Brain of z-scores to a Brain of p-values. """
+        # survivor function
+        for k in self.brain_grid:
+            self.brain_grid[k] = st.norm.sf(abs(self.brain_grid[k]))
+
+    def benjamini_hochberg(self, threshold):
+        """ Use Benjamini–Hochberg to account for multiple comparisons. """
+        filtering_threshold = threshold / self.total_samples
+        # get the brain_grid sorted by p-value
+        sorted_brain_grid_tuples = sorted(
+            self.brain_grid.items(),
+            key=operator.itemgetter(1))
+        # find the greatest i : P(i) <= i * filtering_threshold
+        # (this function actually finds the element right after that, and adds all elements before it)
+        i = 0
+        found_maximum = False
+        for j in range(len(sorted_brain_grid_tuples)):
+            if sorted_brain_grid_tuples[j][1] > (j + 1) * filtering_threshold:
+                i = j
+                found_maximum = True
+                break
+
+        if not found_maximum:
+            i = len(sorted_brain_grid_tuples)
+
+        self.init_brain_grid()  # add in only the results that are significant
+        for k in range(i):
+            self.brain_grid[sorted_brain_grid_tuples[k]
+                            [0]] = sorted_brain_grid_tuples[k][1]
+
+
+def get_boolean_map_from_article_object(article, width=5):
+    """ Return a Brain of 0s and 1s corresponding to if any coordinate exists at that location, in any of the article's experiment tables. """
+
+    brain = Brain()
+
+    try:
+        experiments = json_decode(article.experiments)
+
+        for exp in experiments:
+            locations = exp["locations"]
+            for coord_string in locations:
+                coord = coord_string.split(",")
+                try:  # assumes that coordinates are well-formed
+                    coord_tuple = (int(float(coord[0])), int(
+                        float(coord[1])), int(float(coord[2])))
+                    brain.insert_at_location(1, *coord_tuple, width=width)
+                except BaseException as e:
+                    # malformed coordinate
+                    print(e)
+                    pass
+    except BaseException as e:
+        # article not valid, or malformed JSON
+        print(e)
+        pass
+
+    return brain
+
+
+def get_boolean_map_from_pmid(pmid, width=5):
+    """ Get a boolean map of an article given a PMID. """
+
+    return get_boolean_map_from_article_object(
+        next(get_article_object(pmid)), width)
+
+
+def significance_from_collections(
+        pmids,
+        other_pmids=None,
+        width=5,
+        threshold=.001):
+    """ Return a grid representing the p-value/effect size
+    at each x, y, z coordinate, with the second collection acting as the
+    null hypothesis. Default to entire dataset - pmids. """
+
+    brain = Brain(total_samples=0)
+
+    # get the binomial distribution sample for pmids
+    # print("Generating cumulative Brain of the articles in this collection...")
+    for pmid in pmids:
+        # get the boolean repr of this PMID, then sum in the aggregate Brain
+        brain_to_sum = get_boolean_map_from_pmid(pmid, width)
+        brain.sum(brain_to_sum)
+
+    other_brain = Brain(total_samples=0)
+
+    if other_pmids is not None:
+        # get the sample for other_pmids
+        # print("Generating cumulative Brain of the articles in the other collection...")
+        for pmid in other_pmids:
+            brain_to_sum = get_boolean_map_from_pmid(pmid, width)
+            other_brain.sum(brain_to_sum)
+
+    else:
+        all_articles = get_all_articles()
+        # TODO: can cache this value once we start using this feature, and instead "subtract" the
+        # elements of the collection from (a clone of) the all_articles_brain
+        # print("Generating cumulative Brain of all articles in the database, minus the collection...")
+        article_checker = set(pmids)
+        for article in all_articles:
+            if article.pmid not in article_checker:
+                brain_to_sum = get_boolean_map_from_article_object(
+                    article, width)
+                other_brain.sum(brain_to_sum)
+
+    # print("Calculating significance...")
+    # calculate significance for each location, brain to other brain
+    brain.transform_to_z_scores(other_brain)
+
+    # convert to p values
+    brain.transform_to_p_values()
+    # print("Filtering insignificant values...")
+    # filter for significant values, accounting for multiple comparisons with
+    # Benjamini–Hochberg
+    brain.benjamini_hochberg(threshold)
+
+    return brain.grid()
diff --git a/json_api/test_tornado.py b/json_api/test_tornado.py
index fb69f85..0a7deeb 100644
--- a/json_api/test_tornado.py
+++ b/json_api/test_tornado.py
@@ -65,7 +65,7 @@ def test_abstraction_layer():
     for f in files_to_enforce:
         with open(f, "r") as python_file_handler:
             python_contents = python_file_handler.read()
-            assert ("from models import" not in python_contents) and ("import models" not in python_contents), "You should not access the models directly in your handler. The file " + \
+            assert ("from models import" not in python_contents) and ("import models" not in python_contents) and ("execute()" not in python_contents), "You should not access the models directly in your handler. The file " + \
                 f + " should be rewritten to no longer import models, and instead use a layer of abstraction (so that we can reimplement our data access layer if needed)."
             if f == "json_api.py" or f == "github_collections.py":
                 assert "self.render" not in python_contents, "The file " + f + \
diff --git a/requirements.txt b/requirements.txt
index efb4c60..abbd5cf 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,6 +9,7 @@ psycopg2==2.6.2
 pycurl==7.43.0
 pytest-tornado==0.4.5
 pytest==3.0.3
+scipy==0.19.1
 simplejson==3.10.0
 tornado==4.4.1
 torngithub==0.2.0