gold: force layout diagram

golden/go/skiacorrectness/main2.go

 package main
 
 import (
         "encoding/json"
         "fmt"
         "html/template"
         "net/http"
         "net/url"
         "path/filepath"
         "regexp"
@@ skipping 29 matching lines @@
         MAX_PAGE_SIZE = 100
 )
 
 var (
         templates *template.Template
 )
 
 func loadTemplates() {
         templates = template.Must(template.New("").Delims("{%", "%}").ParseFiles(
                 filepath.Join(*resourcesDir, "templates/byblame.html"),
+                filepath.Join(*resourcesDir, "templates/cluster.html"),
                 filepath.Join(*resourcesDir, "templates/index.html"),
                 filepath.Join(*resourcesDir, "templates/ignores.html"),
                 filepath.Join(*resourcesDir, "templates/compare.html"),
                 filepath.Join(*resourcesDir, "templates/single.html"),
                 filepath.Join(*resourcesDir, "templates/diff.html"),
                 filepath.Join(*resourcesDir, "templates/help.html"),
                 filepath.Join(*resourcesDir, "templates/triagelog.html"),
                 filepath.Join(*resourcesDir, "templates/search.html"),
                 filepath.Join(*resourcesDir, "templates/search2.html"),
                 // Sub templates used by other templates.
@@ skipping 1153 matching lines @@
                 Pos:            r.FormValue("pos") == "true",
                 Neg:            r.FormValue("neg") == "true",
                 Unt:            r.FormValue("unt") == "true",
                 Head:           r.FormValue("head") == "true",
                 IncludeIgnores: r.FormValue("include") == "true",
                 Query:          r.FormValue("query"),
                 Limit:          Limit,
         }
 }
 
+// Node represents a single node in a d3 diagram. Used in D3.
+type Node struct {
+        Name   string `json:"name"`
+        Status string `json:"status"`
+}
+
+// Link represents a link between d3 nodes, used in D3.
+type Link struct {
+        Source int     `json:"source"`
+        Target int     `json:"target"`
+        Value  float32 `json:"value"`
+}
+
+// D3 represents the data structure to pass to a d3 force layout object.
+type D3 struct {
+        Nodes []Node `json:"nodes"`
+        Links []Link `json:"links"`
+
+        // map [digest] paramset
+        Paramsets map[string]map[string][]string `json:"paramsets"`
+}
+
+// nxnJSONHandler calculates the NxN diffs of all the digests that match
+// the incoming query and returns the data in a format appropriate for
+// handling in d3.
+func nxnJSONHandler(w http.ResponseWriter, r *http.Request) {
+        w.Header().Set("Content-Type", "application/json")
+        test := r.FormValue("test")
+
+        e, err := storages.ExpectationsStore.Get()
+        if err != nil {
+                util.ReportError(w, r, err, "Failed to get expectations.")
+        }
+
+        var t *tally.Tally
+        var ok bool
+        if t, ok = tallies.ByTest()[test]; !ok {
+                util.ReportError(w, r, fmt.Errorf("Not a valid test name: %s", test), "Not a valid test name.")
+        }
+
+        digests := []string{}
+        for digest, _ := range *t {
+                digests = append(digests, digest)
+        }
+
+        digestIndex := map[string]int{}
+        for i, d := range digests {
+                digestIndex[d] = i
+        }
+
+        d3 := D3{
+                Nodes:     []Node{},
+                Links:     []Link{},
+                Paramsets: map[string]map[string][]string{},
+        }
+        for i, d := range digests {
+                d3.Nodes = append(d3.Nodes, Node{
+                        Name:   d,
+                        Status: e.Classification(test, d).String(),
+                })
+                remaining := digests[i:len(digests)]
+                diffs, err := storages.DiffStore.Get(d, remaining)
+                if err != nil {
+                        glog.Errorf("Failed to calculate differences: %s", err)
+                        continue
+                }
+                for otherDigest, diff := range diffs {
+                        d3.Links = append(d3.Links, Link{
+                                Source: digestIndex[d],
+                                Target: digestIndex[otherDigest],
+                                Value:  diff.PixelDiffPercent,
+                        })
+                }
+                d3.Paramsets[d] = paramsetSum.Get(test, d, false)
+        }
+
+        sendJsonResponse(w, d3)
+}
+
 // sendJsonResponse serializes resp to JSON. If an error occurs
 // a text based error code is send to the client.
 func sendJsonResponse(w http.ResponseWriter, resp interface{}) {
         w.Header().Set("Content-Type", "application/json")
         if err := json.NewEncoder(w).Encode(resp); err != nil {
                 glog.Errorf("Failed to write or encode result: %s", err)
         }
 }
 
 // makeResourceHandler creates a static file handler that sets a caching policy.
 func makeResourceHandler() func(http.ResponseWriter, *http.Request) {
         fileServer := http.FileServer(http.Dir(*resourcesDir))
         return func(w http.ResponseWriter, r *http.Request) {
                 w.Header().Add("Cache-Control", string(300))
                 fileServer.ServeHTTP(w, r)
         }
 }
 
 // Init figures out where the resources are and then loads the templates.
 func Init() {
         if *resourcesDir == "" {
                 _, filename, _, _ := runtime.Caller(0)
                 *resourcesDir = filepath.Join(filepath.Dir(filename), "../..")
         }
         loadTemplates()
 }