Add all files to this repo

.bowerrc

+{
+  "directory": "bower_components",
+  "analytics": false
+}

.editorconfig

+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+
+[*]
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+indent_style = space
+indent_size = 2
+
+[*.js]
+indent_style = space
+indent_size = 2
+
+[*.hbs]
+insert_final_newline = false
+indent_style = space
+indent_size = 2
+
+[*.css]
+indent_style = space
+indent_size = 2
+
+[*.html]
+indent_style = space
+indent_size = 2
+
+[*.{diff,md}]
+trim_trailing_whitespace = false

.ember-cli

+{
+  /**
+    Ember CLI sends analytics information by default. The data is completely
+    anonymous, but there are times when you might want to disable this behavior.
+
+    Setting `disableAnalytics` to true will prevent any data from being sent.
+  */
+  "disableAnalytics": false
+}

.gitignore

+# See http://help.github.com/ignore-files/ for more about ignoring files.
+
+# compiled output
+/dist
+/tmp
+
+# dependencies
+/node_modules
+/bower_components
+
+# misc
+/.sass-cache
+/connect.lock
+/coverage/*
+/libpeerconnection.log
+npm-debug.log
+testem.log

.jshintrc

+{
+  "predef": [
+    "document",
+    "window",
+    "-Promise"
+  ],
+  "bass": true,
+  "browser": true,
+  "boss": true,
+  "curly": true,
+  "debug": false,
+  "devel": true,
+  "eqeqeq": true,
+  "evil": true,
+  "forin": false,
+  "immed": false,
+  "laxbreak": false,
+  "newcap": true,
+  "noarg": true,
+  "noempty": false,
+  "nonew": false,
+  "nomen": false,
+  "onevar": false,
+  "plusplus": false,
+  "regexp": false,
+  "undef": true,
+  "sub": true,
+  "strict": false,
+  "white": false,
+  "eqnull": true,
+  "esnext": true,
+  "unused": true
+}

.travis.yml

+---
+language: node_js
+node_js:
+  - "4"
+
+sudo: false
+
+cache:
+  directories:
+    - node_modules
+
+before_install:
+  - npm config set spin false
+  - npm install -g bower
+  - npm install phantomjs-prebuilt
+
+install:
+  - npm install
+  - bower install
+
+script:
+  - npm test

.watchmanconfig

+{
+  "ignore_dirs": ["tmp", "dist"]
+}

README.md

+# Viewer
+
+This README outlines the details of collaborating on this Ember application.
+A short introduction of this app could easily go here.
+
+## Prerequisites
+
+You will need the following things properly installed on your computer.
+
+* [Git](http://git-scm.com/)
+* [Node.js](http://nodejs.org/) (with NPM)
+* [Bower](http://bower.io/)
+* [Ember CLI](http://ember-cli.com/)
+* [PhantomJS](http://phantomjs.org/)
+
+## Installation
+
+* `git clone <repository-url>` this repository
+* change into the new directory
+* `npm install`
+* `bower install`
+
+## Running / Development
+
+* `ember server`
+* Visit your app at [http://localhost:4200](http://localhost:4200).
+
+### Code Generators
+
+Make use of the many generators for code, try `ember help generate` for more details
+
+### Running Tests
+
+* `ember test`
+* `ember test --server`
+
+### Building
+
+* `ember build` (development)
+* `ember build --environment production` (production)
+
+### Deploying
+
+Specify what it takes to deploy your app.
+
+## Further Reading / Useful Links
+
+* [ember.js](http://emberjs.com/)
+* [ember-cli](http://ember-cli.com/)
+* Development Browser Extensions
+  * [ember inspector for chrome](https://chrome.google.com/webstore/detail/ember-inspector/bmdblncegkenkacieihfhpjfppoconhi)
+  * [ember inspector for firefox](https://addons.mozilla.org/en-US/firefox/addon/ember-inspector/)
+

app/adapters/application.js

+import JSONAPIAdapter from 'ember-data/adapters/json-api';
+
+export default JSONAPIAdapter.extend({
+    host: 'http://localhost:8888',
+    namespace: 'api/v1'
+});

app/app.js

+import Ember from 'ember';
+import Resolver from './resolver';
+import loadInitializers from 'ember-load-initializers';
+import config from './config/environment';
+
+let App;
+
+Ember.MODEL_FACTORY_INJECTIONS = true;
+
+App = Ember.Application.extend({
+  modulePrefix: config.modulePrefix,
+  podModulePrefix: config.podModulePrefix,
+  Resolver
+});
+
+loadInitializers(App, config.modulePrefix);
+
+export default App;

app/components/images-loader.js

+import Ember from 'ember';
+import ENV from 'viewer/config/environment';
+
+const ImageLoaderComponent = Ember.Component.extend({
+    store: Ember.inject.service(),
+    current_face: null,
+
+    imageIndexChanged: Ember.observer('image_index', function() {

+        this.send('updateCurrentFace');
+    }),
+
+    loadFaces: Ember.on('didInsertElement', function() {
+        this.get('store').findAll('face').then((faces) => {
+            this.set('faces', faces);
+            this.send('updateCurrentFace');
+        });
+    }),
+
+    faces: Ember.computed('params.[]', function(){
+        return this.get('params')[1];
+    }),
+
+    convertFilenameToBase64: function(fileUrl, resolve) {
+        var image = new Image();
+        image.crossOrigin = 'Anonymous';
+
+        image.onload = function() {
+            var canvas = document.createElement('CANVAS');
+            var ctx = canvas.getContext('2d');
+            var dataURL;
+            canvas.height = this.height;
+            canvas.width = this.width;
+            ctx.drawImage(this, 0, 0);
+            dataURL = canvas.toDataURL('image/jpeg');
+            console.log(dataUrl);
+            resolve(dataURL);
+            canvas = null;
+        };
+
+        image.src = fileUrl;
+    },
+
+    actions: {
+        /**
+        * Update the current face given the current index
+        */
+        updateCurrentFace() {
+            var face = this.get('faces').objectAt(this.get('image_index'));
+            var filename = face.get('filename');
+            //var that = this;
+
+            //var requestConversion = new Ember.RSVP.Promise(function(resolve, reject) {
+            //     that.convertFilenameToBase64(filename, resolve);
+            //});
+
+            //requestConversion.then((base64Image) => {
+            this.set('current_face', face);
+            //this.set('current_face_base64', base64Image);
+            this.set('current_face_filename', ENV.APP.staticURL + filename);
+        }
+    }
+});
+
+ImageLoaderComponent.reopenClass({
+    positionalParams: ['params']
+});
+
+export default ImageLoaderComponent;

app/components/three-js-reconstruction.js

+import Ember from 'ember';
+import THREE from 'npm:three';
+import dat from 'npm:dat-gui';
+
+
+const ThreeComponent = Ember.Component.extend({
+    store: Ember.inject.service(),
+    scene: null,
+
+    willRender() {
+        if (this.scene) {
+            return;
+        }
+
+        var scene = new THREE.Scene();
+        var gui = new dat.GUI();
+        var camera = new THREE.PerspectiveCamera(
+            75, window.innerWidth / window.innerHeight, 0.1, 1000
+        );
+
+        scene.add(camera);
+
+        var renderer = new THREE.WebGLRenderer();
+
+        this.set('scene', scene);
+        this.set('camera', camera);
+        this.set('renderer', renderer);
+        this.set('gui', gui);
+
+        this.get('store').findAll('face').then((faces) => {
+            this.set('faces', faces);
+            this.addSliders();
+        });
+    },
+
+    /**
+     * Wait for elements to be inserted, else we can not find
+     * the threejs container.
+     * TODO: try to not use appendChild
+     */
+    loadGui: Ember.computed('faces', function() {
+        //var container = document.getElementById('threejs-container');
+        //container.appendChild(this.get('renderer').domElement);
+
+    }),
+
+    /**
+     * Adds the 'dat-gui' sliders
+     *
+     * See:
+     * http://learningthreejs.com/blog/2011/08/14/dat-gui-simple-ui-for-demos/
+     */
+    addSliders() {
+        var self = this;
+        var gui = this.get('gui');
+
+        // the sidebar 'dat-gui' controls
+        var reconstructionControls = {
+            index: 0,
+            shape_components: 58,
+            background_image: true
+        };
+
+        var length = this.get('faces').get('length');
+
+        var index = gui.add(reconstructionControls, 'index', 0, length - 1);
+        var shapeComponents = gui.add(reconstructionControls, 'shape_components', 0, 58);
+        var background = gui.add(reconstructionControls, 'background_image');
+
+        // on index change
+        index.onChange(function(newValue) {
+            // update the image_index, which is on the controller
+            self.set('image_index', parseInt(newValue));
+            self.sendAction('updateIndex', parseInt(newValue));
+        });
+
+        background.onChange(function(newValue) {
+            self.sendAction('updateBackground', newValue);
+        });
+
+        shapeComponents.onChange(function(newValue) {
+            self.sendAction('updateShapeComponents', newValue);
+        });
+
+        var shapeEigenValueControls = gui.addFolder('shape_eigen_values');
+
+        /**
+        * ShapeSlider callback function
+        */
+        var handleShapeSlidersCb = function(value) {
+            var sliderObject = this;
+
+            // slider index is the last character of the slider property string.
+            var sliderCharacterIndex = sliderObject.property.length - 1;
+            var sliderIndex = parseInt(sliderObject.property[sliderCharacterIndex]);
+
+            self.sendAction('updateShapeEigenValues', sliderIndex, value);
+        };
+
+        var shapeEigenValues = this.get('shape_eigenvalues');
+
+        shapeEigenValues.forEach(function(value, index) {
+            reconstructionControls['shape_eigen_value_' + index] = value;
+            var slider = shapeEigenValueControls.add(reconstructionControls, 'shape_eigen_value_' + index, 0.0, 10.0);
+
+            slider.onChange(handleShapeSlidersCb);
+        });
+
+        console.log(gui.__controllers);
+    }
+});
+
+export default ThreeComponent;

app/controllers/reconstruction.js

+import Ember from 'ember';
+
+const { get, inject } = Ember;
+
+export default Ember.Controller.extend({
+    websockets: inject.service(),
+
+    title: 'title',
+    faces: null,
+    image: null,
+
+    image_index: 0,
+    background_image: true,
+    shape_components: 58,
+    n_images: null,
+    reconstructed: null,
+    shape_eigenvalues: [],
+
+    socketRef: null,
+
+    init() {
+        const socket = get(this, 'websockets').socketFor('ws://localhost:8888/reconstruction');
+
+        socket.on('open', this.openHandler, this);
+        socket.on('message', this.messageHandler, this);
+        socket.on('close', this.closeHandler, this);
+
+        this.set('socketRef', socket);
+        this.initShapeEigenValues(15);
+    },
+
+    initShapeEigenValues(amountOfEigenValues) {
+        var shapeEigenValues = this.get('shape_eigenvalues');
+
+        shapeEigenValues.length = amountOfEigenValues;
+        shapeEigenValues.fill(1.0);
+
+        this.set('shape_eigenvalues', shapeEigenValues);
+    },
+
+    willDestroyElement() {
+        const socket = this.get('socketRef');
+
+        /*
+        * Remove all of the listeners you have setup.
+        */
+        socket.off('open', this.openHandler);
+        socket.off('message', this.messageHandler);
+        socket.off('close', this.closeHandler);
+
+        console.log('Websockets: Removed all handlers');
+    },
+
+    openHandler(event) {
+        console.log(`On open event has been called: ${event}`);
+
+        // get the reconstruction right after the socket opened
+        this.send('getReconstruction');
+    },
+
+    messageHandler(event) {
+        var message = JSON.parse(event.data);
+
+        if (message.n_images) {
+            this.set('n_images', message.n_images);
+        }
+
+        if (message.reconstructed) {
+            this.set('reconstructed', message.reconstructed);
+        }
+
+        if (message.error) {
+            console.log(message.error);
+        }
+
+        this.set('loading', false);
+    },
+
+    getReconstruction: Ember.observer(
+            'image_index', 'background_image',
+            'shape_components', 'shape_eigenvalues', function() {
+        this.send('getReconstruction');
+    }),
+
+    closeHandler(event) {
+        console.log(`On close event has been called: ${event}`);
+    },
+
+    actions: {
+        getImage(faceModel) {
+            this.set('loading', true);
+            var filename = faceModel.get('filename');
+
+            const socket = this.get('socketRef');
+
+            socket.send(
+                JSON.stringify({filename: filename})
+            );
+        },
+
+        getReconstruction() {
+            this.set('loading', true);
+            const socket = this.get('socketRef');
+            console.log(this.get('current_face_base64'));
+
+            socket.send(
+                JSON.stringify({
+                    reconstruction: {
+                        reconstruction_index: this.get('image_index'),
+                        background_image: this.get('background_image'),
+                        shape_components: this.get('shape_components'),
+                        shape_eigenvalues: this.get('shape_eigenvalues')
+                    }
+                })
+            );
+        },
+
+        // connects components together
+        // handles the upate action passed to a component
+        updateIndexComponentConnector(index) {
+            this.set('image_index', index);
+        },
+
+        updateBackgroundComponentConnector(showBackground) {
+            this.set('background_image', showBackground);
+        },
+
+        updateShapeComponents(components) {
+            console.log('shape_components', components);
+            this.set('shape_components', components);
+        },
+
+        updateShapeEigenValues(eigenValueIndex, value) {
+            console.log('shape_eigenvalues', value);
+            var eigenValues = this.get('shape_eigenvalues');
+            eigenValues[eigenValueIndex] = value;
+
+            this.set('shape_eigenvalues', eigenValues);
+            this.send('getReconstruction');
+        },
+
+        resetShapeEigenValues(/*gui*/) {
+            this.initShapeEigenValues(15);
+        }
+    }
+});

app/controllers/test-controller.js

+import Ember from 'ember';
+
+export default Ember.Controller.extend({
+});

app/index.html

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>Viewer</title>
+    <meta name="description" content="">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    {{content-for "head"}}
+
+    <link rel="stylesheet" href="assets/vendor.css">
+    <link rel="stylesheet" href="assets/viewer.css">
+
+    <link href="https://npmcdn.com/basscss@7.1.1/css/basscss.min.css"
+    rel="stylesheet">
+
+    {{content-for "head-footer"}}
+  </head>
+  <body>
+    <div class="clearfix">
+        {{content-for "body"}}
+    </div>
+
+        <script src="assets/vendor.js"></script>
+        <script src="assets/viewer.js"></script>
+
+    <div class="clearfix">
+        {{content-for "body-footer"}}
+    </div>
+  </body>
+</html>

app/models/face-model.js

+import Model from 'ember-data/model';
+import attr from 'ember-data/attr';
+import { hasMany } from 'ember-data/relationships';
+
+export default Model.extend({
+    type: attr('string'),
+    maxComponents: attr('int'),
+    nEigenvalues: attr('int'),
+    faces: hasMany('face')
+});

app/models/face.js

+import Model from 'ember-data/model';
+import attr from 'ember-data/attr';
+import { belongsTo } from 'ember-data/relationships';
+
+export default Model.extend({
+    filename: attr('string'),
+    shape: attr(),
+    faceModel: belongsTo('face-model')
+});

app/resolver.js

+import Resolver from 'ember-resolver';
+
+export default Resolver;

app/router.js

+import Ember from 'ember';
+import config from './config/environment';
+
+const Router = Ember.Router.extend({
+  location: config.locationType
+});
+
+Router.map(function() {
+  this.route('reconstruction');
+});
+
+export default Router;

app/routes/application.js

+import Ember from 'ember';
+
+export default Ember.Route.extend({
+});

app/routes/faces.js

+import Ember from 'ember';
+
+export default Ember.Route.extend({
+
+});

app/routes/reconstruction.js

+import Ember from 'ember';
+
+export default Ember.Route.extend({
+    model() {
+        //return this.get('store').findAll('face');
+    }
+});

app/styles/app.css

+canvas { width: 100%; height: 100% }
+
+.empty-image-container {
+    width: 100%;
+    height: 480px;
+}

app/templates/application.hbs

+<nav class="clearfix white bg-black">
+    {{#link-to "index" class="btn py2"}}Index{{/link-to}}
+    {{#link-to "reconstruction" class="btn py2"}}Reconstruction{{/link-to}}
+</nav>
+
+{{outlet}}

app/templates/components/images-loader.hbs

+{{# if current_face_filename }}
+    <img src='{{current_face_filename}}' alt='missing original'>
+{{/if}}
+{{yield}}

app/templates/components/three-js-reconstruction.hbs

+<div id="threejs-container"> </div>
+{{yield}}

app/templates/faces.hbs

+{{outlet}}

app/templates/reconstruction.hbs

+<h1>Reconstruction</h1>
+
+<div class="container">
+    <div class="clearfix">
+        <div class="col col-6">
+            {{images-loader image_index=image_index
+                background_image=background_image
+                shape_components=shape_components
+                loading=loading
+            }}
+        </div>
+
+        <div class="col col-6">
+            <div class="table">
+                <div class="table-cell align-middle">
+                    {{#if reconstructed }}
+                        <img src='data:image/jpg;base64,{{reconstructed}}'
+                            alt='missing image'>
+                    {{/if}}
+
+                    {{#if loading }}
+                        {{fa-icon "spinner" spin=true size='lg'}} Loading..
+                    {{/if}}
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div class="col col-12 px2">
+        {{three-js-reconstruction
+            shape_eigenvalues=shape_eigenvalues
+            updateIndex=(action 'updateIndexComponentConnector')
+            updateBackground=(action 'updateBackgroundComponentConnector')
+            updateShapeComponents=(action 'updateShapeComponents')
+            updateShapeEigenValues=(action 'updateShapeEigenValues')
+            resetShapeEigenValues=(action 'resetShapeEigenValues')
+        }}
+    </div>
+</div>

bower.json

+{
+  "name": "viewer",
+  "dependencies": {
+    "ember": "~2.6.0",
+    "ember-cli-shims": "0.1.1",
+    "ember-cli-test-loader": "0.2.2",
+    "ember-qunit-notifications": "0.1.0",
+    "urijs": "^1.18.1",
+    "basscss": "~8.0.1",
+    "font-awesome": "~4.5.0"
+  }
+}

config/environment.js

+/* jshint node: true */
+
+module.exports = function(environment) {
+  var ENV = {
+    modulePrefix: 'viewer',
+    environment: environment,
+    baseURL: '/',
+    locationType: 'auto',
+    EmberENV: {
+      FEATURES: {
+        // Here you can enable experimental features on an ember canary build
+        // e.g. 'with-controller': true
+      }
+    },
+
+    APP: {
+      // Here you can pass flags/options to your application instance
+      // when it is created
+    }
+  };
+
+  if (environment === 'development') {
+    ENV.APP.staticURL = 'http://localhost:8888/data/';
+    // ENV.APP.LOG_RESOLVER = true;
+    // ENV.APP.LOG_ACTIVE_GENERATION = true;
+    // ENV.APP.LOG_TRANSITIONS = true;
+    // ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
+    // ENV.APP.LOG_VIEW_LOOKUPS = true;
+  }
+
+  if (environment === 'test') {
+    // Testem prefers this...
+    ENV.baseURL = '/';
+    ENV.locationType = 'none';
+
+    // keep test console output quieter
+    ENV.APP.LOG_ACTIVE_GENERATION = false;
+    ENV.APP.LOG_VIEW_LOOKUPS = false;
+
+    ENV.APP.rootElement = '#ember-testing';
+  }
+
+  if (environment === 'production') {
+
+  }
+
+  return ENV;
+};

ember-cli-build.js

+/*jshint node:true*/
+/* global require, module */
+var EmberApp = require('ember-cli/lib/broccoli/ember-app');
+
+module.exports = function(defaults) {
+  var app = new EmberApp(defaults, {
+    // Add options here
+  });
+
+  // bower compoenents
+  app.import('bower_components/basscss/modules/align/index.css');
+  app.import('bower_components/basscss/modules/border/index.css');
+  app.import('bower_components/basscss/modules/flexbox/index.css');
+  app.import('bower_components/basscss/modules/grid/index.css');
+  app.import('bower_components/basscss/modules/hide/index.css');
+  app.import('bower_components/basscss/modules/layout/index.css');
+  app.import('bower_components/basscss/modules/margin/index.css');
+  app.import('bower_components/basscss/modules/padding/index.css');
+  app.import('bower_components/basscss/modules/position/index.css');
+  app.import('bower_components/basscss/modules/type-scale/index.css');
+  app.import('bower_components/basscss/modules/typography/index.css');
+
+  // npm modules
+  //app.import('node_modules/basscss-responsive-margin/css/responsive-margin.css');
+
+  // Use `app.import` to add additional libraries to the generated
+  // output files.
+  //
+  // If you need to use different assets in different
+  // environments, specify an object as the first parameter. That
+  // object's keys should be the environment name and the values
+  // should be the asset to use in that environment.
+  //
+  // If the library that you are including contains AMD or ES6
+  // modules that you would like to import into your application
+  // please specify an object with the list of modules as keys
+  // along with the exports of each module as its value.
+
+  return app.toTree();
+};

package.json

+{
+  "name": "viewer",
+  "version": "0.0.0",
+  "description": "Small description for viewer goes here",
+  "private": true,
+  "directories": {
+    "doc": "doc",
+    "test": "tests"
+  },
+  "scripts": {
+    "build": "ember build",
+    "start": "ember server",
+    "test": "ember test"
+  },
+  "repository": "",
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "basscss-responsive-margin": "^1.1.0",
+    "broccoli-asset-rev": "^2.4.2",
+    "ember-ajax": "^2.0.1",
+    "ember-browserify": "1.1.10",
+    "ember-cli": "2.6.2",
+    "ember-cli-app-version": "^1.0.0",
+    "ember-cli-babel": "^5.1.6",
+    "ember-cli-cors": "0.0.2",
+    "ember-cli-dependency-checker": "^1.2.0",
+    "ember-cli-htmlbars": "^1.0.3",
+    "ember-cli-htmlbars-inline-precompile": "^0.3.1",
+    "ember-cli-inject-live-reload": "^1.4.0",
+    "ember-cli-jshint": "^1.0.0",
+    "ember-cli-qunit": "^1.4.0",
+    "ember-cli-release": "^0.2.9",
+    "ember-cli-sri": "^2.1.0",
+    "ember-cli-uglify": "^1.2.0",
+    "ember-data": "^2.6.0",
+    "ember-export-application-global": "^1.0.5",
+    "ember-font-awesome": "2.1.1",
+    "ember-load-initializers": "^0.5.1",
+    "ember-resolver": "^2.0.3",
+    "ember-websockets": "4.0.1",
+    "ember-welcome-page": "^1.0.1",
+    "loader.js": "^4.0.1",
+    "mock-socket": "3.0.1",
+    "three": "^0.78.0"
+  }
+}

public/crossdomain.xml

+<?xml version="1.0"?>
+<!DOCTYPE cross-domain-policy SYSTEM "http://www.adobe.com/xml/dtds/cross-domain-policy.dtd">
+<cross-domain-policy>
+  <!-- Read this: www.adobe.com/devnet/articles/crossdomain_policy_file_spec.html -->
+
+  <!-- Most restrictive policy: -->
+  <site-control permitted-cross-domain-policies="none"/>
+
+  <!-- Least restrictive policy: -->
+  <!--
+  <site-control permitted-cross-domain-policies="all"/>
+  <allow-access-from domain="*" to-ports="*" secure="false"/>
+  <allow-http-request-headers-from domain="*" headers="*" secure="false"/>
+  -->
+</cross-domain-policy>

public/robots.txt

+# http://www.robotstxt.org
+User-agent: *
+Disallow:

testem.js

+/*jshint node:true*/
+module.exports = {
+  "framework": "qunit",
+  "test_page": "tests/index.html?hidepassed",
+  "disable_watching": true,
+  "launch_in_ci": [
+    "PhantomJS"
+  ],
+  "launch_in_dev": [
+    "PhantomJS",
+    "Chrome"
+  ]
+};

tests/.jshintrc

+{
+  "predef": [
+    "document",
+    "window",
+    "location",
+    "setTimeout",
+    "$",
+    "-Promise",
+    "define",
+    "console",
+    "visit",
+    "exists",
+    "fillIn",
+    "click",
+    "keyEvent",
+    "triggerEvent",
+    "find",
+    "findWithAssert",
+    "wait",
+    "DS",
+    "andThen",
+    "currentURL",
+    "currentPath",
+    "currentRouteName"
+  ],
+  "node": false,
+  "browser": false,
+  "boss": true,
+  "curly": true,
+  "debug": false,
+  "devel": false,
+  "eqeqeq": true,
+  "evil": true,
+  "forin": false,
+  "immed": false,
+  "laxbreak": false,
+  "newcap": true,
+  "noarg": true,
+  "noempty": false,
+  "nonew": false,
+  "nomen": false,
+  "onevar": false,
+  "plusplus": false,
+  "regexp": false,
+  "undef": true,
+  "sub": true,
+  "strict": false,
+  "white": false,
+  "eqnull": true,
+  "esnext": true,
+  "unused": true
+}

tests/helpers/destroy-app.js

+import Ember from 'ember';
+
+export default function destroyApp(application) {
+  Ember.run(application, 'destroy');
+}

tests/helpers/module-for-acceptance.js

+import { module } from 'qunit';
+import Ember from 'ember';
+import startApp from '../helpers/start-app';
+import destroyApp from '../helpers/destroy-app';
+
+const { RSVP: { Promise } } = Ember;
+
+export default function(name, options = {}) {
+  module(name, {
+    beforeEach() {
+      this.application = startApp();
+
+      if (options.beforeEach) {
+        return options.beforeEach.apply(this, arguments);
+      }
+    },
+
+    afterEach() {
+      let afterEach = options.afterEach && options.afterEach.apply(this, arguments);
+      return Promise.resolve(afterEach).then(() => destroyApp(this.application));
+    }
+  });
+}

tests/helpers/resolver.js

+import Resolver from '../../resolver';
+import config from '../../config/environment';
+
+const resolver = Resolver.create();
+
+resolver.namespace = {
+  modulePrefix: config.modulePrefix,
+  podModulePrefix: config.podModulePrefix
+};
+
+export default resolver;

tests/helpers/start-app.js

+import Ember from 'ember';
+import Application from '../../app';
+import config from '../../config/environment';
+
+export default function startApp(attrs) {
+  let application;
+
+  let attributes = Ember.merge({}, config.APP);
+  attributes = Ember.merge(attributes, attrs); // use defaults, but you can override;
+
+  Ember.run(() => {
+    application = Application.create(attributes);
+    application.setupForTesting();
+    application.injectTestHelpers();
+  });
+
+  return application;
+}

tests/index.html

+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <title>Viewer Tests</title>
+    <meta name="description" content="">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    {{content-for "head"}}
+    {{content-for "test-head"}}
+
+    <link rel="stylesheet" href="assets/vendor.css">
+    <link rel="stylesheet" href="assets/viewer.css">
+    <link rel="stylesheet" href="assets/test-support.css">
+
+    {{content-for "head-footer"}}
+    {{content-for "test-head-footer"}}
+  </head>
+  <body>
+    {{content-for "body"}}
+    {{content-for "test-body"}}
+
+    <script src="testem.js" integrity=""></script>
+    <script src="assets/vendor.js"></script>
+    <script src="assets/test-support.js"></script>
+    <script src="assets/viewer.js"></script>
+    <script src="assets/tests.js"></script>
+    <script src="assets/test-loader.js"></script>
+
+    {{content-for "body-footer"}}
+    {{content-for "test-body-footer"}}
+  </body>
+</html>

tests/integration/components/images-loader-test.js

+import { moduleForComponent, test } from 'ember-qunit';
+import hbs from 'htmlbars-inline-precompile';
+
+moduleForComponent('images-loader', 'Integration | Component | images loader', {
+  integration: true
+});
+
+test('it renders', function(assert) {
+  // Set any properties with this.set('myProperty', 'value');
+  // Handle any actions with this.on('myAction', function(val) { ... });
+
+  this.render(hbs`{{images-loader}}`);
+
+  assert.equal(this.$().text().trim(), '');
+
+  // Template block usage:
+  this.render(hbs`
+    {{#images-loader}}
+      template block text
+    {{/images-loader}}
+  `);
+
+  assert.equal(this.$().text().trim(), 'template block text');
+});

tests/integration/components/three-js-reconstruction-test.js

+import { moduleForComponent, test } from 'ember-qunit';
+import hbs from 'htmlbars-inline-precompile';
+
+moduleForComponent('three-js-reconstruction', 'Integration | Component | three js reconstruction', {
+  integration: true
+});
+
+test('it renders', function(assert) {
+  // Set any properties with this.set('myProperty', 'value');
+  // Handle any actions with this.on('myAction', function(val) { ... });
+
+  this.render(hbs`{{three-js-reconstruction}}`);
+
+  assert.equal(this.$().text().trim(), '');
+
+  // Template block usage:
+  this.render(hbs`
+    {{#three-js-reconstruction}}
+      template block text
+    {{/three-js-reconstruction}}
+  `);
+
+  assert.equal(this.$().text().trim(), 'template block text');
+});

tests/test-helper.js

+import resolver from './helpers/resolver';
+import {
+  setResolver
+} from 'ember-qunit';
+
+setResolver(resolver);

tests/unit/controllers/reconstruction-test.js

+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('controller:reconstruction', 'Unit | Controller | reconstruction', {
+  // Specify the other units that are required for this test.
+  // needs: ['controller:foo']
+});
+
+// Replace this with your real tests.
+test('it exists', function(assert) {
+  let controller = this.subject();
+  assert.ok(controller);
+});

tests/unit/controllers/test-controller-test.js

+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('controller:test-controller', 'Unit | Controller | test controller', {
+  // Specify the other units that are required for this test.
+  // needs: ['controller:foo']
+});
+
+// Replace this with your real tests.
+test('it exists', function(assert) {
+  let controller = this.subject();
+  assert.ok(controller);
+});

tests/unit/models/face-model-test.js

+import { moduleForModel, test } from 'ember-qunit';
+
+moduleForModel('face-model', 'Unit | Model | face model', {
+  // Specify the other units that are required for this test.
+  needs: []
+});
+
+test('it exists', function(assert) {
+  let model = this.subject();
+  // let store = this.store();
+  assert.ok(!!model);
+});

tests/unit/models/face-test.js

+import { moduleForModel, test } from 'ember-qunit';
+
+moduleForModel('face', 'Unit | Model | face', {
+  // Specify the other units that are required for this test.
+  needs: []
+});
+
+test('it exists', function(assert) {
+  let model = this.subject();
+  // let store = this.store();
+  assert.ok(!!model);
+});

tests/unit/routes/application-test.js

+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('route:application', 'Unit | Route | application', {
+  // Specify the other units that are required for this test.
+  // needs: ['controller:foo']
+});
+
+test('it exists', function(assert) {
+  let route = this.subject();
+  assert.ok(route);
+});

tests/unit/routes/faces-test.js

+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('route:faces', 'Unit | Route | faces', {
+  // Specify the other units that are required for this test.
+  // needs: ['controller:foo']
+});
+
+test('it exists', function(assert) {
+  let route = this.subject();
+  assert.ok(route);
+});

tests/unit/routes/reconstruction-test.js

+import { moduleFor, test } from 'ember-qunit';
+
+moduleFor('route:reconstruction', 'Unit | Route | reconstruction', {
+  // Specify the other units that are required for this test.
+  // needs: ['controller:foo']
+});
+
+test('it exists', function(assert) {
+  let route = this.subject();
+  assert.ok(route);
+});