diff --git a/apps/Launcher/mainwindow.h b/apps/Launcher/mainwindow.h
index e3360b1c23..9b9d9bd10e 100644
--- a/apps/Launcher/mainwindow.h
+++ b/apps/Launcher/mainwindow.h
@@ -79,8 +79,8 @@ private:
 //class MainWindow : public QWidget {
 //Q_OBJECT
 //public:
-//	MainWindow();
-//	~MainWindow();
+//    MainWindow();
+//    ~MainWindow();
 //
 //    std::string nextTarget() const;
 //
@@ -94,7 +94,7 @@ private:
 //    void onSocketConnected();
 //    void onSocketDisconnected();
 //
-//	void readTcpData();
+//    void readTcpData();
 //    void handleStatusMessage(QByteArray data);
 //    void handlePlaybook(QByteArray data);
 //
@@ -106,7 +106,7 @@ private:
 //    InformationWidget* _informationWidget;
 //    TimelineWidget* _timelineWidget;
 //    
-//	QTcpSocket* _socket;
+//    QTcpSocket* _socket;
 //
 //    bool _hasHongKangTimeline = false;
 //    bool _hasLabelTimeline = false;
diff --git a/apps/OpenSpace/main.cpp b/apps/OpenSpace/main.cpp
index 0eba15f18b..d43be6508b 100644
--- a/apps/OpenSpace/main.cpp
+++ b/apps/OpenSpace/main.cpp
@@ -183,7 +183,7 @@ int main(int argc, char** argv) {
 }
 
 void mainInitFunc() {
-    //is this node the master?	(must be set after call to _sgctEngine->init())
+    //is this node the master?    (must be set after call to _sgctEngine->init())
     OsEng.setMaster(_sgctEngine->isMaster());
     
     bool success = OsEng.initialize();
diff --git a/apps/TimelineView/configurationwidget.h b/apps/TimelineView/configurationwidget.h
index 3beca827f7..1f7ff034c2 100644
--- a/apps/TimelineView/configurationwidget.h
+++ b/apps/TimelineView/configurationwidget.h
@@ -32,7 +32,7 @@
 class ConfigurationWidget : public QWidget {
 Q_OBJECT
 public:
-	ConfigurationWidget(QWidget* parent);
+    ConfigurationWidget(QWidget* parent);
 
     void socketConnected();
     void socketDisconnected();
diff --git a/apps/TimelineView/controlwidget.h b/apps/TimelineView/controlwidget.h
index 8ae2f11fd8..5c6e99e5df 100644
--- a/apps/TimelineView/controlwidget.h
+++ b/apps/TimelineView/controlwidget.h
@@ -35,7 +35,7 @@ class QSlider;
 class ControlWidget : public QWidget {
 Q_OBJECT
 public:
-	ControlWidget(QWidget* parent);
+    ControlWidget(QWidget* parent);
 
     void update(QString currentTime, QString currentDelta);
 
diff --git a/apps/TimelineView/informationwidget.h b/apps/TimelineView/informationwidget.h
index c1a657ee20..811151a415 100644
--- a/apps/TimelineView/informationwidget.h
+++ b/apps/TimelineView/informationwidget.h
@@ -30,7 +30,7 @@
 class InformationWidget : public QTextEdit {
 Q_OBJECT
 public:
-	InformationWidget(QWidget* parent);
+    InformationWidget(QWidget* parent);
     void socketConnected();
     void socketDisconnected();
 
diff --git a/apps/TimelineView/main.cpp b/apps/TimelineView/main.cpp
index 463578f67e..f9bd72520c 100644
--- a/apps/TimelineView/main.cpp
+++ b/apps/TimelineView/main.cpp
@@ -28,15 +28,15 @@
 
 static const QString style = R"style(
 QWidget {
-	background-color: rgb(80, 80, 80);
-	font-family: Helvetica;
+    background-color: rgb(80, 80, 80);
+    font-family: Helvetica;
 }
 
 QGroupBox {
     background-color: qlineargradient(
-    	x1: 0, y1: 0, x2: 0, y2: 1,
-    	stop: 0 #858585,
-    	stop: 1 #959595);
+        x1: 0, y1: 0, x2: 0, y2: 1,
+        stop: 0 #858585,
+        stop: 1 #959595);
     border: 2px solid gray;
     border-radius: 5px;
     margin-top: 4ex;
@@ -44,7 +44,7 @@ QGroupBox {
 }
 
 QGroupBox::title {
-	background-color: #E0E0E0;
+    background-color: #E0E0E0;
     border: 2px solid gray;
     border-radius: 5px;
     subcontrol-origin: margin;
@@ -60,10 +60,10 @@ QSlider::groove:horizontal {
     border: 1px solid #999999;
     height: 8px; /* the groove expands to the size of the slider by default. by giving it a height, it has a fixed size */
     background: qlineargradient(
-    	x1:0, y1:0, x2:1, y2:0,
-    	stop:0 #c4c4c4,
-    	stop:0.5 #555555,
-    	stop:1 #c4c4c4
+        x1:0, y1:0, x2:1, y2:0,
+        stop:0 #c4c4c4,
+        stop:0.5 #555555,
+        stop:1 #c4c4c4
     );
     margin: 2px 0;
 }
@@ -77,7 +77,7 @@ QSlider::handle:horizontal {
 }
 
 QPushButton {
-	background-color: lightgray;
+    background-color: lightgray;
     border-style: outset;
     border-width: 0.5px;
     border-radius: 5px;
@@ -87,16 +87,16 @@ QPushButton {
 }
 
 QPushButton#connection {
-	background-color: lightgreen;
+    background-color: lightgreen;
 }
 
 QPushButton#connection:pressed {
-	background-color: green;
+    background-color: green;
 }
 
 
 QPushButton#pause, QPushButton#play {
-	padding: 5px;
+    padding: 5px;
 }
 
 QPushButton#pause:pressed, QPushButton#play:pressed, QPushButton:pressed {
@@ -112,7 +112,7 @@ QCombobox {
 }
 
 QComboBox:editable {
-    background: lightgrey;	
+    background: lightgrey;    
 }
 
 QComboBox QAbstractItemView {
@@ -123,34 +123,34 @@ QComboBox QAbstractItemView {
 }
 
 QLabel#label {
-	font-size: 13px;
-	background-color: transparent;
-	font-variant: small-caps;
+    font-size: 13px;
+    background-color: transparent;
+    font-variant: small-caps;
 }
 
 QLabel#value {
-	font-family: monospace;
-	font-weight: bold;
-	font-size: 14px;
-	background-color: transparent;
+    font-family: monospace;
+    font-weight: bold;
+    font-size: 14px;
+    background-color: transparent;
 }
 
 QWidget#background {
-	background-color: transparent;
+    background-color: transparent;
 }
 
 QTextEdit {
-	font-family: monospace;
+    font-family: monospace;
 }
 )style";
 
 int main(int argc, char** argv) {
-	QApplication app(argc, argv);
+    QApplication app(argc, argv);
 
     app.setStyleSheet(style);
 
-	MainWindow window;
-	window.show();
+    MainWindow window;
+    window.show();
 
-	return app.exec();
+    return app.exec();
 }
diff --git a/apps/TimelineView/mainwindow.cpp b/apps/TimelineView/mainwindow.cpp
index 54bec61456..dc5e623e88 100644
--- a/apps/TimelineView/mainwindow.cpp
+++ b/apps/TimelineView/mainwindow.cpp
@@ -67,9 +67,9 @@ MainWindow::MainWindow()
     , _timeControlWidget(nullptr)
     , _informationWidget(nullptr)
     , _timelineWidget(nullptr)
-	, _socket(nullptr)
+    , _socket(nullptr)
 {
-	setWindowTitle("OpenSpace Timeline");
+    setWindowTitle("OpenSpace Timeline");
 
     _configurationWidget = new ConfigurationWidget(this);
     _configurationWidget->setMinimumWidth(350);
@@ -79,7 +79,7 @@ MainWindow::MainWindow()
     _informationWidget->setMinimumWidth(350);
     _timelineWidget = new TimelineWidget(this);
 
-	QGridLayout* layout = new QGridLayout;
+    QGridLayout* layout = new QGridLayout;
     layout->addWidget(_configurationWidget, 0, 0);
     layout->addWidget(_timeControlWidget, 1, 0);
     layout->addWidget(_informationWidget, 2, 0);
@@ -102,7 +102,7 @@ MainWindow::MainWindow()
         this, SLOT(sendScript(QString))
     );
 
-	setLayout(layout);
+    setLayout(layout);
 
     _configurationWidget->socketDisconnected();
     _timeControlWidget->socketDisconnected();
@@ -111,7 +111,7 @@ MainWindow::MainWindow()
 }
 
 MainWindow::~MainWindow() {
-	delete _socket;
+    delete _socket;
 }
 
 void MainWindow::onConnect(QString host, QString port) {
diff --git a/apps/TimelineView/mainwindow.h b/apps/TimelineView/mainwindow.h
index 126dc314cf..9c23cf8448 100644
--- a/apps/TimelineView/mainwindow.h
+++ b/apps/TimelineView/mainwindow.h
@@ -38,8 +38,8 @@ class TimelineWidget;
 class MainWindow : public QWidget {
 Q_OBJECT
 public:
-	MainWindow();
-	~MainWindow();
+    MainWindow();
+    ~MainWindow();
 
     std::string nextTarget() const;
 
@@ -53,7 +53,7 @@ private slots:
     void onSocketConnected();
     void onSocketDisconnected();
 
-	void readTcpData();
+    void readTcpData();
     void handleStatusMessage(QByteArray data);
     QByteArray handlePlaybook(QByteArray data);
     void printMapping(QByteArray data);
@@ -66,7 +66,7 @@ private:
     InformationWidget* _informationWidget;
     TimelineWidget* _timelineWidget;
     
-	QTcpSocket* _socket;
+    QTcpSocket* _socket;
 
     bool _isConnected = false;
 };
diff --git a/apps/TimelineView/timelinewidget.h b/apps/TimelineView/timelinewidget.h
index f0c9233a8a..be3a880d00 100644
--- a/apps/TimelineView/timelinewidget.h
+++ b/apps/TimelineView/timelinewidget.h
@@ -38,7 +38,7 @@ class QPaintEvent;
 class TimelineWidget : public QWidget {
 Q_OBJECT
 public:
-	TimelineWidget(QWidget* parent);
+    TimelineWidget(QWidget* parent);
 
     void setData(std::vector<Image> images, std::map<uint8_t, std::string> targetMap, std::map<uint16_t, std::string> instrumentMap);
     void setCurrentTime(std::string currentTime, double et);
diff --git a/ext/ghoul b/ext/ghoul
index a1556e0497..fb0ce7bfbd 160000
--- a/ext/ghoul
+++ b/ext/ghoul
@@ -1 +1 @@
-Subproject commit a1556e04976dc66225614a2435a6576e3ff6eecf
+Subproject commit fb0ce7bfbd859efa02beab4c84b62991a25d1666
diff --git a/include/openspace/engine/openspaceengine.h b/include/openspace/engine/openspaceengine.h
index f921b0ded9..891e8c795b 100644
--- a/include/openspace/engine/openspaceengine.h
+++ b/include/openspace/engine/openspaceengine.h
@@ -66,8 +66,8 @@ public:
     static bool isInitialized();
     static OpenSpaceEngine& ref();
 
-	bool isMaster();
-	void setMaster(bool master);
+    bool isMaster();
+    void setMaster(bool master);
     double runTime();
     void setRunTime(double t);
 
@@ -75,29 +75,29 @@ public:
     ConfigurationManager& configurationManager();
     interaction::InteractionHandler& interactionHandler();
     RenderEngine& renderEngine();
-	scripting::ScriptEngine& scriptEngine();
+    scripting::ScriptEngine& scriptEngine();
     NetworkEngine& networkEngine();
-	LuaConsole& console();
+    LuaConsole& console();
     ModuleEngine& moduleEngine();
     network::ParallelConnection& parallelConnection();
     properties::PropertyOwner& globalPropertyOwner();
     WindowWrapper& windowWrapper();
     ghoul::fontrendering::FontManager& fontManager();
-	gui::GUI& gui();
+    gui::GUI& gui();
 
     // SGCT callbacks
     bool initialize();
     bool initializeGL();
     void preSynchronization();
     void postSynchronizationPreDraw();
-	void render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix);
-	void postDraw();
+    void render(const glm::mat4& projectionMatrix, const glm::mat4& viewMatrix);
+    void postDraw();
     void keyboardCallback(Key key, KeyModifier mod, KeyAction action);
-	void charCallback(unsigned int codepoint, KeyModifier mod);
+    void charCallback(unsigned int codepoint, KeyModifier mod);
     void mouseButtonCallback(MouseButton button, MouseAction action);
     void mousePositionCallback(double x, double y);
     void mouseScrollWheelCallback(double pos);
-	void externalControlCallback(const char* receivedChars, int size, int clientId);
+    void externalControlCallback(const char* receivedChars, int size, int clientId);
     void encode();
     void decode();
 
@@ -110,22 +110,22 @@ private:
     OpenSpaceEngine(std::string programName, std::unique_ptr<WindowWrapper> windowWrapper);
     ~OpenSpaceEngine();
 
-	void clearAllWindows();
-	bool gatherCommandlineArguments();
-	bool loadSpiceKernels();
+    void clearAllWindows();
+    bool gatherCommandlineArguments();
+    bool loadSpiceKernels();
     void loadFonts();
     void runScripts(const ghoul::Dictionary& scripts);
     void runStartupScripts();
-	void configureLogging();
+    void configureLogging();
     
     // Components
     std::unique_ptr<ConfigurationManager> _configurationManager;
     std::unique_ptr<interaction::InteractionHandler> _interactionHandler;
     std::unique_ptr<RenderEngine> _renderEngine;
-	std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
+    std::unique_ptr<scripting::ScriptEngine> _scriptEngine;
     std::unique_ptr<NetworkEngine> _networkEngine;
-	std::unique_ptr<ghoul::cmdparser::CommandlineParser> _commandlineParser;
-	std::unique_ptr<LuaConsole> _console;
+    std::unique_ptr<ghoul::cmdparser::CommandlineParser> _commandlineParser;
+    std::unique_ptr<LuaConsole> _console;
     std::unique_ptr<ModuleEngine> _moduleEngine;
     std::unique_ptr<gui::GUI> _gui;
     std::unique_ptr<network::ParallelConnection> _parallelConnection;
@@ -136,7 +136,7 @@ private:
     std::unique_ptr<properties::PropertyOwner> _globalPropertyNamespace;
     std::unique_ptr<SyncBuffer> _syncBuffer;
     
-	bool _isMaster;
+    bool _isMaster;
     double _runTime;
 
     static OpenSpaceEngine* _engine;
diff --git a/include/openspace/engine/wrapper/windowwrapper.h b/include/openspace/engine/wrapper/windowwrapper.h
index 6a6ce64dd3..d20f5339db 100644
--- a/include/openspace/engine/wrapper/windowwrapper.h
+++ b/include/openspace/engine/wrapper/windowwrapper.h
@@ -116,7 +116,7 @@ public:
      */
     virtual int currentNumberOfAaSamples() const;
 
-	/**
+    /**
      * Returns <code>true</code> if the current rendering method is regular, i.e., it is
      * a flat projection without non-linear distortions. Returns <code>false</code> in
      * other cases, for example fisheye projections. On default, this method will return
diff --git a/include/openspace/interaction/controller.h b/include/openspace/interaction/controller.h
index a4349c248d..636b810ebe 100644
--- a/include/openspace/interaction/controller.h
+++ b/include/openspace/interaction/controller.h
@@ -37,14 +37,14 @@ class InteractionHandler;
 
 class Controller {
 public:
-	Controller() :
-		_handler(nullptr)
-	{}
+    Controller() :
+        _handler(nullptr)
+    {}
     
-	void setHandler(InteractionHandler* handler);
+    void setHandler(InteractionHandler* handler);
 
 protected:
-	InteractionHandler* _handler;
+    InteractionHandler* _handler;
 };
 
 } // namespace interaction
diff --git a/include/openspace/interaction/deviceidentifier.h b/include/openspace/interaction/deviceidentifier.h
index c2174ab204..0497699149 100644
--- a/include/openspace/interaction/deviceidentifier.h
+++ b/include/openspace/interaction/deviceidentifier.h
@@ -14,39 +14,39 @@ enum class InputDevice {NONE, UNKNOWN, SPACENAVIGATOR, XBOX};
 
 class DeviceIdentifier {
 public:
-	static DeviceIdentifier& ref();
-	virtual ~DeviceIdentifier();
+    static DeviceIdentifier& ref();
+    virtual ~DeviceIdentifier();
 
-	static void init();
-	static void deinit();
-	static bool isInitialized();
-	
-	void scanDevices();
-	const int numberOfDevices() const;
-	const InputDevice type(const int device) const;
-	
-	void update();
-	void update(const int device);
+    static void init();
+    static void deinit();
+    static bool isInitialized();
+    
+    void scanDevices();
+    const int numberOfDevices() const;
+    const InputDevice type(const int device) const;
+    
+    void update();
+    void update(const int device);
 
-	const int getButtons(const int device, unsigned char **buttons = nullptr) const;
-	const int getAxes(const int device, float **axespos = nullptr) const;
-	void get(const int device, unsigned char **buttons, float **axespos) const;
-	
+    const int getButtons(const int device, unsigned char **buttons = nullptr) const;
+    const int getAxes(const int device, float **axespos = nullptr) const;
+    void get(const int device, unsigned char **buttons, float **axespos) const;
+    
 private:
-	// singleton
-	static DeviceIdentifier* this_;
+    // singleton
+    static DeviceIdentifier* this_;
     DeviceIdentifier(void);
     DeviceIdentifier(const DeviceIdentifier& src);
     DeviceIdentifier& operator=(const DeviceIdentifier& rhs);
 
 
-	// member variables
-	int devices_;
-	std::array<InputDevice, MAXDEVICES> inputDevice_;
-	std::array<int, MAXDEVICES> numberOfAxes_;
-	std::array<int, MAXDEVICES> numberOfButtons_;
-	std::array<float *, MAXDEVICES> axesPos_;
-	std::array<unsigned char *, MAXDEVICES> buttons_;
+    // member variables
+    int devices_;
+    std::array<InputDevice, MAXDEVICES> inputDevice_;
+    std::array<int, MAXDEVICES> numberOfAxes_;
+    std::array<int, MAXDEVICES> numberOfButtons_;
+    std::array<float *, MAXDEVICES> axesPos_;
+    std::array<unsigned char *, MAXDEVICES> buttons_;
 
 };
 
diff --git a/include/openspace/interaction/externalcontrol/externalconnectioncontroller.h b/include/openspace/interaction/externalcontrol/externalconnectioncontroller.h
index 4d45937c59..09e952e10e 100644
--- a/include/openspace/interaction/externalcontrol/externalconnectioncontroller.h
+++ b/include/openspace/interaction/externalcontrol/externalconnectioncontroller.h
@@ -9,14 +9,14 @@ namespace openspace {
 class ExternalConnectionController: public ExternalControl {
 public:
 
-	// constructors & destructor
-	ExternalConnectionController();
-	~ExternalConnectionController();
-	
+    // constructors & destructor
+    ExternalConnectionController();
+    ~ExternalConnectionController();
+    
 private:
 
-	std::vector<ExternalControl*> controllers;
-	
+    std::vector<ExternalControl*> controllers;
+    
 };
 
 } // namespace openspace
diff --git a/include/openspace/interaction/externalcontrol/externalcontrol.h b/include/openspace/interaction/externalcontrol/externalcontrol.h
index 4e36ed9ce5..986749135b 100644
--- a/include/openspace/interaction/externalcontrol/externalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/externalcontrol.h
@@ -10,17 +10,17 @@ namespace openspace {
 class ExternalControl {
 public:
 
-	// constructors & destructor
-	ExternalControl();
-	virtual ~ExternalControl();
-	
-	virtual void update();
-	
-	void rotate(const glm::quat &rotation);
-	void orbit(const glm::quat &rotation);
-	void distance(const PowerScaledScalar &distance);
+    // constructors & destructor
+    ExternalControl();
+    virtual ~ExternalControl();
+    
+    virtual void update();
+    
+    void rotate(const glm::quat &rotation);
+    void orbit(const glm::quat &rotation);
+    void distance(const PowerScaledScalar &distance);
 
-	
+    
 protected:
 };
 
diff --git a/include/openspace/interaction/externalcontrol/joystickexternalcontrol.h b/include/openspace/interaction/externalcontrol/joystickexternalcontrol.h
index 9416c6b202..4182d3c102 100644
--- a/include/openspace/interaction/externalcontrol/joystickexternalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/joystickexternalcontrol.h
@@ -8,19 +8,19 @@
 //class JoystickExternalControl: public PythonExternalControl {
 //public:
 //
-//	// constructors & destructor
-//	JoystickExternalControl(const char *filename);
-//	~JoystickExternalControl();
-//	
-//	void setInputDevice(const int device);
-//	void update();
+//    // constructors & destructor
+//    JoystickExternalControl(const char *filename);
+//    ~JoystickExternalControl();
+//    
+//    void setInputDevice(const int device);
+//    void update();
 //
 //private:
 //
-//	// joystick
-//	int inputDevice_;
-//	int numberOfButtons_;
-//	int numberOfAxes_;
+//    // joystick
+//    int inputDevice_;
+//    int numberOfButtons_;
+//    int numberOfAxes_;
 //};
 //
 //} // namespace openspace
diff --git a/include/openspace/interaction/externalcontrol/keyboardexternalcontrol.h b/include/openspace/interaction/externalcontrol/keyboardexternalcontrol.h
index 6e331e69b8..9a01732944 100644
--- a/include/openspace/interaction/externalcontrol/keyboardexternalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/keyboardexternalcontrol.h
@@ -8,15 +8,15 @@
 //class KeyboardExternalControl: public PythonExternalControl {
 //public:
 //
-//	// constructors & destructor
-//	KeyboardExternalControl(const char *filename);
-//	~KeyboardExternalControl();
+//    // constructors & destructor
+//    KeyboardExternalControl(const char *filename);
+//    ~KeyboardExternalControl();
 //
-//	void update();
-//	
-//	void keyboardCallback(int key, int action);
+//    void update();
+//    
+//    void keyboardCallback(int key, int action);
 //private:
-//	int *keys_;
+//    int *keys_;
 //
 //};
 //
diff --git a/include/openspace/interaction/externalcontrol/mouseexternalcontrol.h b/include/openspace/interaction/externalcontrol/mouseexternalcontrol.h
index 890a741733..cbd5cec7d3 100644
--- a/include/openspace/interaction/externalcontrol/mouseexternalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/mouseexternalcontrol.h
@@ -8,18 +8,18 @@
 //class MouseExternalControl: public PythonExternalControl {
 //public:
 //
-//	// constructors & destructor
-//	MouseExternalControl(const char *filename);
-//	~MouseExternalControl();
+//    // constructors & destructor
+//    MouseExternalControl(const char *filename);
+//    ~MouseExternalControl();
 //
-//	void update();
-//	
-//	void mouseButtonCallback(int key, int action);
-//	void mousePosCallback(int x, int y);
-//	void mouseScrollCallback(int pos);
+//    void update();
+//    
+//    void mouseButtonCallback(int key, int action);
+//    void mousePosCallback(int x, int y);
+//    void mouseScrollCallback(int pos);
 //private:
 //
-//	int x_, y_, pos_, button1_, button2_, button3_;
+//    int x_, y_, pos_, button1_, button2_, button3_;
 //
 //};
 //
diff --git a/include/openspace/interaction/externalcontrol/pythonexternalcontrol.h b/include/openspace/interaction/externalcontrol/pythonexternalcontrol.h
index 8a01d6f571..432f1c6d9a 100644
--- a/include/openspace/interaction/externalcontrol/pythonexternalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/pythonexternalcontrol.h
@@ -12,22 +12,22 @@
 //class PythonExternalControl: public ExternalControl {
 //public:
 //
-//	// constructors & destructor
-//	PythonExternalControl(const char *filename);
-//	~PythonExternalControl();
+//    // constructors & destructor
+//    PythonExternalControl(const char *filename);
+//    ~PythonExternalControl();
 //
-//	static PyMethodDef* getMethodDef();
-//	
-//	void message(const char *text);
-//	virtual void update();
-//	void clear();
+//    static PyMethodDef* getMethodDef();
+//    
+//    void message(const char *text);
+//    virtual void update();
+//    void clear();
 //private:
-//	PythonScript ps_;
+//    PythonScript ps_;
 //
 //protected:
-//	void run();
-//	int pyarrSize_;
-//	PyObject **pyarr_;
+//    void run();
+//    int pyarrSize_;
+//    PyObject **pyarr_;
 //};
 //
 //} // namespace openspace
diff --git a/include/openspace/interaction/externalcontrol/randomexternalcontrol.h b/include/openspace/interaction/externalcontrol/randomexternalcontrol.h
index 2cc189f4c5..171ab2c79a 100644
--- a/include/openspace/interaction/externalcontrol/randomexternalcontrol.h
+++ b/include/openspace/interaction/externalcontrol/randomexternalcontrol.h
@@ -11,14 +11,14 @@ namespace openspace {
 class RandomExternalControl: public ExternalControl {
 public:
 
-	// constructors & destructor
-	RandomExternalControl();
-	~RandomExternalControl();
-	
+    // constructors & destructor
+    RandomExternalControl();
+    ~RandomExternalControl();
+    
 private:
-	std::mutex inputGuard;
-	bool *keepGoing_;
-    //	std::thread *backgroundThread;
+    std::mutex inputGuard;
+    bool *keepGoing_;
+    //    std::thread *backgroundThread;
 };
 
 } // namespace openspace
diff --git a/include/openspace/interaction/keyboardcontroller.h b/include/openspace/interaction/keyboardcontroller.h
index d739d9b802..94550e2869 100644
--- a/include/openspace/interaction/keyboardcontroller.h
+++ b/include/openspace/interaction/keyboardcontroller.h
@@ -35,20 +35,20 @@ namespace interaction {
 class KeyboardController : public Controller {
 public:
     virtual ~KeyboardController() {};
-	virtual void keyPressed(KeyAction action, Key key, KeyModifier modifier) = 0;
+    virtual void keyPressed(KeyAction action, Key key, KeyModifier modifier) = 0;
 };
 
 class KeyboardControllerFixed : public KeyboardController {
 public:
-	void keyPressed(KeyAction action, Key key, KeyModifier modifier);
+    void keyPressed(KeyAction action, Key key, KeyModifier modifier);
 };
 
 class KeyboardControllerLua : public KeyboardController {
 public:
-	void keyPressed(KeyAction action, Key key, KeyModifier modifier);
+    void keyPressed(KeyAction action, Key key, KeyModifier modifier);
 
 protected:
-	std::string keyToString(Key key, KeyModifier mod) const;
+    std::string keyToString(Key key, KeyModifier mod) const;
 };
 
 } // namespace interaction
diff --git a/include/openspace/interaction/luaconsole.h b/include/openspace/interaction/luaconsole.h
index 547fe09c1e..d3e6aed595 100644
--- a/include/openspace/interaction/luaconsole.h
+++ b/include/openspace/interaction/luaconsole.h
@@ -36,35 +36,35 @@ namespace openspace {
 
 class LuaConsole {
 public:
-	LuaConsole();
+    LuaConsole();
 
     void initialize();
     void deinitialize();
 
-	void keyboardCallback(Key key, KeyModifier modifier, KeyAction action);
+    void keyboardCallback(Key key, KeyModifier modifier, KeyAction action);
     void charCallback(unsigned int codepoint, KeyModifier modifier);
 
-	void render();
+    void render();
 
     Key commandInputButton();
 
-	bool isVisible() const;
-	void setVisible(bool visible);
-	void toggleVisibility();
-		
-	static scripting::ScriptEngine::LuaLibrary luaLibrary();
+    bool isVisible() const;
+    void setVisible(bool visible);
+    void toggleVisibility();
+        
+    static scripting::ScriptEngine::LuaLibrary luaLibrary();
 
 
 private:
     void addToCommand(std::string c);
-	std::string UnicodeToUTF8(unsigned int codepoint);
+    std::string UnicodeToUTF8(unsigned int codepoint);
 
-	size_t _inputPosition;
-	std::vector<std::string> _commandsHistory;
-	size_t _activeCommand;
-	std::vector<std::string> _commands;
+    size_t _inputPosition;
+    std::vector<std::string> _commandsHistory;
+    size_t _activeCommand;
+    std::vector<std::string> _commands;
 
-	std::string _filename;
+    std::string _filename;
 
     struct {
         int lastIndex;
@@ -72,7 +72,7 @@ private:
         std::string initialValue;
     } _autoCompleteInfo;
 
-	bool _isVisible;
+    bool _isVisible;
 };
 
 } // namespace openspace
diff --git a/include/openspace/interaction/mousecontroller.h b/include/openspace/interaction/mousecontroller.h
index bc247ec384..6df5c53165 100644
--- a/include/openspace/interaction/mousecontroller.h
+++ b/include/openspace/interaction/mousecontroller.h
@@ -36,66 +36,66 @@ namespace interaction {
 
 class MouseController : public Controller {
 public:
-	MouseController();
+    MouseController();
     virtual ~MouseController() {}
 
-	virtual void button(MouseButton button, MouseAction action) = 0;
-	virtual void move(float x, float y) = 0;
-	virtual void scrollWheel(int pos) = 0;
-	virtual void update(const double& dt) = 0;
+    virtual void button(MouseButton button, MouseAction action) = 0;
+    virtual void move(float x, float y) = 0;
+    virtual void scrollWheel(int pos) = 0;
+    virtual void update(const double& dt) = 0;
 
 protected:
-	glm::vec3 _lastTrackballPos;
-	bool _isMouseBeingPressedAndHeld;
+    glm::vec3 _lastTrackballPos;
+    bool _isMouseBeingPressedAndHeld;
 
-	glm::vec3 mapToTrackball(glm::vec2 mousePos);
+    glm::vec3 mapToTrackball(glm::vec2 mousePos);
 
-	glm::vec3 mapToCamera(glm::vec3 trackballPos);
+    glm::vec3 mapToCamera(glm::vec3 trackballPos);
 
-	void trackballRotate(int x, int y);
+    void trackballRotate(int x, int y);
 };
 
 class TrackballMouseController : public MouseController {
 public:
-	TrackballMouseController();
+    TrackballMouseController();
 
-	void button(MouseButton button, MouseAction action) override;
+    void button(MouseButton button, MouseAction action) override;
 
-	void move(float x, float y) override;
+    void move(float x, float y) override;
 
-	void scrollWheel(int pos) override;
+    void scrollWheel(int pos) override;
 
-	void update(const double& dt) override;
+    void update(const double& dt) override;
 
 protected:
-	bool _leftMouseButtonDown;
-	glm::vec3 _previousTrackballPos;
+    bool _leftMouseButtonDown;
+    glm::vec3 _previousTrackballPos;
 };
 
 class OrbitalMouseController : public MouseController {
 public:
-	OrbitalMouseController();
+    OrbitalMouseController();
 
-	void button(MouseButton button, MouseAction action) override;
+    void button(MouseButton button, MouseAction action) override;
 
-	void move(float x, float y) override;
+    void move(float x, float y) override;
 
-	void scrollWheel(int pos) override;
+    void scrollWheel(int pos) override;
 
-	void update(const double& dt) override;
+    void update(const double& dt) override;
 
 protected:
-	bool _leftMouseButtonDown;
-	bool _rightMouseButtonDown;
-	bool _middleMouseButtonDown;
-	glm::vec2 _previousCursorPos[3];
-	glm::vec2 _currentCursorPos;
-	glm::vec2 _currentCursorDiff[3];
-	float _rotationSpeed;
-	float _navigationSpeed;
+    bool _leftMouseButtonDown;
+    bool _rightMouseButtonDown;
+    bool _middleMouseButtonDown;
+    glm::vec2 _previousCursorPos[3];
+    glm::vec2 _currentCursorPos;
+    glm::vec2 _currentCursorDiff[3];
+    float _rotationSpeed;
+    float _navigationSpeed;
 
 private:
-	enum MouseButtons{ ButtonLeft = 0, ButtonRight, ButtonMiddle };
+    enum MouseButtons{ ButtonLeft = 0, ButtonRight, ButtonMiddle };
 };
 
 } // namespace interaction
diff --git a/include/openspace/network/parallelconnection.h b/include/openspace/network/parallelconnection.h
index b4187c1c5b..caa9b3bdfb 100644
--- a/include/openspace/network/parallelconnection.h
+++ b/include/openspace/network/parallelconnection.h
@@ -82,7 +82,7 @@ namespace openspace{
             
             void requestHostship(const std::string &password);
 
-			void setPassword(const std::string &password);
+            void setPassword(const std::string &password);
             
             void signalDisconnect();
             
@@ -113,23 +113,23 @@ namespace openspace{
         protected:
             
         private:
-			//@TODO change this into the ghoul hasher for client AND server
-			uint32_t hash(const std::string &val){
-				uint32_t hashVal = 0, i;
-				size_t len = val.length();
+            //@TODO change this into the ghoul hasher for client AND server
+            uint32_t hash(const std::string &val){
+                uint32_t hashVal = 0, i;
+                size_t len = val.length();
 
-				for (hashVal = i = 0; i < len; ++i){
-					hashVal += val.c_str()[i];
-					hashVal += (hashVal << 10);
-					hashVal ^= (hashVal >> 6);
-				}
+                for (hashVal = i = 0; i < len; ++i){
+                    hashVal += val.c_str()[i];
+                    hashVal += (hashVal << 10);
+                    hashVal ^= (hashVal >> 6);
+                }
 
-				hashVal += (hashVal << 3);
-				hashVal ^= (hashVal >> 11);
-				hashVal += (hashVal << 15);
+                hashVal += (hashVal << 3);
+                hashVal ^= (hashVal >> 11);
+                hashVal += (hashVal << 15);
 
-				return hashVal;
-			};
+                return hashVal;
+            };
             
             void queueMessage(std::vector<char> message);
             
@@ -137,27 +137,27 @@ namespace openspace{
             
             void writeHeader(std::vector<char> &buffer, uint32_t messageType);
 
-			void closeSocket();
+            void closeSocket();
 
-			bool initNetworkAPI();
+            bool initNetworkAPI();
 
-			void establishConnection(addrinfo *info);
+            void establishConnection(addrinfo *info);
 
-			void sendAuthentication();
+            void sendAuthentication();
 
-			void listenCommunication();
+            void listenCommunication();
 
-			void delegateDecoding(uint32_t type);
+            void delegateDecoding(uint32_t type);
 
-			void initializationMessageReceived();
+            void initializationMessageReceived();
 
-			void dataMessageReceived();
+            void dataMessageReceived();
 
-			void hostInfoMessageReceived();
-			
-			void initializationRequestMessageReceived();
+            void hostInfoMessageReceived();
+            
+            void initializationRequestMessageReceived();
 
-			void broadcast();
+            void broadcast();
             
             int headerSize();
 
@@ -171,15 +171,15 @@ namespace openspace{
             
             std::string scriptFromPropertyAndValue(const std::string property, const std::string value);
             
-			uint32_t _passCode;
+            uint32_t _passCode;
             std::string _port;
             std::string _address;
             std::string _name;
             _SOCKET _clientSocket;
             std::thread *_connectionThread;
-			std::thread *_broadcastThread;
+            std::thread *_broadcastThread;
             std::thread *_sendThread;
-			std::thread *_listenThread;
+            std::thread *_listenThread;
             std::thread *_handlerThread;
             std::atomic<bool> _isHost;
             std::atomic<bool> _isConnected;
diff --git a/include/openspace/properties/numericalproperty.h b/include/openspace/properties/numericalproperty.h
index 09cf92b517..33a179b7fd 100644
--- a/include/openspace/properties/numericalproperty.h
+++ b/include/openspace/properties/numericalproperty.h
@@ -35,35 +35,35 @@ class NumericalProperty : public TemplateProperty<T> {
 public:
     NumericalProperty(std::string identifier, std::string guiName);
     NumericalProperty(std::string identifier, std::string guiName, T value);
-	NumericalProperty(std::string identifier, std::string guiName, T value,
-		T minimumValue, T maximumValue);
+    NumericalProperty(std::string identifier, std::string guiName, T value,
+        T minimumValue, T maximumValue);
     NumericalProperty(std::string identifier, std::string guiName, T value,
         T minimumValue, T maximumValue, T steppingValue);
 
-	bool getLuaValue(lua_State* state) const override;
-	bool setLuaValue(lua_State* state) override;
-	int typeLua() const override;
+    bool getLuaValue(lua_State* state) const override;
+    bool setLuaValue(lua_State* state) override;
+    int typeLua() const override;
 
     bool getStringValue(std::string& value) const override;
     bool setStringValue(std::string value) override;
 
-	T minValue() const;
-	T maxValue() const;
+    T minValue() const;
+    T maxValue() const;
 
     virtual std::string className() const override;
 
     using TemplateProperty<T>::operator=;
 
 protected:
-	static const std::string MinimumValueKey;
-	static const std::string MaximumValueKey;
-	static const std::string SteppingValueKey;
+    static const std::string MinimumValueKey;
+    static const std::string MaximumValueKey;
+    static const std::string SteppingValueKey;
 
-	std::string generateAdditionalDescription() const;
+    std::string generateAdditionalDescription() const;
 
     T _minimumValue;
     T _maximumValue;
-	T _stepping;
+    T _stepping;
 };
 
 } // namespace properties
diff --git a/include/openspace/properties/numericalproperty.inl b/include/openspace/properties/numericalproperty.inl
index ef3f686d53..5366f2d6fd 100644
--- a/include/openspace/properties/numericalproperty.inl
+++ b/include/openspace/properties/numericalproperty.inl
@@ -48,9 +48,9 @@ namespace properties {
     template <>                                                                          \
     TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultMaximumValue<TYPE>();         \
                                                                                          \
-	template <>																		     \
-	template <>																			 \
-	TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultSteppingValue<TYPE>();		 \
+    template <>                                                                             \
+    template <>                                                                             \
+    TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultSteppingValue<TYPE>();         \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
@@ -104,41 +104,41 @@ namespace properties {
     std::string PropertyDelegate<TemplateProperty<TYPE>>::className()                    \
     {                                                                                    \
         return #CLASS_NAME;                                                              \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     std::string PropertyDelegate<NumericalProperty<TYPE>>::className()                   \
     {                                                                                    \
         return PropertyDelegate<TemplateProperty<TYPE>>::className();                    \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
     TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultValue<TYPE>()                 \
     {                                                                                    \
         return DEFAULT_VALUE;                                                            \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
     TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultMinimumValue<TYPE>()          \
     {                                                                                    \
         return DEFAULT_MIN_VALUE;                                                        \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
     TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultMaximumValue<TYPE>()          \
     {                                                                                    \
         return DEFAULT_MAX_VALUE;                                                        \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
-	template <>																		     \
-	template <>																			 \
-	TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultSteppingValue<TYPE>()		 \
-	{ 																					 \
-		return DEFAULT_STEPPING;														 \
-	}																					 \
+    template <>                                                                             \
+    template <>                                                                             \
+    TYPE PropertyDelegate<NumericalProperty<TYPE>>::defaultSteppingValue<TYPE>()         \
+    {                                                                                      \
+        return DEFAULT_STEPPING;                                                         \
+    }                                                                                     \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
@@ -146,7 +146,7 @@ namespace properties {
                                                                       bool& success)     \
     {                                                                                    \
         return FROM_LUA_LAMBDA_EXPRESSION(state, success);                               \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
@@ -155,7 +155,7 @@ namespace properties {
     {                                                                                    \
         return PropertyDelegate<TemplateProperty<TYPE>>::fromLuaValue<TYPE>(state,       \
                                                                             success);    \
-	}                                                                                    \
+    }                                                                                    \
                                                                                          \
     template <>                                                                          \
     template <>                                                                          \
@@ -235,33 +235,33 @@ const std::string NumericalProperty<T>::SteppingValueKey = "SteppingValue";
 template <typename T>
 NumericalProperty<T>::NumericalProperty(std::string identifier, std::string guiName)
     : NumericalProperty<T>(
-		std::move(identifier), std::move(guiName),
-		PropertyDelegate<NumericalProperty<T>>::template defaultValue<T>(),
-		PropertyDelegate<NumericalProperty<T>>::template defaultMinimumValue<T>(),
-		PropertyDelegate<NumericalProperty<T>>::template defaultMaximumValue<T>(),
-		PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
-	)
+        std::move(identifier), std::move(guiName),
+        PropertyDelegate<NumericalProperty<T>>::template defaultValue<T>(),
+        PropertyDelegate<NumericalProperty<T>>::template defaultMinimumValue<T>(),
+        PropertyDelegate<NumericalProperty<T>>::template defaultMaximumValue<T>(),
+        PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
+    )
 {}
 
 template <typename T>
 NumericalProperty<T>::NumericalProperty(std::string identifier,
                                         std::string guiName, T value)
     : NumericalProperty<T>(
-		std::move(identifier), std::move(guiName), std::move(value),
-		PropertyDelegate<NumericalProperty<T>>::template defaultMinimumValue<T>(),
-		PropertyDelegate<NumericalProperty<T>>::template defaultMaximumValue<T>(),
-		PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
-	)
+        std::move(identifier), std::move(guiName), std::move(value),
+        PropertyDelegate<NumericalProperty<T>>::template defaultMinimumValue<T>(),
+        PropertyDelegate<NumericalProperty<T>>::template defaultMaximumValue<T>(),
+        PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
+    )
 {}
 
 template <typename T>
 NumericalProperty<T>::NumericalProperty(std::string identifier, std::string guiName,
-										T value, T minimumValue, T maximumValue)
-	: NumericalProperty<T>(
-		std::move(identifier) , std::move(guiName), std::move(value),
-		std::move(minimumValue), std::move(maximumValue),
-		PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
-	)
+                                        T value, T minimumValue, T maximumValue)
+    : NumericalProperty<T>(
+        std::move(identifier) , std::move(guiName), std::move(value),
+        std::move(minimumValue), std::move(maximumValue),
+        PropertyDelegate<NumericalProperty<T>>::template defaultSteppingValue<T>()
+    )
 {}
 
 template <typename T>
@@ -271,7 +271,7 @@ NumericalProperty<T>::NumericalProperty(std::string identifier,
     : TemplateProperty<T>(std::move(identifier), std::move(guiName), std::move(value))
     , _minimumValue(std::move(minimumValue))
     , _maximumValue(std::move(maximumValue))
-	, _stepping(std::move(steppingValue))
+    , _stepping(std::move(steppingValue))
 {}
 
 template <typename T>
@@ -282,23 +282,23 @@ std::string NumericalProperty<T>::className() const {
 template <typename T>
 bool NumericalProperty<T>::setLuaValue(lua_State* state)
 {
-	bool success = false;
-	T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(state, success);
-	if (success)
-		TemplateProperty<T>::setValue(value);
-	return success;
+    bool success = false;
+    T value = PropertyDelegate<NumericalProperty<T>>::template fromLuaValue<T>(state, success);
+    if (success)
+        TemplateProperty<T>::setValue(value);
+    return success;
 }
 
 template <typename T>
 bool NumericalProperty<T>::getLuaValue(lua_State* state) const
 {
-	bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(state, TemplateProperty<T>::_value);
-	return success;
+    bool success = PropertyDelegate<NumericalProperty<T>>::template toLuaValue<T>(state, TemplateProperty<T>::_value);
+    return success;
 }
 
 template <typename T>
 int NumericalProperty<T>::typeLua() const {
-	return PropertyDelegate<NumericalProperty<T>>::typeLua();
+    return PropertyDelegate<NumericalProperty<T>>::typeLua();
 }
 
 template <typename T>
@@ -318,21 +318,21 @@ bool NumericalProperty<T>::setStringValue(std::string value) {
 
 template <typename T>
 T NumericalProperty<T>::minValue() const {
-	return _minimumValue;
+    return _minimumValue;
 }
 
 template <typename T>
 T NumericalProperty<T>::maxValue() const {
-	return _maximumValue;
+    return _maximumValue;
 }
 
 template <typename T>
 std::string NumericalProperty<T>::generateAdditionalDescription() const {
-	std::string result;
-	result += MinimumValueKey  + " = " + std::to_string(_minimumValue) + ",";
-	result += MaximumValueKey  + " = " + std::to_string(_maximumValue) + ",";
-	result += SteppingValueKey + " = " + std::to_string(_stepping);
-	return result;
+    std::string result;
+    result += MinimumValueKey  + " = " + std::to_string(_minimumValue) + ",";
+    result += MaximumValueKey  + " = " + std::to_string(_maximumValue) + ",";
+    result += SteppingValueKey + " = " + std::to_string(_stepping);
+    return result;
 }
 
 } // namespace properties
diff --git a/include/openspace/properties/optionproperty.h b/include/openspace/properties/optionproperty.h
index ef9a3f9f2e..cd248fe336 100644
--- a/include/openspace/properties/optionproperty.h
+++ b/include/openspace/properties/optionproperty.h
@@ -41,58 +41,58 @@ namespace properties {
  */
 class OptionProperty : public IntProperty {
 public:
-	/**
-	 * The struct storing a single option consisting of an integer <code>value</code> and
-	 * a <code>string</code> description.
-	 */
-	struct Option {
-		int value;
-		std::string description;
-	};
+    /**
+     * The struct storing a single option consisting of an integer <code>value</code> and
+     * a <code>string</code> description.
+     */
+    struct Option {
+        int value;
+        std::string description;
+    };
 
-	/**
-	 * The constructor delegating the <code>identifier</code> and the <code>guiName</code>
-	 * to its super class.
-	 * \param identifier A unique identifier for this property
-	 * \param guiName The GUI name that should be used to represent this property
-	 */
-	OptionProperty(std::string identifier, std::string guiName);
+    /**
+     * The constructor delegating the <code>identifier</code> and the <code>guiName</code>
+     * to its super class.
+     * \param identifier A unique identifier for this property
+     * \param guiName The GUI name that should be used to represent this property
+     */
+    OptionProperty(std::string identifier, std::string guiName);
 
-	/**
-	 * Returns the name of the class for reflection purposes.
-	 * \return The name of this class for reflection purposes
-	 */
-	std::string className() const override;
-	using IntProperty::operator=;
+    /**
+     * Returns the name of the class for reflection purposes.
+     * \return The name of this class for reflection purposes
+     */
+    std::string className() const override;
+    using IntProperty::operator=;
 
-	/**
-	 * Adds the passed option to the list of available options. The <code>value</code> of
-	 * the <code>option</code> must not have been registered previously, or a warning will
-	 * be logged.
-	 * \param value The option that will be added to the list of available options
+    /**
+     * Adds the passed option to the list of available options. The <code>value</code> of
+     * the <code>option</code> must not have been registered previously, or a warning will
+     * be logged.
+     * \param value The option that will be added to the list of available options
      * \param desc The description of the value that will be added
-	 */
-	void addOption(int value, std::string desc);
+     */
+    void addOption(int value, std::string desc);
 
-	/**
-	 * Returns the list of available options.
-	 * /return The list of available options
-	 */
-	const std::vector<Option>& options() const;
+    /**
+     * Returns the list of available options.
+     * /return The list of available options
+     */
+    const std::vector<Option>& options() const;
 
-	/**
-	 * The overritten TemplateProperty::setValue method that checks if the provided value
-	 * represents a valid Option
-	 * \param value The value of the Option that should be set
-	 */
-	void setValue(int value) override;
+    /**
+     * The overritten TemplateProperty::setValue method that checks if the provided value
+     * represents a valid Option
+     * \param value The value of the Option that should be set
+     */
+    void setValue(int value) override;
 
 private:
-	static const std::string OptionsKey;
-	std::string generateAdditionalDescription() const;
+    static const std::string OptionsKey;
+    std::string generateAdditionalDescription() const;
 
-	/// The list of options which have been registered with this OptionProperty
-	std::vector<Option> _options;
+    /// The list of options which have been registered with this OptionProperty
+    std::vector<Option> _options;
 };
 
 } // namespace properties
diff --git a/include/openspace/properties/property.h b/include/openspace/properties/property.h
index 3c5f40e5c9..900eb81dac 100644
--- a/include/openspace/properties/property.h
+++ b/include/openspace/properties/property.h
@@ -62,239 +62,239 @@ class PropertyOwner;
  */
 class Property {
 public:
-	/**
-	 * The constructor for the property. The <code>identifier</code> needs to be unique
-	 * for each PropertyOwner. The <code>guiName</code> will be stored in the metaData
-	 * to be accessed by the GUI elements using the <code>guiName</code> key. The default
-	 * visibility settings is <code>true</code>, whereas the default read-only state is
-	 * <code>false</code>.
-	 * \param identifier A unique identifier for this property. It has to be unique to the
-	 * PropertyOwner and cannot contain any <code>.</code>s
-	 * \param guiName The human-readable GUI name for this Property
-	 */
+    /**
+     * The constructor for the property. The <code>identifier</code> needs to be unique
+     * for each PropertyOwner. The <code>guiName</code> will be stored in the metaData
+     * to be accessed by the GUI elements using the <code>guiName</code> key. The default
+     * visibility settings is <code>true</code>, whereas the default read-only state is
+     * <code>false</code>.
+     * \param identifier A unique identifier for this property. It has to be unique to the
+     * PropertyOwner and cannot contain any <code>.</code>s
+     * \param guiName The human-readable GUI name for this Property
+     */
     Property(std::string identifier, std::string guiName);
 
-	/**
-	 * The destructor taking care of deallocating all unused memory. This method will not
-	 * remove the Property from the PropertyOwner.
-	 */
+    /**
+     * The destructor taking care of deallocating all unused memory. This method will not
+     * remove the Property from the PropertyOwner.
+     */
     virtual ~Property();
 
-	/**
-	 * This method returns the class name of the Property. The method is used by the
-	 * TemplateFactory to create new instances of Propertys. The returned value is almost
-	 * always identical to the C++ class name of the derived class.
-	 * \return The class name of the Property
-	 */
+    /**
+     * This method returns the class name of the Property. The method is used by the
+     * TemplateFactory to create new instances of Propertys. The returned value is almost
+     * always identical to the C++ class name of the derived class.
+     * \return The class name of the Property
+     */
     virtual std::string className() const = 0;
 
-	/**
-	 * This method returns the encapsulated value of the Property to the caller. The type
-	 * that is returned is determined by the type function and is up to the developer of
-	 * the derived class. The default implementation returns an empty ghoul::any object.
-	 * \return The value that is encapsulated by this Property, or an empty ghoul::any
-	 * object if the method was not overritten.
-	 */
+    /**
+     * This method returns the encapsulated value of the Property to the caller. The type
+     * that is returned is determined by the type function and is up to the developer of
+     * the derived class. The default implementation returns an empty ghoul::any object.
+     * \return The value that is encapsulated by this Property, or an empty ghoul::any
+     * object if the method was not overritten.
+     */
     virtual ghoul::any get() const;
 
-	/**
-	 * Sets the value encapsulated by this Property to the <code>value</code> passed to
-	 * this function. It is the caller's responsibility to ensure that the type contained
-	 * in <code>value</code> is compatible with the concrete subclass of the Property. The
-	 * method Property::type will return the desired type for the Property. The default
-	 * implementation of this method ignores the input.
-	 * \param value The new value that should be stored in this Property
-	 */
+    /**
+     * Sets the value encapsulated by this Property to the <code>value</code> passed to
+     * this function. It is the caller's responsibility to ensure that the type contained
+     * in <code>value</code> is compatible with the concrete subclass of the Property. The
+     * method Property::type will return the desired type for the Property. The default
+     * implementation of this method ignores the input.
+     * \param value The new value that should be stored in this Property
+     */
     virtual void set(ghoul::any value);
 
-	/**
-	 * This method returns the type that is requested by this Property for the set method.
-	 * The default implementation returns the type of <code>void</code>.
-	 * \return The type that is requested by this Property's Property::set method
-	 */
+    /**
+     * This method returns the type that is requested by this Property for the set method.
+     * The default implementation returns the type of <code>void</code>.
+     * \return The type that is requested by this Property's Property::set method
+     */
     virtual const std::type_info& type() const;
-	
-	/**
-	 * This method encodes the encapsulated value of this Property at the top of the Lua
-	 * stack. The specific details of this serialization is up to the property developer
-	 * as long as the rest of the stack is unchanged. The implementation has to be
-	 * synchronized with the Property::setLuaValue method. The default implementation is a
-	 * no-op.
-	 * \param state The Lua state to which the value will be encoded
-	 * \return <code>true</code> if the encoding succeeded, <code>false</code> otherwise
-	 */
-	virtual bool getLuaValue(lua_State* state) const;
+    
+    /**
+     * This method encodes the encapsulated value of this Property at the top of the Lua
+     * stack. The specific details of this serialization is up to the property developer
+     * as long as the rest of the stack is unchanged. The implementation has to be
+     * synchronized with the Property::setLuaValue method. The default implementation is a
+     * no-op.
+     * \param state The Lua state to which the value will be encoded
+     * \return <code>true</code> if the encoding succeeded, <code>false</code> otherwise
+     */
+    virtual bool getLuaValue(lua_State* state) const;
 
-	/**
-	 * This method sets the value encapsulated by this Property by deserializing the value
-	 * on top of the passed Lua stack. The specific details of the deserialization are up
-	 * to the Property developer, but they must only depend on the top element of the
-	 * stack and must leave all other elements unchanged. The implementation has to be
-	 * synchronized with the Property::getLuaValue method. The default implementation is a
-	 * no-op.
-	 * \param state The Lua state from which the value will be decoded
-	 * \return <code>true</code> if the decoding and setting of the value succeeded,
-	 * <code>false</code> otherwise
-	 */
-	virtual bool setLuaValue(lua_State* state);
+    /**
+     * This method sets the value encapsulated by this Property by deserializing the value
+     * on top of the passed Lua stack. The specific details of the deserialization are up
+     * to the Property developer, but they must only depend on the top element of the
+     * stack and must leave all other elements unchanged. The implementation has to be
+     * synchronized with the Property::getLuaValue method. The default implementation is a
+     * no-op.
+     * \param state The Lua state from which the value will be decoded
+     * \return <code>true</code> if the decoding and setting of the value succeeded,
+     * <code>false</code> otherwise
+     */
+    virtual bool setLuaValue(lua_State* state);
 
-	/**
-	 * Returns the Lua type that will be put onto the stack in the Property::getLua method
-	 * and which will be consumed by the Property::setLuaValue method. The returned value
-	 * can belong to the set of Lua types: <code>LUA_TNONE</code>, <code>LUA_TNIL</code>,
-	 * <code>LUA_TBOOLEAN</code>, <code>LUA_TLIGHTUSERDATA</code>,
-	 * <code>LUA_TNUMBER</code>, <code>LUA_TSTRING</code>, <code>LUA_TTABLE</code>,
-	 * <code>LUA_TFUNCTION</code>, <code>LUA_TUSERDATA</code>, or
-	 * <code>LUA_TTHREAD</code>. The default implementation will return
-	 * <code>LUA_TNONE</code>.
-	 * \return The Lua type that will be consumed or produced by the Property::getLuaValue
+    /**
+     * Returns the Lua type that will be put onto the stack in the Property::getLua method
+     * and which will be consumed by the Property::setLuaValue method. The returned value
+     * can belong to the set of Lua types: <code>LUA_TNONE</code>, <code>LUA_TNIL</code>,
+     * <code>LUA_TBOOLEAN</code>, <code>LUA_TLIGHTUSERDATA</code>,
+     * <code>LUA_TNUMBER</code>, <code>LUA_TSTRING</code>, <code>LUA_TTABLE</code>,
+     * <code>LUA_TFUNCTION</code>, <code>LUA_TUSERDATA</code>, or
+     * <code>LUA_TTHREAD</code>. The default implementation will return
+     * <code>LUA_TNONE</code>.
+     * \return The Lua type that will be consumed or produced by the Property::getLuaValue
      * and Property::setLuaValue methods.
-	 */
-	virtual int typeLua() const;
+     */
+    virtual int typeLua() const;
 
-	/**
-	 * This method encodes the encapsulated value of this Property as a
+    /**
+     * This method encodes the encapsulated value of this Property as a
      * <code>std::string</code>. The specific details of this serialization is up to the
      * property developer. The implementation has to be synchronized with the
      Property::setStringValue method. The default implementation is a no-op.
-	 * \param value The value to which the Property will be encoded
-	 * \return <code>true</code> if the encoding succeeded, <code>false</code> otherwise
-	 */
+     * \param value The value to which the Property will be encoded
+     * \return <code>true</code> if the encoding succeeded, <code>false</code> otherwise
+     */
     virtual bool getStringValue(std::string& value) const;
 
-	/**
-	 * This method sets the value encapsulated by this Property by deserializing the
+    /**
+     * This method sets the value encapsulated by this Property by deserializing the
      * passed <code>std::string</code>. The specific details of the deserialization are up
-	 * to the Property developer. The implementation has to be synchronized with the
+     * to the Property developer. The implementation has to be synchronized with the
      * Property::getLuaValue method. The default implementation is a no-op.
-	 * \param value The value from which the Property will be decoded
-	 * \return <code>true</code> if the decoding and setting of the value succeeded,
-	 * <code>false</code> otherwise
-	 */
+     * \param value The value from which the Property will be decoded
+     * \return <code>true</code> if the decoding and setting of the value succeeded,
+     * <code>false</code> otherwise
+     */
     virtual bool setStringValue(std::string value);
 
-	/**
-	 * This method registers a <code>callback</code> function that will be called every
-	 * time if either Property:set or Property::setLuaValue was called with a value that
+    /**
+     * This method registers a <code>callback</code> function that will be called every
+     * time if either Property:set or Property::setLuaValue was called with a value that
      * is different from the previously stored value. The callback can be removed by
      * passing an empty <code>std::function<void()></code> object.
-	 * \param callback The callback function that is called when the encapsulated type has
-	 * been successfully changed by either the Property::set or Property::setLuaValue
+     * \param callback The callback function that is called when the encapsulated type has
+     * been successfully changed by either the Property::set or Property::setLuaValue
      * methods.
-	 */
+     */
     virtual void onChange(std::function<void()> callback);
 
-	/**
-	 * This method returns the unique identifier of this Property.
-	 * \return The unique identifier of this Property
-	 */
+    /**
+     * This method returns the unique identifier of this Property.
+     * \return The unique identifier of this Property
+     */
     const std::string& identifier() const;
-	
-	/**
-	 * Returns the fully qualified name for this Property that uniquely identifies this
-	 * Property within OpenSpace. It consists of the <code>identifier</code> preceded by
-	 * all levels of PropertyOwner%s separated with <code>.</code>; for example:
-	 * <code>owner1.owner2.identifier</code>.
-	 * \return The fully qualified identifier for this Property
-	 */
-	std::string fullyQualifiedIdentifier() const;
+    
+    /**
+     * Returns the fully qualified name for this Property that uniquely identifies this
+     * Property within OpenSpace. It consists of the <code>identifier</code> preceded by
+     * all levels of PropertyOwner%s separated with <code>.</code>; for example:
+     * <code>owner1.owner2.identifier</code>.
+     * \return The fully qualified identifier for this Property
+     */
+    std::string fullyQualifiedIdentifier() const;
 
-	/**
-	 * Returns the PropertyOwner of this Property or <code>nullptr</code>, if it does not
-	 * have an owner.
-	 *\ return The Property of this Property
-	 */
+    /**
+     * Returns the PropertyOwner of this Property or <code>nullptr</code>, if it does not
+     * have an owner.
+     *\ return The Property of this Property
+     */
     PropertyOwner* owner() const;
 
-	/**
-	 * Assigned the Property to a new PropertyOwner. This method does not inform the
-	 * PropertyOwner of this action.
-	 * \param owner The new PropertyOwner for this Property
-	 */
+    /**
+     * Assigned the Property to a new PropertyOwner. This method does not inform the
+     * PropertyOwner of this action.
+     * \param owner The new PropertyOwner for this Property
+     */
     void setPropertyOwner(PropertyOwner* owner);
-	
-	/**
-	 * Returns the human-readable GUI name for this Property that has been set in the
-	 * constructor. This method returns the same value as accessing the metaData object
-	 * and requesting the <code>std::string</code> stored for the <code>guiName</code>
-	 * key.
-	 * \return The human-readable GUI name for this Property
-	 */
-	std::string guiName() const;
+    
+    /**
+     * Returns the human-readable GUI name for this Property that has been set in the
+     * constructor. This method returns the same value as accessing the metaData object
+     * and requesting the <code>std::string</code> stored for the <code>guiName</code>
+     * key.
+     * \return The human-readable GUI name for this Property
+     */
+    std::string guiName() const;
 
-	/**
-	 * Returns the description for this Property that contains all necessary information
-	 * required for creating a GUI representation. The format of the description is a
-	 * valid Lua table, i.e., it is surrounded by a pair of <code>{</code> and
-	 * <code>}</code> with key,value pairs between. Each value can either be a number, a
-	 * string, a bool, or another table. The general values set by this base function
-	 * are: <code>Identifier</code>, <code>Name</code>, <code>Type</code>. All other
-	 * values are specific to the type and are added in a specific subclass, which require
-	 * the subclass to call this method first.
-	 * \return The descriptive text for the Property that can be used for constructing a
-	 * GUI representation
-	 */
-	virtual std::string description() const;
+    /**
+     * Returns the description for this Property that contains all necessary information
+     * required for creating a GUI representation. The format of the description is a
+     * valid Lua table, i.e., it is surrounded by a pair of <code>{</code> and
+     * <code>}</code> with key,value pairs between. Each value can either be a number, a
+     * string, a bool, or another table. The general values set by this base function
+     * are: <code>Identifier</code>, <code>Name</code>, <code>Type</code>. All other
+     * values are specific to the type and are added in a specific subclass, which require
+     * the subclass to call this method first.
+     * \return The descriptive text for the Property that can be used for constructing a
+     * GUI representation
+     */
+    virtual std::string description() const;
 
-	/**
-	 * Sets the identifier of the group that this Property belongs to. Property groups can
-	 * be used, for example, by GUI application to visually group different properties,
-	 * but it has no impact on the Property itself. The default value for the groupID is
-	 * <code>""</code>.
-	 * \param groupId The group id that this property should belong to
-	 */
+    /**
+     * Sets the identifier of the group that this Property belongs to. Property groups can
+     * be used, for example, by GUI application to visually group different properties,
+     * but it has no impact on the Property itself. The default value for the groupID is
+     * <code>""</code>.
+     * \param groupId The group id that this property should belong to
+     */
     void setGroupIdentifier(std::string groupId);
 
-	/**
-	 * Returns the group idenfier that this Property belongs to, or <code>""</code> if it
-	 * belongs to no group.
-	 * \return The group identifier that this Property belongs to
-	 */
+    /**
+     * Returns the group idenfier that this Property belongs to, or <code>""</code> if it
+     * belongs to no group.
+     * \return The group identifier that this Property belongs to
+     */
     std::string groupIdentifier() const;
 
-	/**
-	 * Determines a hint if this Property should be visible, or hidden. Each application
-	 * accessing the properties is free to ignore this hint. It is stored in the metaData
-	 * Dictionary with the key: <code>isVisible</code>. The default value is
-	 * <code>true</code>.
-	 * \param state <code>true</code> if the Property should be visible,
-	 * <code>false</code> otherwise.
-	 */
+    /**
+     * Determines a hint if this Property should be visible, or hidden. Each application
+     * accessing the properties is free to ignore this hint. It is stored in the metaData
+     * Dictionary with the key: <code>isVisible</code>. The default value is
+     * <code>true</code>.
+     * \param state <code>true</code> if the Property should be visible,
+     * <code>false</code> otherwise.
+     */
     void setVisible(bool state);
 
-	/**
-	 * This method determines if this Property should be read-only in external
-	 * applications. This setting is only a hint and does not need to be followed by GUI
-	 * applications and does not have any effect on the Property::set,
+    /**
+     * This method determines if this Property should be read-only in external
+     * applications. This setting is only a hint and does not need to be followed by GUI
+     * applications and does not have any effect on the Property::set,
      * Property::setLuaValue, or Property::setStringValue methods. The value is stored in
      * the metaData Dictionary with the key: <code>isReadOnly</code>. The default value is
      * <code>false</code>.
-	 * \param state <code>true</code> if the Property should be read only,
-	 * <code>false</code> otherwise
-	 */
-	void setReadOnly(bool state);
+     * \param state <code>true</code> if the Property should be read only,
+     * <code>false</code> otherwise
+     */
+    void setReadOnly(bool state);
 
-	/**
-	 * This method allows the developer to give hints to the GUI about different
-	 * representations for the GUI. The same Property (for example Vec4Property) can be
-	 * used in different ways, each requiring a different input method. These values are
-	 * stored in the metaData object using the <code>views.</code> prefix in front of the
-	 * <code>option</code> parameter. See Property::ViewOptions for a default list of
-	 * possible options. As these are only hints, the GUI is free to ignore any suggestion
-	 * by the developer.
-	 * \param option The view option that should be modified
-	 * \param value Determines if the view option should be active (<code>true</code>) or
-	 * deactivated (<code>false</code>)
-	 */
+    /**
+     * This method allows the developer to give hints to the GUI about different
+     * representations for the GUI. The same Property (for example Vec4Property) can be
+     * used in different ways, each requiring a different input method. These values are
+     * stored in the metaData object using the <code>views.</code> prefix in front of the
+     * <code>option</code> parameter. See Property::ViewOptions for a default list of
+     * possible options. As these are only hints, the GUI is free to ignore any suggestion
+     * by the developer.
+     * \param option The view option that should be modified
+     * \param value Determines if the view option should be active (<code>true</code>) or
+     * deactivated (<code>false</code>)
+     */
     void setViewOption(std::string option, bool value = true);
 
-	/**
-	 * Default view options that can be used in the Property::setViewOption method. The
-	 * values are: Property::ViewOptions::Color = <code>color</code>,
-	 * Property::ViewOptions::LightPosition = <code>lightPosition</code>,
-	 * Property::ViewOptions::PowerScaledScalar = <code>powerScaledScalar</code>, and
-	 * Property::ViewOptions::PowerScaledCoordinate = <code>powerScaledCoordinate</code>.
-	 */
+    /**
+     * Default view options that can be used in the Property::setViewOption method. The
+     * values are: Property::ViewOptions::Color = <code>color</code>,
+     * Property::ViewOptions::LightPosition = <code>lightPosition</code>,
+     * Property::ViewOptions::PowerScaledScalar = <code>powerScaledScalar</code>, and
+     * Property::ViewOptions::PowerScaledCoordinate = <code>powerScaledCoordinate</code>.
+     */
     struct ViewOptions {
         static const std::string Color;
         static const std::string LightPosition;
@@ -302,68 +302,68 @@ public:
         static const std::string PowerScaledCoordinate;
     };
 
-	/**
-	 * Returns the metaData that contains all information for external applications to
-	 * correctly display information about the Property. No information that is stored in
-	 * this Dictionary is necessary for the programmatic use of the Property.
-	 * \return The Dictionary containing all meta data information about this Property
-	 */
+    /**
+     * Returns the metaData that contains all information for external applications to
+     * correctly display information about the Property. No information that is stored in
+     * this Dictionary is necessary for the programmatic use of the Property.
+     * \return The Dictionary containing all meta data information about this Property
+     */
     const ghoul::Dictionary& metaData() const;
 
 protected:
-	static const std::string IdentifierKey;
-	static const std::string NameKey;
-	static const std::string TypeKey;
-	static const std::string MetaDataKey;
+    static const std::string IdentifierKey;
+    static const std::string NameKey;
+    static const std::string TypeKey;
+    static const std::string MetaDataKey;
 
-	/**
-	 * Creates the information that is general to every Property and adds the
-	 * <code>Identifier</code>, <code>Name</code>, <code>Type</code>, and
-	 * <code>MetaData</code> keys and their values. The meta data is handles by the
-	 * generateMetaDataDescription method, which has to be overloaded if a concrete base
-	 * class wants to add meta data that is not curated by the Property class
-	 * \return The base description common to all Property classes
-	 */
-	std::string generateBaseDescription() const;
+    /**
+     * Creates the information that is general to every Property and adds the
+     * <code>Identifier</code>, <code>Name</code>, <code>Type</code>, and
+     * <code>MetaData</code> keys and their values. The meta data is handles by the
+     * generateMetaDataDescription method, which has to be overloaded if a concrete base
+     * class wants to add meta data that is not curated by the Property class
+     * \return The base description common to all Property classes
+     */
+    std::string generateBaseDescription() const;
 
-	/**
-	 * Creates the information for the <code>MetaData</code> key-part of the Lua
-	 * description for the Property. The result can be included as one key-value pair in
-	 * the description text generated by subclasses. Only the metadata curated by the
-	 * Property class is used in this method.
-	 * \return The metadata information text for the property
-	 */
-	virtual std::string generateMetaDataDescription() const;
+    /**
+     * Creates the information for the <code>MetaData</code> key-part of the Lua
+     * description for the Property. The result can be included as one key-value pair in
+     * the description text generated by subclasses. Only the metadata curated by the
+     * Property class is used in this method.
+     * \return The metadata information text for the property
+     */
+    virtual std::string generateMetaDataDescription() const;
 
-	/**
-	 * Creates the information that is specific to each subclass of Property%s. If a
-	 * subclass needs to add additional information into the description, it has to
-	 * override this method and return the string containing all of the additional
-	 * information. The base implementation of the #description method will return the Lua
-	 * script:
-	 * <code>return { generateBaseDescription(), generateMetaDataDescription(),</code>
-	 * <code>generateAdditionalDescription()}</code>, which #generateMetaDataDescription
-	 * and this method being the override points to customize the behavior.
-	 * \return The information specific to each subclass of Property
-	 */ 
-	virtual std::string generateAdditionalDescription() const;
+    /**
+     * Creates the information that is specific to each subclass of Property%s. If a
+     * subclass needs to add additional information into the description, it has to
+     * override this method and return the string containing all of the additional
+     * information. The base implementation of the #description method will return the Lua
+     * script:
+     * <code>return { generateBaseDescription(), generateMetaDataDescription(),</code>
+     * <code>generateAdditionalDescription()}</code>, which #generateMetaDataDescription
+     * and this method being the override points to customize the behavior.
+     * \return The information specific to each subclass of Property
+     */ 
+    virtual std::string generateAdditionalDescription() const;
 
-	/**
-	 * This method must be called by all subclasses whenever the encapsulated value has
-	 * changed and a potential listener has to be informed.
-	 */
-	void notifyListener();
+    /**
+     * This method must be called by all subclasses whenever the encapsulated value has
+     * changed and a potential listener has to be informed.
+     */
+    void notifyListener();
 
-	/// The PropetyOwner this Property belongs to, or <code>nullptr</code>
+    /// The PropetyOwner this Property belongs to, or <code>nullptr</code>
     PropertyOwner* _owner; 
 
-	/// The identifier for this Property
+    /// The identifier for this Property
     std::string _identifier;
 
-	/// The Dictionary containing all meta data necessary for external applications
+    /// The Dictionary containing all meta data necessary for external applications
     ghoul::Dictionary _metaData;
 
-	/// The callback function that will be invoked whenever the encapsulated value changes
+    /// The callback function that will be invoked whenever the encapsulated value changes
     std::function<void()> _onChangeCallback;
 };
 
diff --git a/include/openspace/properties/propertydelegate.h b/include/openspace/properties/propertydelegate.h
index 3ed144cd48..c369482e37 100644
--- a/include/openspace/properties/propertydelegate.h
+++ b/include/openspace/properties/propertydelegate.h
@@ -47,108 +47,108 @@ namespace properties {
 template <typename T>
 class PropertyDelegate {
 public:
-	/**
-	 * This method returns the class name for the class <code>T</code>. The default
-	 * implementation will lead to a compile-time error if the class method is not
-	 * specialized.
-	 * \return The class name for the class <code>T</code>
-	 */
+    /**
+     * This method returns the class name for the class <code>T</code>. The default
+     * implementation will lead to a compile-time error if the class method is not
+     * specialized.
+     * \return The class name for the class <code>T</code>
+     */
     static std::string className();
 
-	/**
-	 * This method will return the preferred default value for the class <code>T</code>.
-	 * The default implementation will lead to a compile-time error if the class method is
-	 * not specialized.
-	 * \return The default value that the class <code>T</code> should use
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
-	 */
+    /**
+     * This method will return the preferred default value for the class <code>T</code>.
+     * The default implementation will lead to a compile-time error if the class method is
+     * not specialized.
+     * \return The default value that the class <code>T</code> should use
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
+     */
     template <typename U>
     static U defaultValue();
 
-	/**
-	 * This method will return the preferred default minimum value for the class
-	 * <code>T</code>. The default implementation will lead to a compile-time error if the
-	 * class method is not specialized. This method is not used in TemplateProperty, but
-	 * only NumericalProperty, so the TemplateProperty does not require this method to be
-	 * specialized.
-	 * \return The default minimum value that the class <code>T</code> should use
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
-	 */
+    /**
+     * This method will return the preferred default minimum value for the class
+     * <code>T</code>. The default implementation will lead to a compile-time error if the
+     * class method is not specialized. This method is not used in TemplateProperty, but
+     * only NumericalProperty, so the TemplateProperty does not require this method to be
+     * specialized.
+     * \return The default minimum value that the class <code>T</code> should use
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
+     */
     template <typename U>
     static U defaultMinimumValue();
 
-	/**
-	 * This method will return the preferred default maximum value for the class
-	 * <code>T</code>. The default implementation will lead to a compile-time error if the
-	 * class method is not specialized. This method is not used in TemplateProperty, but
-	 * only NumericalProperty, so the TemplateProperty does not require this method to be
-	 * specialized.
-	 * \return The default maximum value that the class <code>T</code> should use
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
-	 */
+    /**
+     * This method will return the preferred default maximum value for the class
+     * <code>T</code>. The default implementation will lead to a compile-time error if the
+     * class method is not specialized. This method is not used in TemplateProperty, but
+     * only NumericalProperty, so the TemplateProperty does not require this method to be
+     * specialized.
+     * \return The default maximum value that the class <code>T</code> should use
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
+     */
     template <typename U>
     static U defaultMaximumValue();
 
-	/**
-	 * The method returns the default stepping value for the class <code>T</code> used in
-	 * GUI elements. The default implementation will lead to a compile-time error if the
-	 * class method is not specialized. This method is not used in TemplateProperty, but
-	 * only NumericalProperty, so the TemplateProperty does not require this method to be
-	 * specialized.
-	 * \return The default stepping that the class <code>T</code> should use
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
-	 */
-	template <typename U>
-	static U defaultSteppingValue();
+    /**
+     * The method returns the default stepping value for the class <code>T</code> used in
+     * GUI elements. The default implementation will lead to a compile-time error if the
+     * class method is not specialized. This method is not used in TemplateProperty, but
+     * only NumericalProperty, so the TemplateProperty does not require this method to be
+     * specialized.
+     * \return The default stepping that the class <code>T</code> should use
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = NumericalProperty<int></code>, then <code>U = int</code>
+     */
+    template <typename U>
+    static U defaultSteppingValue();
 
-	/**
-	 * This method converts the top value from the Lua stack into a value of type
-	 * <code>U</code> and reports the <code>success</code> back to the caller. The default
-	 * implementation will lead to a compile-time error if the class method is not
-	 * specialized.
-	 * \param state The Lua state from which the value is retrieved
-	 * \param success Will be <code>true</code> if the conversion succeeded;
-	 * <code>false</code> otherwise
-	 * \return The value that was created by converting the top value from the stack
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
-	 */
-	template <typename U>
-	static U fromLuaValue(lua_State* state, bool& success);
+    /**
+     * This method converts the top value from the Lua stack into a value of type
+     * <code>U</code> and reports the <code>success</code> back to the caller. The default
+     * implementation will lead to a compile-time error if the class method is not
+     * specialized.
+     * \param state The Lua state from which the value is retrieved
+     * \param success Will be <code>true</code> if the conversion succeeded;
+     * <code>false</code> otherwise
+     * \return The value that was created by converting the top value from the stack
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
+     */
+    template <typename U>
+    static U fromLuaValue(lua_State* state, bool& success);
 
-	/**
-	 * This method converts the passed <code>value</code>, encodes it and places it on the
-	 * top value of the Lua stack and returns the success back to the caller. The default
-	 * implementation will lead to a compile-time error if the class method is not
-	 * specialized.
-	 * \param state The Lua state from which the value is retrieved
-	 * \param value The value that will be converted into a Lua object
-	 * \return <code>true</code> if the conversion succeeded; <code>false</code> otherwise
-	 * \tparam U The type by which the class T is specialized. If
-	 * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
-	 */
-	template <typename U>
-	static bool toLuaValue(lua_State* state, U value);
+    /**
+     * This method converts the passed <code>value</code>, encodes it and places it on the
+     * top value of the Lua stack and returns the success back to the caller. The default
+     * implementation will lead to a compile-time error if the class method is not
+     * specialized.
+     * \param state The Lua state from which the value is retrieved
+     * \param value The value that will be converted into a Lua object
+     * \return <code>true</code> if the conversion succeeded; <code>false</code> otherwise
+     * \tparam U The type by which the class T is specialized. If
+     * <code>T = TemplateProperty<std::string></code>, then <code>U = std::string</code>
+     */
+    template <typename U>
+    static bool toLuaValue(lua_State* state, U value);
 
-	/**
-	 * Returns the Lua type that will be put onto the stack in the
-	 * PropertyDelegate::toLuaValue method and which will be consumed by the
-	 * PropertyDelegate::fromLuaValue method. The returned value can belong to the set of
-	 * Lua types: <code>LUA_TNONE</code>, <code>LUA_TNIL</code>,
-	 * <code>LUA_TBOOLEAN</code>, <code>LUA_TLIGHTUSERDATA</code>,
-	 * <code>LUA_TNUMBER</code>, <code>LUA_TSTRING</code>, <code>LUA_TTABLE</code>,
-	 * <code>LUA_TFUNCTION</code>, <code>LUA_TUSERDATA</code>, or
-	 * <code>LUA_TTHREAD</code>. The default implementation will return
-	 * <code>LUA_TNONE</code>. The default implementation will lead to a compile-time
-	 * error if the class method is not specialized.
-	 * \return The Lua type that will be consumed or produced by the
-	 * PropertyDelegate::toLuaValue and PropertyDelegate::fromLuaValue methods.
-	 */
-	static int typeLua();
+    /**
+     * Returns the Lua type that will be put onto the stack in the
+     * PropertyDelegate::toLuaValue method and which will be consumed by the
+     * PropertyDelegate::fromLuaValue method. The returned value can belong to the set of
+     * Lua types: <code>LUA_TNONE</code>, <code>LUA_TNIL</code>,
+     * <code>LUA_TBOOLEAN</code>, <code>LUA_TLIGHTUSERDATA</code>,
+     * <code>LUA_TNUMBER</code>, <code>LUA_TSTRING</code>, <code>LUA_TTABLE</code>,
+     * <code>LUA_TFUNCTION</code>, <code>LUA_TUSERDATA</code>, or
+     * <code>LUA_TTHREAD</code>. The default implementation will return
+     * <code>LUA_TNONE</code>. The default implementation will lead to a compile-time
+     * error if the class method is not specialized.
+     * \return The Lua type that will be consumed or produced by the
+     * PropertyDelegate::toLuaValue and PropertyDelegate::fromLuaValue methods.
+     */
+    static int typeLua();
 
     template <typename U>
     static U fromString(std::string value, bool& success);
diff --git a/include/openspace/properties/propertydelegate.inl b/include/openspace/properties/propertydelegate.inl
index d3531c1654..a4740d4707 100644
--- a/include/openspace/properties/propertydelegate.inl
+++ b/include/openspace/properties/propertydelegate.inl
@@ -30,14 +30,14 @@ namespace properties {
 template <typename T>
 std::string PropertyDelegate<T>::className() {
     static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::className specialization");
+        "Unimplemented PropertyDelegate::className specialization");
 }
 
 template <typename T>
 template <typename U>
 U PropertyDelegate<T>::defaultValue() {
     static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::defaultValue specialization");
+        "Unimplemented PropertyDelegate::defaultValue specialization");
 }
 
 template <typename T>
@@ -57,28 +57,28 @@ U PropertyDelegate<T>::defaultMaximumValue() {
 template <typename T>
 template <typename U>
 U PropertyDelegate<T>::defaultSteppingValue() {
-	static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::defaultSteppingValue specialization");
+    static_assert(sizeof(T) == 0,
+        "Unimplemented PropertyDelegate::defaultSteppingValue specialization");
 }
 
 template <typename T>
 template <typename U>
 U PropertyDelegate<T>::fromLuaValue(lua_State* state, bool& success) {
-	static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::fromLuaValue specialization");
+    static_assert(sizeof(T) == 0,
+        "Unimplemented PropertyDelegate::fromLuaValue specialization");
 }
 
 template <typename T>
 template <typename U>
 bool PropertyDelegate<T>::toLuaValue(lua_State* state, U value) {
-	static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::toLuaValue specialization");
+    static_assert(sizeof(T) == 0,
+        "Unimplemented PropertyDelegate::toLuaValue specialization");
 }
 
 template <typename T>
 int PropertyDelegate<T>::typeLua() {
-	static_assert(sizeof(T) == 0,
-		"Unimplemented PropertyDelegate::luaType specialization");
+    static_assert(sizeof(T) == 0,
+        "Unimplemented PropertyDelegate::luaType specialization");
 }
 
 template <typename T>
diff --git a/include/openspace/properties/propertyowner.h b/include/openspace/properties/propertyowner.h
index f8797cdf66..55cc9bcb82 100644
--- a/include/openspace/properties/propertyowner.h
+++ b/include/openspace/properties/propertyowner.h
@@ -49,173 +49,173 @@ namespace properties {
  */
 class PropertyOwner {
 public:
-	/// The separator that is used while accessing the properties and/or sub-owners
+    /// The separator that is used while accessing the properties and/or sub-owners
     static const char URISeparator = '.';
     
-	/// The constructor initializing the PropertyOwner's name to <code>""</code>
+    /// The constructor initializing the PropertyOwner's name to <code>""</code>
     PropertyOwner();
 
-	/**
-	 * The destructor will remove all Propertys and PropertyOwners it owns along with
-	 * itself.
-	 */
+    /**
+     * The destructor will remove all Propertys and PropertyOwners it owns along with
+     * itself.
+     */
     virtual ~PropertyOwner();
 
-	/**
-	 * Sets the name for this PropertyOwner. If the PropertyOwner does not have an owner
-	 * itself, the name must be globally unique. If the PropertyOwner has an owner, the
-	 * name must be unique to the owner (including the owner's properties). No uniqueness
-	 * check will be preformed here, but rather in the PropertyOwner::addProperty and
-	 * PropertyOwner::addPropertySubOwner methods).
-	 * \param name The name of this PropertyOwner. It may not contain any <code>.</code>s
-	 */
+    /**
+     * Sets the name for this PropertyOwner. If the PropertyOwner does not have an owner
+     * itself, the name must be globally unique. If the PropertyOwner has an owner, the
+     * name must be unique to the owner (including the owner's properties). No uniqueness
+     * check will be preformed here, but rather in the PropertyOwner::addProperty and
+     * PropertyOwner::addPropertySubOwner methods).
+     * \param name The name of this PropertyOwner. It may not contain any <code>.</code>s
+     */
     void setName(std::string name);
 
-	/**
-	 * Returns the name of this PropertyOwner.
-	 * \return The name of this PropertyOwner
-	 */
+    /**
+     * Returns the name of this PropertyOwner.
+     * \return The name of this PropertyOwner
+     */
     const std::string& name() const;
 
-	/**
-	 * Returns a list of all Propertys directly owned by this PropertyOwner. This list not
-	 * include Propertys owned by other sub-owners.
-	 * \return A list of all Propertys directly owned by this PropertyOwner
-	 */
+    /**
+     * Returns a list of all Propertys directly owned by this PropertyOwner. This list not
+     * include Propertys owned by other sub-owners.
+     * \return A list of all Propertys directly owned by this PropertyOwner
+     */
     const std::vector<Property*>& properties() const;
 
-	/**
-	 * Returns a list of all Propertys directly or indirectly owned by this PropertyOwner.
-	 * \return A list of all Propertys directly or indirectly owned by this PropertyOwner
-	 */
-	std::vector<Property*> propertiesRecursive() const;
+    /**
+     * Returns a list of all Propertys directly or indirectly owned by this PropertyOwner.
+     * \return A list of all Propertys directly or indirectly owned by this PropertyOwner
+     */
+    std::vector<Property*> propertiesRecursive() const;
 
-	/**
-	 * Retrieves a Property identified by <code>URI</code> from this PropertyOwner. If
-	 * <code>id</code> does not contain a <code>.</code> the identifier must refer to a
-	 * Property directly owned by this PropertyOwner. If the identifier contains one or
-	 * more <code>.</code>, the first part of the name will be recursively extracted and
-	 * used as a name for a sub-owner and only the last part of the identifier is
-	 * referring to a Property owned by PropertyOwner named by the second-but-last name.
-	 * \param URI The identifier of the Property that should be extracted
-	 * \return If the Property cannot be found, <code>nullptr</code> is returned,
-	 * otherwise the pointer to the Property is returned
-	 */
+    /**
+     * Retrieves a Property identified by <code>URI</code> from this PropertyOwner. If
+     * <code>id</code> does not contain a <code>.</code> the identifier must refer to a
+     * Property directly owned by this PropertyOwner. If the identifier contains one or
+     * more <code>.</code>, the first part of the name will be recursively extracted and
+     * used as a name for a sub-owner and only the last part of the identifier is
+     * referring to a Property owned by PropertyOwner named by the second-but-last name.
+     * \param URI The identifier of the Property that should be extracted
+     * \return If the Property cannot be found, <code>nullptr</code> is returned,
+     * otherwise the pointer to the Property is returned
+     */
     Property* property(const std::string& URI) const;
 
-	/**
-	 * This method checks if a Property with the provided <code>URI</code> exists in this
-	 * PropertyOwner (or any sub-owner). If the identifier contains one or more
-	 * <code>.</code>, the first part of the name will be recursively extracted and is
-	 * used as a name for a sub-owner and only the last part of the identifier is
-	 * referring to a Property owned by PropertyOwner named by the second-but-last name.
-	 * \return <code>true</code> if the <code>URI</code> refers to a Property;
-	 * <code>false</code> otherwise.
-	 */
+    /**
+     * This method checks if a Property with the provided <code>URI</code> exists in this
+     * PropertyOwner (or any sub-owner). If the identifier contains one or more
+     * <code>.</code>, the first part of the name will be recursively extracted and is
+     * used as a name for a sub-owner and only the last part of the identifier is
+     * referring to a Property owned by PropertyOwner named by the second-but-last name.
+     * \return <code>true</code> if the <code>URI</code> refers to a Property;
+     * <code>false</code> otherwise.
+     */
     bool hasProperty(const std::string& URI) const;
     
     void setPropertyOwner(PropertyOwner* owner) { _owner = owner; }
-	PropertyOwner* owner() const { return _owner; }
+    PropertyOwner* owner() const { return _owner; }
 
-	/**
-	 * Returns a list of all sub-owners this PropertyOwner has. Each name of a sub-owner
-	 * has to be unique with respect to other sub-owners as well as Property's owned by
-	 * this PropertyOwner.
-	 * \return A list of all sub-owners this PropertyOwner has
-	 */
+    /**
+     * Returns a list of all sub-owners this PropertyOwner has. Each name of a sub-owner
+     * has to be unique with respect to other sub-owners as well as Property's owned by
+     * this PropertyOwner.
+     * \return A list of all sub-owners this PropertyOwner has
+     */
     const std::vector<PropertyOwner*>& propertySubOwners() const;
 
-	/**
-	 * This method returns the direct sub-owner of this PropertyOwner with the provided
-	 * <code>name</code>. This means that <code>name</code> cannot contain any
-	 * <code>.</code> as this character is not allowed in PropertyOwner names. If the
-	 * <code>name</code> does not name a valid sub-owner of this PropertyOwner, a
-	 * <code>nullptr</code> will be returned.
-	 * \param name The name of the sub-owner that should be returned
-	 * \return The PropertyOwner with the given <code>name</code>, or <code>nullptr</code>
-	 */
+    /**
+     * This method returns the direct sub-owner of this PropertyOwner with the provided
+     * <code>name</code>. This means that <code>name</code> cannot contain any
+     * <code>.</code> as this character is not allowed in PropertyOwner names. If the
+     * <code>name</code> does not name a valid sub-owner of this PropertyOwner, a
+     * <code>nullptr</code> will be returned.
+     * \param name The name of the sub-owner that should be returned
+     * \return The PropertyOwner with the given <code>name</code>, or <code>nullptr</code>
+     */
     PropertyOwner* propertySubOwner(const std::string& name) const;
 
-	/**
-	 * Returns <code>true</code> if this PropertyOwner owns a sub-owner with the provided
-	 * <code>name</code>; returns <code>false</code> otherwise.
-	 * \param name The name of the sub-owner that should be looked up
-	 * \return <code>true</code> if this PropertyOwner owns a sub-owner with the provided
-	 * <code>name</code>; returns <code>false</code> otherwise
-	 */
+    /**
+     * Returns <code>true</code> if this PropertyOwner owns a sub-owner with the provided
+     * <code>name</code>; returns <code>false</code> otherwise.
+     * \param name The name of the sub-owner that should be looked up
+     * \return <code>true</code> if this PropertyOwner owns a sub-owner with the provided
+     * <code>name</code>; returns <code>false</code> otherwise
+     */
     bool hasPropertySubOwner(const std::string& name) const;
 
-	/**
-	 * This method converts a provided <code>groupID</code>, used by the Propertys, into a
-	 * human-readable <code>name</code> which can be used by some external application.
-	 * \param groupID The group identifier whose human-readable name should be set
-	 * \param name The human-readable name for the group identifier
-	 */
+    /**
+     * This method converts a provided <code>groupID</code>, used by the Propertys, into a
+     * human-readable <code>name</code> which can be used by some external application.
+     * \param groupID The group identifier whose human-readable name should be set
+     * \param name The human-readable name for the group identifier
+     */
     void setPropertyGroupName(std::string groupID, std::string name);
 
-	/**
-	 * Returns the human-readable name for the <code>groupID</code> for the Propertys of
-	 * this PropertyOwner.
-	 * \param groupID The group identifier whose human-readable name should be returned
-	 * \return The human readable name for the Propertys identified by
-	 * <code>groupID</code>
-	 */
+    /**
+     * Returns the human-readable name for the <code>groupID</code> for the Propertys of
+     * this PropertyOwner.
+     * \param groupID The group identifier whose human-readable name should be returned
+     * \return The human readable name for the Propertys identified by
+     * <code>groupID</code>
+     */
     const std::string& propertyGroupName(const std::string& groupID) const;
     
-	/**
-	 * Assigns the Property <code>prop</code> to this PropertyOwner. This method will
-	 * check if the name of the Property is unique amongst Propertys and sub-owners in
-	 * this PropertyOwner. This method will also inform the Property about the change in
-	 * ownership by calling the Property::setPropertyOwner method.
-	 * \param prop The Property whose ownership is changed.
-	 */
+    /**
+     * Assigns the Property <code>prop</code> to this PropertyOwner. This method will
+     * check if the name of the Property is unique amongst Propertys and sub-owners in
+     * this PropertyOwner. This method will also inform the Property about the change in
+     * ownership by calling the Property::setPropertyOwner method.
+     * \param prop The Property whose ownership is changed.
+     */
     void addProperty(Property* prop);
-	
-	/// \see Property::addProperty(Property*)
+    
+    /// \see Property::addProperty(Property*)
     void addProperty(Property& prop);
     
-	/**
-	 * Adds the provided PropertyOwner to the list of sub-owners for this PropertyOwner.
-	 * This means that the name of the <code>owner</code> has to be unique amonst the
-	 * direct Property's as well as other PropertyOwner's that this PropertyOwner owns.
-	 * This uniqueness will be tested in this method.
-	 * \param owner The owner that should be assigned to this PropertyOwner
-	 */
+    /**
+     * Adds the provided PropertyOwner to the list of sub-owners for this PropertyOwner.
+     * This means that the name of the <code>owner</code> has to be unique amonst the
+     * direct Property's as well as other PropertyOwner's that this PropertyOwner owns.
+     * This uniqueness will be tested in this method.
+     * \param owner The owner that should be assigned to this PropertyOwner
+     */
     void addPropertySubOwner(PropertyOwner* owner);
 
-	/// \see PropertyOwner::addPropertySubOwner(PropertyOwner*)
+    /// \see PropertyOwner::addPropertySubOwner(PropertyOwner*)
     void addPropertySubOwner(PropertyOwner& owner);
 
-	/**
-	 * Removes the Property from this PropertyOwner. Notifies the Property about this
-	 * change by calling the Property::setPropertyOwner method with a <code>nullptr</code>
-	 * as parameter.
-	 * \param prop The Property that should be removed from this PropertyOwner
-	 */
+    /**
+     * Removes the Property from this PropertyOwner. Notifies the Property about this
+     * change by calling the Property::setPropertyOwner method with a <code>nullptr</code>
+     * as parameter.
+     * \param prop The Property that should be removed from this PropertyOwner
+     */
     void removeProperty(Property* prop);
 
-	/// \see PropertyOwner::removeProperty(Property*)
+    /// \see PropertyOwner::removeProperty(Property*)
     void removeProperty(Property& prop);
     
-	/**
-	 * Removes the sub-owner from this PropertyOwner.
-	 * \param owner The PropertyOwner that should be removed
-	 */
+    /**
+     * Removes the sub-owner from this PropertyOwner.
+     * \param owner The PropertyOwner that should be removed
+     */
     void removePropertySubOwner(PropertyOwner* owner);
 
-	/// \see PropertyOwner::removePropertySubOwner(PropertyOwner*)
+    /// \see PropertyOwner::removePropertySubOwner(PropertyOwner*)
     void removePropertySubOwner(PropertyOwner& owner);
 
 private:
-	/// The name of this PropertyOwner
+    /// The name of this PropertyOwner
     std::string _name;
-	/// The owner of this PropertyOwner
-	PropertyOwner* _owner;
-	/// A list of all registered Property's
+    /// The owner of this PropertyOwner
+    PropertyOwner* _owner;
+    /// A list of all registered Property's
     std::vector<Property*> _properties;
-	/// A list of all sub-owners
+    /// A list of all sub-owners
     std::vector<PropertyOwner*> _subOwners;
-	/// The associations between group identifiers of Property's and human-readable names
+    /// The associations between group identifiers of Property's and human-readable names
     std::map<std::string, std::string> _groupNames;
 };
 
diff --git a/include/openspace/properties/selectionproperty.h b/include/openspace/properties/selectionproperty.h
index b70b3d968e..926155f25d 100644
--- a/include/openspace/properties/selectionproperty.h
+++ b/include/openspace/properties/selectionproperty.h
@@ -34,23 +34,23 @@ namespace properties {
 
 class SelectionProperty : public TemplateProperty<std::vector<int>> {
 public:
-	struct Option {
-		int value;
-		std::string description;
-	};
+    struct Option {
+        int value;
+        std::string description;
+    };
 
-	SelectionProperty(std::string identifier, std::string guiName);
-	
-	void addOption(Option option);
-	const std::vector<Option>& options() const;
+    SelectionProperty(std::string identifier, std::string guiName);
+    
+    void addOption(Option option);
+    const std::vector<Option>& options() const;
 
 private:
-	static const std::string OptionsKey;
-	std::string generateAdditionalDescription() const;
+    static const std::string OptionsKey;
+    std::string generateAdditionalDescription() const;
 
-	/// The list of options which have been registered with this OptionProperty
-	std::vector<Option> _options;
-	std::vector<int> _values;
+    /// The list of options which have been registered with this OptionProperty
+    std::vector<Option> _options;
+    std::vector<int> _values;
 };
 
 template <>
diff --git a/include/openspace/properties/templateproperty.h b/include/openspace/properties/templateproperty.h
index 22ac8050cb..08bf1e8068 100644
--- a/include/openspace/properties/templateproperty.h
+++ b/include/openspace/properties/templateproperty.h
@@ -52,135 +52,135 @@ namespace properties {
 template <typename T>
 class TemplateProperty : public Property {
 public:
-	typedef T ValueType;
+    typedef T ValueType;
 
-	/**
-	 * The constructor initializing the TemplateProperty with the provided
-	 * <code>identifier</code> and human-readable <code>guiName</code>. The default value
-	 * for the stored type <code>T</code> is retrieved using the PropertyDelegate's
-	 * PropertyDelegate::defaultValue method, which must be specialized for new types or
-	 * a compile-error will occur.
-	 * \param identifier The identifier that is used for this TemplateProperty
-	 * \param guiName The human-readable GUI name for this TemplateProperty
-	 */
+    /**
+     * The constructor initializing the TemplateProperty with the provided
+     * <code>identifier</code> and human-readable <code>guiName</code>. The default value
+     * for the stored type <code>T</code> is retrieved using the PropertyDelegate's
+     * PropertyDelegate::defaultValue method, which must be specialized for new types or
+     * a compile-error will occur.
+     * \param identifier The identifier that is used for this TemplateProperty
+     * \param guiName The human-readable GUI name for this TemplateProperty
+     */
     TemplateProperty(std::string identifier, std::string guiName);
 
-	/**
-	 * The constructor initializing the TemplateProperty with the provided
-	 * <code>identifier</code>, human-readable <code>guiName</code> and provided
-	 * <code>value</code>.
-	 */
+    /**
+     * The constructor initializing the TemplateProperty with the provided
+     * <code>identifier</code>, human-readable <code>guiName</code> and provided
+     * <code>value</code>.
+     */
     TemplateProperty(std::string identifier, std::string guiName, T value);
 
-	/**
-	 * Returns the class name for this TemplateProperty. The default implementation makes
-	 * a call to the PropertyDelegate::className method with the template parameter
-	 * <code>T</code> as argument. For this to work, that method needs to be specialized
-	 * to return the correct class name for the new template parameter T, or a
-	 * compile-time error will occur.
-	 * \return The class name for the TemplateProperty
-	 */
+    /**
+     * Returns the class name for this TemplateProperty. The default implementation makes
+     * a call to the PropertyDelegate::className method with the template parameter
+     * <code>T</code> as argument. For this to work, that method needs to be specialized
+     * to return the correct class name for the new template parameter T, or a
+     * compile-time error will occur.
+     * \return The class name for the TemplateProperty
+     */
     virtual std::string className() const override;
 
-	/**
-	 * Returns the stored value packed into a ghoul::any object.
-	 * \return The stored value packed into a ghoul::any object
-	 */
+    /**
+     * Returns the stored value packed into a ghoul::any object.
+     * \return The stored value packed into a ghoul::any object
+     */
     virtual ghoul::any get() const override;
 
-	/**
-	 * Sets the value fro the provided ghoul::any object. If the types between
+    /**
+     * Sets the value fro the provided ghoul::any object. If the types between
      * <code>T</code> and <code>value</code> disagree, an error is logged and the stored
      * value remains unchanged.
-	 */
+     */
     virtual void set(ghoul::any value) override;
 
-	/**
-	 * Returns the <code>std::type_info</code> describing the template parameter
-	 * <code>T</code>. It can be used to test against a ghoul::any value before trying to
+    /**
+     * Returns the <code>std::type_info</code> describing the template parameter
+     * <code>T</code>. It can be used to test against a ghoul::any value before trying to
      * assign it.
-	 * \return The type info object describing the template parameter <code>T</code>
-	 */
+     * \return The type info object describing the template parameter <code>T</code>
+     */
     virtual const std::type_info& type() const override;
 
-	/**
-	 * This method encodes the stored value into a Lua object and pushes that object onto
-	 * the stack. The encoding is performed by calling PropertyDelegate::toLuaValue with
-	 * the template parameter <code>T</code> as an argument. This method has to be
-	 * specialized for each new type, or a compile-time error will occur.
-	 * \param state The Lua state onto which the encoded object will be pushed
-	 * \return <code>true</code> if the encoding succeeded; <code>false</code> otherwise
-	 */
-	bool getLuaValue(lua_State* state) const override;
+    /**
+     * This method encodes the stored value into a Lua object and pushes that object onto
+     * the stack. The encoding is performed by calling PropertyDelegate::toLuaValue with
+     * the template parameter <code>T</code> as an argument. This method has to be
+     * specialized for each new type, or a compile-time error will occur.
+     * \param state The Lua state onto which the encoded object will be pushed
+     * \return <code>true</code> if the encoding succeeded; <code>false</code> otherwise
+     */
+    bool getLuaValue(lua_State* state) const override;
 
-	/**
-	 * Sets the value of this TemplateProprty by decoding the object at the top of the Lua
-	 * stack and, if successful, assigning it using the Property::set method. The decoding
-	 * is performed by calling the PropertyDelegate::fromLuaValue with the template
-	 * parameter <code>T</code> as argument. If the decoding is successful, the new value
-	 * is set, otherwise it remains unchanged.
-	 * \param state The Lua state from which the value will be decoded
-	 * \return <code>true</code> if the decoding succeeded; <code>false</code> otherwise
-	 */
-	bool setLuaValue(lua_State* state) override;
+    /**
+     * Sets the value of this TemplateProprty by decoding the object at the top of the Lua
+     * stack and, if successful, assigning it using the Property::set method. The decoding
+     * is performed by calling the PropertyDelegate::fromLuaValue with the template
+     * parameter <code>T</code> as argument. If the decoding is successful, the new value
+     * is set, otherwise it remains unchanged.
+     * \param state The Lua state from which the value will be decoded
+     * \return <code>true</code> if the decoding succeeded; <code>false</code> otherwise
+     */
+    bool setLuaValue(lua_State* state) override;
 
-	/// \see Property::typeLua
-	int typeLua() const override;
+    /// \see Property::typeLua
+    int typeLua() const override;
 
     bool getStringValue(std::string& value) const override;
 
     bool setStringValue(std::string value) override;
 
-	/**
-	 * Returns the description for this TemplateProperty as a Lua script that returns a
-	 * table on execution
-	 * \return The description for this TemplateProperty
-	 */
-	//virtual std::string description() override;
+    /**
+     * Returns the description for this TemplateProperty as a Lua script that returns a
+     * table on execution
+     * \return The description for this TemplateProperty
+     */
+    //virtual std::string description() override;
 
-	/**
-	 * This operator allows the TemplateProperty to be used almost transparently as if it
-	 * was of the type <code>T</code>. It makes assignments such as
-	 * <code>T v = property;</code> possible by allowing implicit casts (even though,
-	 * internally, not casts are performed. This method is next to zero overhead).
-	 * \return The internal representation of the Property
-	 */
+    /**
+     * This operator allows the TemplateProperty to be used almost transparently as if it
+     * was of the type <code>T</code>. It makes assignments such as
+     * <code>T v = property;</code> possible by allowing implicit casts (even though,
+     * internally, not casts are performed. This method is next to zero overhead).
+     * \return The internal representation of the Property
+     */
     operator T();
 
-	/**
-	 * This operator allows the TemplateProperty to be used almost transparently as if it
-	 * was of the type <code>T</code>. It makes assignments such as
-	 * <code>T v = property;</code> possible by allowing implicit casts (even though,
-	 * internally, not casts are performed. This method is next to zero overhead).
-	 * \return The internal representation of the Property
-	 */
-	operator T() const;
+    /**
+     * This operator allows the TemplateProperty to be used almost transparently as if it
+     * was of the type <code>T</code>. It makes assignments such as
+     * <code>T v = property;</code> possible by allowing implicit casts (even though,
+     * internally, not casts are performed. This method is next to zero overhead).
+     * \return The internal representation of the Property
+     */
+    operator T() const;
 
-	/**
-	 * The assignment operator allows the TemplateProperty's value to be set without using
-	 * the TemplateProperty::set method. It will be done internally by thos method and it
-	 * allows assignments such as <code>prop = T(1)</code>.
-	 * \param val The value that should be set.
-	 */
+    /**
+     * The assignment operator allows the TemplateProperty's value to be set without using
+     * the TemplateProperty::set method. It will be done internally by thos method and it
+     * allows assignments such as <code>prop = T(1)</code>.
+     * \param val The value that should be set.
+     */
     TemplateProperty<T>& operator=(T val);
 
-	/**
-	 * These method sets the stored value to the provided value <code>val</code>,
-	 * moving it into place. This move only happens if the provided value <code>val</code>
-	 * is different from the stored value, which needs an operator== to exist for the type
-	 * <code>T</code>. If the value are different, the listeners are notified.
-	 * \param val The new value for this TemplateProperty
-	 */
+    /**
+     * These method sets the stored value to the provided value <code>val</code>,
+     * moving it into place. This move only happens if the provided value <code>val</code>
+     * is different from the stored value, which needs an operator== to exist for the type
+     * <code>T</code>. If the value are different, the listeners are notified.
+     * \param val The new value for this TemplateProperty
+     */
     virtual void setValue(T val);
 
-	/**
-	 * Returns the currently stored value.
-	 * \return The currently stored value
-	 */
+    /**
+     * Returns the currently stored value.
+     * \return The currently stored value
+     */
     T value() const;
 
 protected:
-	/// The value that this TemplateProperty currently stores
+    /// The value that this TemplateProperty currently stores
     T _value;
 };
 
diff --git a/include/openspace/properties/templateproperty.inl b/include/openspace/properties/templateproperty.inl
index ac6db8ca65..3567784124 100644
--- a/include/openspace/properties/templateproperty.inl
+++ b/include/openspace/properties/templateproperty.inl
@@ -29,7 +29,7 @@ namespace properties {
 
 // The following macros can be used to quickly generate the necessary PropertyDelegate
 // specializations required by the TemplateProperty class. Use the
-// REGISTER_TEMPLATEPROPERTY_HEADER	macro in the header file and the
+// REGISTER_TEMPLATEPROPERTY_HEADER    macro in the header file and the
 // REGISTER_TEMPLATEPROPERTY_SOURCE macro in the source file of your new specialization of
 // a TemplateProperty
 
@@ -77,13 +77,13 @@ namespace properties {
 // DEFAULT_VALUE = The value (as type T) which should be used as a default value
 // FROM_LUA_LAMBDA_EXPRESSION = A lambda expression receiving a lua_State* as the first
 //                              parameter, a bool& as the second parameter and returning
-//								a value T. It is used by the fromLua method of
-//								TemplateProperty. The lambda expression must extract the
-//								stored value from the lua_State, return the value and
-//								report success in the second argument
+//                                a value T. It is used by the fromLua method of
+//                                TemplateProperty. The lambda expression must extract the
+//                                stored value from the lua_State, return the value and
+//                                report success in the second argument
 // TO_LUA_LAMBDA_EXPRESSION = A lambda expression receiving a lua_State*, a value T and
 //                            returning a bool. The lambda expression must encode the
-//							  value T onto the lua_State stack and return the success
+//                              value T onto the lua_State stack and return the success
 // LUA_TYPE                 = The Lua type that will be produced/consumed by the previous
 //                            Lambda expressions
 #define REGISTER_TEMPLATEPROPERTY_SOURCE(CLASS_NAME, TYPE, DEFAULT_VALUE,                \
@@ -170,7 +170,7 @@ std::string TemplateProperty<T>::className() const {
 
 //template <typename T>
 //std::string TemplateProperty<T>::description() {
-//	return
+//    return
 //}
 
 template <typename T>
@@ -180,7 +180,7 @@ TemplateProperty<T>::operator T() {
 
 template <typename T>
 TemplateProperty<T>::operator T() const {
-	return _value;
+    return _value;
 }
 
 template <typename T>
@@ -198,11 +198,11 @@ T openspace::properties::TemplateProperty<T>::value() const
 template <typename T>
 void openspace::properties::TemplateProperty<T>::setValue(T val)
 {
-	const bool changed = (val != _value);
-	if (changed) {
-		_value = std::move(val);
-		notifyListener();
-	}
+    const bool changed = (val != _value);
+    if (changed) {
+        _value = std::move(val);
+        notifyListener();
+    }
 }
 
 template <typename T>
@@ -220,14 +220,14 @@ template <typename T>
 void TemplateProperty<T>::set(ghoul::any value) {
     try {
         T v = ghoul::any_cast<T>(std::move(value));
-		if (v != _value) {
-			_value = std::move(v);
-			notifyListener();
-		}
+        if (v != _value) {
+            _value = std::move(v);
+            notifyListener();
+        }
     }
     catch (ghoul::bad_any_cast&) {
         LERRORC("TemplateProperty", "Illegal cast from '" << value.type().name()
-			<< "' to '" << typeid(T).name() << "'");
+            << "' to '" << typeid(T).name() << "'");
     }
 }
 
@@ -244,16 +244,16 @@ bool TemplateProperty<T>::getLuaValue(lua_State* state) const {
 
 template <typename T>
 bool TemplateProperty<T>::setLuaValue(lua_State* state) {
-	bool success = false;
-	T thisValue = PropertyDelegate<TemplateProperty<T>>::template fromLuaValue<T>(state, success);
-	if (success)
-		set(ghoul::any(thisValue));
-	return success;
+    bool success = false;
+    T thisValue = PropertyDelegate<TemplateProperty<T>>::template fromLuaValue<T>(state, success);
+    if (success)
+        set(ghoul::any(thisValue));
+    return success;
 }
 
 template <typename T>
 int TemplateProperty<T>::typeLua() const {
-	return PropertyDelegate<TemplateProperty<T>>::typeLua();
+    return PropertyDelegate<TemplateProperty<T>>::typeLua();
 }
 
 template <typename T>
diff --git a/include/openspace/properties/triggerproperty.h b/include/openspace/properties/triggerproperty.h
index e8fa03d596..dd43f58fc4 100644
--- a/include/openspace/properties/triggerproperty.h
+++ b/include/openspace/properties/triggerproperty.h
@@ -36,34 +36,34 @@ namespace properties {
  */
 class TriggerProperty : public Property {
 public:
-	/**
-	 * Initializes the TriggerProperty by delegating the <code>identifier</code> and
-	 * <code>guiName</code> to the Property constructor.
-	 * \param identifier The unique identifier used for this Property
-	 * \param guiName The human-readable name of this Property
-	 */
-	TriggerProperty(std::string identifier, std::string guiName);
+    /**
+     * Initializes the TriggerProperty by delegating the <code>identifier</code> and
+     * <code>guiName</code> to the Property constructor.
+     * \param identifier The unique identifier used for this Property
+     * \param guiName The human-readable name of this Property
+     */
+    TriggerProperty(std::string identifier, std::string guiName);
 
-	/**
-	 * Returns the class name <code>TriggerProperty</code>.
-	 * \return The class name <code>TriggerProperty</code>
-	 */
-	std::string className() const;
+    /**
+     * Returns the class name <code>TriggerProperty</code>.
+     * \return The class name <code>TriggerProperty</code>
+     */
+    std::string className() const;
 
-	/**
-	 * Accepts only the <code>LUA_TNIL</code> type and will notify all the listeners
-	 * that the event has been triggered.
-	 * \param state The unused Lua state 
-	 * \return Returns always <code>true</code>
-	 */
-	bool setLuaValue(lua_State* state);
+    /**
+     * Accepts only the <code>LUA_TNIL</code> type and will notify all the listeners
+     * that the event has been triggered.
+     * \param state The unused Lua state 
+     * \return Returns always <code>true</code>
+     */
+    bool setLuaValue(lua_State* state);
 
-	/**
-	 * Silently ignores any value that is passed into this function and will trigger the
-	 * listeners regardless of the value
-	 * \param value The ignored value
-	 */
-	void set(ghoul::any value);
+    /**
+     * Silently ignores any value that is passed into this function and will trigger the
+     * listeners regardless of the value
+     * \param value The ignored value
+     */
+    void set(ghoul::any value);
 };
 
 } // namespace properties
diff --git a/include/openspace/rendering/abufferrenderer.h b/include/openspace/rendering/abufferrenderer.h
index 46d802f4fb..1351643e8f 100644
--- a/include/openspace/rendering/abufferrenderer.h
+++ b/include/openspace/rendering/abufferrenderer.h
@@ -41,14 +41,14 @@
 #include <openspace/util/updatestructures.h>
 
 namespace ghoul {
-	
+    
     namespace filesystem {
         class File;
     }
-	namespace opengl {
+    namespace opengl {
         class ProgramObject;
-		class Texture;
-	}
+        class Texture;
+    }
 }
 
 namespace openspace {
@@ -56,11 +56,11 @@ namespace openspace {
 class RenderableVolume;
 class Camera;
 class Scene;
-	
+    
 class ABufferRenderer : public Renderer, public RaycasterListener {
 public:
-	ABufferRenderer();
-	virtual ~ABufferRenderer();
+    ABufferRenderer();
+    virtual ~ABufferRenderer();
 
     void initialize() override;
     void deinitialize() override;
@@ -70,7 +70,7 @@ public:
     void setResolution(glm::ivec2 res) override;
 
     void update();
-	void render(float blackoutFactor, bool doPerformanceMeasurements) override;
+    void render(float blackoutFactor, bool doPerformanceMeasurements) override;
 
 
     /**
@@ -120,7 +120,7 @@ private:
     int _nAaSamples;
 
     ghoul::Dictionary _rendererData;
-};		// ABufferRenderer
-}		// openspace
+};        // ABufferRenderer
+}        // openspace
 
-#endif 	// __RENDERER_H__
+#endif     // __RENDERER_H__
diff --git a/include/openspace/rendering/framebufferrenderer.h b/include/openspace/rendering/framebufferrenderer.h
index 01ec98b204..fb65728005 100644
--- a/include/openspace/rendering/framebufferrenderer.h
+++ b/include/openspace/rendering/framebufferrenderer.h
@@ -37,15 +37,15 @@
 #include <openspace/util/updatestructures.h>
 
 namespace ghoul {
-	class Dictionary;
-	
+    class Dictionary;
+    
     namespace filesystem {
         class File;
     }
-	namespace opengl {
+    namespace opengl {
         class ProgramObject;
-		class Texture;
-	}
+        class Texture;
+    }
 }
 
 namespace openspace {
@@ -53,11 +53,11 @@ namespace openspace {
 class RenderableVolume;
 class Camera;
 class Scene;
-	
+    
 class FramebufferRenderer : public Renderer, public RaycasterListener {
 public:
-	FramebufferRenderer();
-	virtual ~FramebufferRenderer();
+    FramebufferRenderer();
+    virtual ~FramebufferRenderer();
 
     void initialize() override;
     void deinitialize() override;
@@ -70,7 +70,7 @@ public:
     void setResolution(glm::ivec2 res) override;
 
     void update() override;
-	void render(float blackoutFactor, bool doPerformanceMeasurements) override;
+    void render(float blackoutFactor, bool doPerformanceMeasurements) override;
     
     /**
      * Update render data
@@ -105,7 +105,7 @@ private:
     int _nAaSamples;
 
     ghoul::Dictionary _rendererData;
-};		// FramebufferRenderer
-}		// openspace
+};        // FramebufferRenderer
+}        // openspace
 
-#endif 	// __FRAMEBUFFERRENDERER_H__
+#endif     // __FRAMEBUFFERRENDERER_H__
diff --git a/include/openspace/rendering/renderable.h b/include/openspace/rendering/renderable.h
index 1e8554f462..7193f8e1e7 100644
--- a/include/openspace/rendering/renderable.h
+++ b/include/openspace/rendering/renderable.h
@@ -36,10 +36,10 @@
 
 // Forward declare to minimize dependencies
 namespace ghoul {
-	namespace opengl {
-		class Texture;
-	}
-	class Dictionary;
+    namespace opengl {
+        class Texture;
+    }
+    class Dictionary;
 }
 
 namespace openspace {
@@ -60,8 +60,8 @@ public:
     virtual bool initialize() = 0;
     virtual bool deinitialize() = 0;
 
-	virtual bool isReady() const = 0;
-	bool isEnabled() const;
+    virtual bool isReady() const = 0;
+    bool isEnabled() const;
 
     void setBoundingSphere(const PowerScaledScalar& boundingSphere);
     const PowerScaledScalar& getBoundingSphere();
@@ -70,27 +70,27 @@ public:
     virtual void render(const RenderData& data, RendererTasks& rendererTask);
     virtual void update(const UpdateData& data);
 
-	bool isVisible() const;
-	
-	bool hasTimeInterval();
-	bool getInterval(double& start, double& end);
-	
-	bool hasBody();
-	bool getBody(std::string& body);
-	void setBody(std::string& body);
+    bool isVisible() const;
+    
+    bool hasTimeInterval();
+    bool getInterval(double& start, double& end);
+    
+    bool hasBody();
+    bool getBody(std::string& body);
+    void setBody(std::string& body);
 
     void onEnabledChange(std::function<void(bool)> callback);
 
     static void setPscUniforms(ghoul::opengl::ProgramObject& program, const Camera& camera, const PowerScaledCoordinate& position);
 
 private:
-	properties::BoolProperty _enabled;
+    properties::BoolProperty _enabled;
     PowerScaledScalar boundingSphere_;
-	std::string _startTime;
-	std::string _endTime;
-	std::string _targetBody;
-	bool _hasBody;
-	bool _hasTimeInterval;
+    std::string _startTime;
+    std::string _endTime;
+    std::string _targetBody;
+    bool _hasBody;
+    bool _hasTimeInterval;
 };
 
 }  // namespace openspace
diff --git a/include/openspace/rendering/renderer.h b/include/openspace/rendering/renderer.h
index f0ee1f6d70..0a3113a3b1 100644
--- a/include/openspace/rendering/renderer.h
+++ b/include/openspace/rendering/renderer.h
@@ -33,15 +33,15 @@
 #include <map>
 
 namespace ghoul {
-	class Dictionary;
-	
+    class Dictionary;
+    
     namespace filesystem {
         class File;
     }
-	namespace opengl {
+    namespace opengl {
         class ProgramObject;
-		class Texture;
-	}
+        class Texture;
+    }
 }
 
 namespace openspace {
@@ -49,7 +49,7 @@ namespace openspace {
 class RenderableVolume;
 class Camera;
 class Scene;
-	
+    
 class Renderer {
 public:
     virtual void initialize() = 0;
@@ -60,14 +60,14 @@ public:
     virtual void setResolution(glm::ivec2 res) = 0;
 
     virtual void update() = 0;
-	virtual void render(float blackoutFactor, bool doPerformanceMeasurements) = 0;
+    virtual void render(float blackoutFactor, bool doPerformanceMeasurements) = 0;
     /**
      * Update render data
      * Responsible for calling renderEngine::setRenderData
      */
     virtual void updateRendererData() = 0;
     
-};		// Renderer
-}		// openspace
+};        // Renderer
+}        // openspace
 
-#endif 	// __RENDERER_H__
+#endif     // __RENDERER_H__
diff --git a/include/openspace/scene/scene.h b/include/openspace/scene/scene.h
index f70bbcabfe..ae5efd1511 100644
--- a/include/openspace/scene/scene.h
+++ b/include/openspace/scene/scene.h
@@ -65,7 +65,7 @@ public:
      * Load the scenegraph from the provided folder
      */
     void scheduleLoadSceneFile(const std::string& sceneDescriptionFilePath);
-	void clearSceneGraph();
+    void clearSceneGraph();
 
     void loadModule(const std::string& modulePath);
 
@@ -95,20 +95,20 @@ public:
      */
     SceneGraphNode* sceneGraphNode(const std::string& name) const;
 
-	std::vector<SceneGraphNode*> allSceneGraphNodes();
+    std::vector<SceneGraphNode*> allSceneGraphNodes();
 
-	/**
-	 * Returns the Lua library that contains all Lua functions available to change the
-	 * scene graph. The functions contained are
-	 * - openspace::luascriptfunctions::property_setValue
-	 * - openspace::luascriptfunctions::property_getValue
-	 * \return The Lua library that contains all Lua functions available to change the
-	 * scene graph
-	 */
-	static scripting::ScriptEngine::LuaLibrary luaLibrary();
+    /**
+     * Returns the Lua library that contains all Lua functions available to change the
+     * scene graph. The functions contained are
+     * - openspace::luascriptfunctions::property_setValue
+     * - openspace::luascriptfunctions::property_getValue
+     * \return The Lua library that contains all Lua functions available to change the
+     * scene graph
+     */
+    static scripting::ScriptEngine::LuaLibrary luaLibrary();
 
 private:
-	bool loadSceneInternal(const std::string& sceneDescriptionFilePath);
+    bool loadSceneInternal(const std::string& sceneDescriptionFilePath);
 
     void writePropertyDocumentation(const std::string& filename, const std::string& type);
 
@@ -120,10 +120,10 @@ private:
     //std::vector<SceneGraphNode*> _nodes;
     //std::map<std::string, SceneGraphNode*> _allNodes;
 
-	std::string _sceneGraphToLoad;
+    std::string _sceneGraphToLoad;
 
-	std::mutex _programUpdateLock;
-	std::set<ghoul::opengl::ProgramObject*> _programsToUpdate;
+    std::mutex _programUpdateLock;
+    std::set<ghoul::opengl::ProgramObject*> _programsToUpdate;
     std::vector<std::unique_ptr<ghoul::opengl::ProgramObject>> _programs;
 
     typedef std::map<std::string, ghoul::Dictionary> NodeMap;
diff --git a/include/openspace/scene/scenegraphnode.h b/include/openspace/scene/scenegraphnode.h
index e547159681..bb577fdd99 100644
--- a/include/openspace/scene/scenegraphnode.h
+++ b/include/openspace/scene/scenegraphnode.h
@@ -44,11 +44,11 @@ namespace openspace {
 
 class SceneGraphNode : public properties::PropertyOwner {
 public:
-	struct PerformanceRecord {
-		long long renderTime;  // time in ns
-		long long updateTimeRenderable;  // time in ns
-		long long updateTimeEphemeris;  // time in ns
-	};
+    struct PerformanceRecord {
+        long long renderTime;  // time in ns
+        long long updateTimeRenderable;  // time in ns
+        long long updateTimeEphemeris;  // time in ns
+    };
 
     static std::string RootNodeName;
 
@@ -61,19 +61,19 @@ public:
 
     static SceneGraphNode* createFromDictionary(const ghoul::Dictionary& dictionary);
 
-	bool initialize();
+    bool initialize();
     bool deinitialize();
 
     void update(const UpdateData& data);
     void evaluate(const Camera* camera, const psc& parentPosition = psc());
     void render(const RenderData& data, RendererTasks& tasks);
-	void updateCamera(Camera* camera) const;
+    void updateCamera(Camera* camera) const;
 
     //void addNode(SceneGraphNode* child);
 
     void addChild(SceneGraphNode* child);
     void setParent(SceneGraphNode* parent);
-	//bool abandonChild(SceneGraphNode* child);
+    //bool abandonChild(SceneGraphNode* child);
 
     const psc& position() const;
     psc worldPosition() const;
@@ -86,7 +86,7 @@ public:
 
     SceneGraphNode* childNode(const std::string& name);
 
-	const PerformanceRecord& performanceRecord() const { return _performanceRecord; }
+    const PerformanceRecord& performanceRecord() const { return _performanceRecord; }
 
     void setRenderable(Renderable* renderable);
     const Renderable* renderable() const;
@@ -101,11 +101,11 @@ public:
 private:
     bool sphereInsideFrustum(const psc& s_pos, const PowerScaledScalar& s_rad, const Camera* camera);
 
-	std::vector<SceneGraphNode*> _children;
+    std::vector<SceneGraphNode*> _children;
     SceneGraphNode* _parent;
     Ephemeris* _ephemeris;
 
-	PerformanceRecord _performanceRecord;
+    PerformanceRecord _performanceRecord;
 
     Renderable* _renderable;
     bool _renderableVisible;
diff --git a/include/openspace/scripting/scriptengine.h b/include/openspace/scripting/scriptengine.h
index 1857176ee7..feab50c7e7 100644
--- a/include/openspace/scripting/scriptengine.h
+++ b/include/openspace/scripting/scriptengine.h
@@ -58,26 +58,26 @@ public:
          * describing the function, and whether it should be shared in a parallel
          * connection (#parallelShared)
          */
-		struct Function {
+        struct Function {
             /// The name of the function
-			std::string name;
+            std::string name;
             /// The function pointer that is executed if the function is called
-			lua_CFunction function;
+            lua_CFunction function;
             /// A text describing the arugments to this function
-			std::string argumentText;
+            std::string argumentText;
             /// A help text describing what the function does/
-			std::string helpText;
+            std::string helpText;
             /// If <code>true</code>, this function will be shared with other parallel
             /// connections
             bool parallelShared;
-		};
+        };
         /// The name of the library
         std::string name;
         /// The list of all functions for this library
-		std::vector<Function> functions;
+        std::vector<Function> functions;
 
         /// Comparison function that compares two LuaLibrary%s name
-		bool operator<(const LuaLibrary& rhs) const;
+        bool operator<(const LuaLibrary& rhs) const;
     };
 
     /**
@@ -92,25 +92,25 @@ public:
      */
     void deinitialize();
     
-	void initializeLuaState(lua_State* state);
+    void initializeLuaState(lua_State* state);
 
-	void addLibrary(LuaLibrary library);
+    void addLibrary(LuaLibrary library);
     bool hasLibrary(const std::string& name);
     
     bool runScript(const std::string& script);
     bool runScriptFile(const std::string& filename);
 
-	bool writeDocumentation(const std::string& filename, const std::string& type) const;
+    bool writeDocumentation(const std::string& filename, const std::string& type) const;
 
-	void serialize(SyncBuffer* syncBuffer);
+    void serialize(SyncBuffer* syncBuffer);
 
-	void deserialize(SyncBuffer* syncBuffer);
+    void deserialize(SyncBuffer* syncBuffer);
 
-	void postSynchronizationPreDraw();
+    void postSynchronizationPreDraw();
 
-	void preSynchronization();
+    void preSynchronization();
 
-	void queueScript(const std::string &script);
+    void queueScript(const std::string &script);
     
     std::vector<std::string> cachedScripts();
 
@@ -122,7 +122,7 @@ public:
     void cacheScript(const std::string &library, const std::string &function, const std::string &script);
     
 private:
-	bool registerLuaLibrary(lua_State* state, const LuaLibrary& library);
+    bool registerLuaLibrary(lua_State* state, const LuaLibrary& library);
     void addLibraryFunctions(lua_State* state, const LuaLibrary& library, bool replace);
 
     bool isLibraryNameAllowed(lua_State* state, const std::string& name);
@@ -133,11 +133,11 @@ private:
     lua_State* _state = nullptr;
     std::set<LuaLibrary> _registeredLibraries;
     
-	//sync variables
-	std::mutex _mutex;
-	std::vector<std::string> _queuedScripts;
-	std::vector<std::string> _receivedScripts;
-	std::string _currentSyncedScript;
+    //sync variables
+    std::mutex _mutex;
+    std::vector<std::string> _queuedScripts;
+    std::vector<std::string> _receivedScripts;
+    std::string _currentSyncedScript;
     
     //parallel variables
     std::map<std::string, std::map<std::string, std::string>> _cachedScripts;
diff --git a/include/openspace/util/blockplaneintersectiongeometry.h b/include/openspace/util/blockplaneintersectiongeometry.h
index 8d3a1da983..58292c967f 100644
--- a/include/openspace/util/blockplaneintersectiongeometry.h
+++ b/include/openspace/util/blockplaneintersectiongeometry.h
@@ -48,8 +48,8 @@ private:
     void updateVertices();
     std::vector<float> _vertices;
     bool _initialized;
-	GLuint _vaoId;
-	GLuint _vBufferId;
+    GLuint _vaoId;
+    GLuint _vBufferId;
     glm::vec3 _size;
     glm::vec3 _normal;
     float _planeDistance;
diff --git a/include/openspace/util/boxgeometry.h b/include/openspace/util/boxgeometry.h
index 25eebe354a..ea16642a5a 100644
--- a/include/openspace/util/boxgeometry.h
+++ b/include/openspace/util/boxgeometry.h
@@ -39,8 +39,8 @@ public:
     bool initialize();
     void render();
  
-	GLuint _vaoId;
-	GLuint _vBufferId;
+    GLuint _vaoId;
+    GLuint _vBufferId;
     glm::vec3 _size;
 };
 
diff --git a/include/openspace/util/camera.h b/include/openspace/util/camera.h
index 6e63e1714d..de53056dbf 100644
--- a/include/openspace/util/camera.h
+++ b/include/openspace/util/camera.h
@@ -90,7 +90,7 @@ namespace openspace {
 //    mutable bool _viewMatrixIsDirty;
 //};
 
-	class SyncBuffer;
+    class SyncBuffer;
 
 class Camera {
 public:
@@ -99,38 +99,38 @@ public:
 
     void setPosition(psc pos);
     const psc& position() const;
-	
-	const psc& unsynchedPosition() const;
+    
+    const psc& unsynchedPosition() const;
 
-	void setModelMatrix(glm::mat4 modelMatrix);
-	const glm::mat4& modelMatrix() const;
+    void setModelMatrix(glm::mat4 modelMatrix);
+    const glm::mat4& modelMatrix() const;
 
-	void setViewMatrix(glm::mat4 viewMatrix);
-	const glm::mat4& viewMatrix() const;
+    void setViewMatrix(glm::mat4 viewMatrix);
+    const glm::mat4& viewMatrix() const;
 
-	void setProjectionMatrix(glm::mat4 projectionMatrix);
-	const glm::mat4& projectionMatrix() const;
+    void setProjectionMatrix(glm::mat4 projectionMatrix);
+    const glm::mat4& projectionMatrix() const;
 
     const glm::mat4& viewProjectionMatrix() const;
 
     void setCameraDirection(glm::vec3 cameraDirection);
     glm::vec3 cameraDirection() const;
 
-	void setFocusPosition(psc pos);
-	const psc& focusPosition() const;
+    void setFocusPosition(psc pos);
+    const psc& focusPosition() const;
 
-	void setViewRotationMatrix(glm::mat4 m);
-	const glm::mat4& viewRotationMatrix() const;
+    void setViewRotationMatrix(glm::mat4 m);
+    const glm::mat4& viewRotationMatrix() const;
     void compileViewRotationMatrix();
 
     void rotate(const glm::quat& rotation);
     void setRotation(glm::quat rotation);
    // const glm::quat& rotation() const;
-	void setRotation(glm::mat4 rotation);
+    void setRotation(glm::mat4 rotation);
 
-	const glm::vec3& viewDirection() const;
+    const glm::vec3& viewDirection() const;
 
-	const float& maxFov() const;
+    const float& maxFov() const;
     const float& sinMaxFov() const;
     void setMaxFov(float fov);
     void setScaling(glm::vec2 scaling);
@@ -139,43 +139,43 @@ public:
     void setLookUpVector(glm::vec3 lookUp);
     const glm::vec3& lookUpVector() const;
 
-	void postSynchronizationPreDraw();
-	void preSynchronization();
-	void serialize(SyncBuffer* syncBuffer);
-	void deserialize(SyncBuffer* syncBuffer);
+    void postSynchronizationPreDraw();
+    void preSynchronization();
+    void serialize(SyncBuffer* syncBuffer);
+    void deserialize(SyncBuffer* syncBuffer);
 
 private:
     float _maxFov;
     float _sinMaxFov;
     mutable glm::mat4 _viewProjectionMatrix;
-	glm::mat4 _modelMatrix;
-	glm::mat4 _viewMatrix;
-	glm::mat4 _projectionMatrix;
+    glm::mat4 _modelMatrix;
+    glm::mat4 _viewMatrix;
+    glm::mat4 _projectionMatrix;
     mutable bool _dirtyViewProjectionMatrix;
     glm::vec3 _viewDirection;
     glm::vec3 _cameraDirection;
-	psc _focusPosition;
+    psc _focusPosition;
     // glm::quat _viewRotation;
     
     glm::vec3 _lookUp;
 
-	mutable std::mutex _mutex;
-	
-	//local variables
-	glm::mat4 _localViewRotationMatrix;
-	glm::vec2 _localScaling;
-	psc _localPosition;
+    mutable std::mutex _mutex;
+    
+    //local variables
+    glm::mat4 _localViewRotationMatrix;
+    glm::vec2 _localScaling;
+    psc _localPosition;
 
-	//shared copies of local variables
-	glm::vec2 _sharedScaling;
-	psc _sharedPosition;
-	glm::mat4 _sharedViewRotationMatrix;
+    //shared copies of local variables
+    glm::vec2 _sharedScaling;
+    psc _sharedPosition;
+    glm::mat4 _sharedViewRotationMatrix;
 
-	//synced copies of local variables
-	glm::vec2 _syncedScaling;
-	psc _syncedPosition;
-	glm::mat4 _syncedViewRotationMatrix;
-	
+    //synced copies of local variables
+    glm::vec2 _syncedScaling;
+    psc _syncedPosition;
+    glm::mat4 _syncedViewRotationMatrix;
+    
 };
 
 } // namespace openspace
diff --git a/include/openspace/util/mouse.h b/include/openspace/util/mouse.h
index 4b8fa4fa22..32c399bbf8 100644
--- a/include/openspace/util/mouse.h
+++ b/include/openspace/util/mouse.h
@@ -61,8 +61,8 @@ namespace openspace {
 
 enum class MouseAction {
     Release = 0,
-	Press = 1,
-	Repeat = 2
+    Press = 1,
+    Repeat = 2
 };
 
 // The X11 library header files define Button1-Button5 as defines, so they have to be
@@ -85,7 +85,7 @@ enum class MouseButton {
     Button7 = 6,
     Button8 = 8,
     Last = Button8,
-	Left = Button1,
+    Left = Button1,
     Right = Button2,
     Middle = Button3
 };
diff --git a/include/openspace/util/powerscaledcoordinate.h b/include/openspace/util/powerscaledcoordinate.h
index d0a655635d..ec79a38931 100644
--- a/include/openspace/util/powerscaledcoordinate.h
+++ b/include/openspace/util/powerscaledcoordinate.h
@@ -44,7 +44,7 @@ public:
     PowerScaledCoordinate();
 
     PowerScaledCoordinate(PowerScaledCoordinate&& rhs);
-	PowerScaledCoordinate(const PowerScaledCoordinate& rhs);
+    PowerScaledCoordinate(const PowerScaledCoordinate& rhs);
 
     // Sets the power scaled coordinates directly
     PowerScaledCoordinate(glm::vec4 v);
@@ -61,11 +61,11 @@ public:
     // returns the rescaled, "normal" coordinates
     glm::vec3 vec3() const;
 
-	// return the full psc as dvec4()
-	 glm::dvec4 dvec4() const;
+    // return the full psc as dvec4()
+     glm::dvec4 dvec4() const;
 
-	// rescaled return as dvec3
-	glm::dvec3 dvec3() const;
+    // rescaled return as dvec3
+    glm::dvec3 dvec3() const;
 
     // length of the vector as a pss
     PowerScaledScalar length() const;
diff --git a/include/openspace/util/powerscaledscalar.h b/include/openspace/util/powerscaledscalar.h
index b3c5300075..745a3eaa68 100644
--- a/include/openspace/util/powerscaledscalar.h
+++ b/include/openspace/util/powerscaledscalar.h
@@ -36,52 +36,52 @@ namespace openspace {
 
 class PowerScaledScalar {
 public:
-	// constructors
-	PowerScaledScalar();
-	PowerScaledScalar(const glm::vec2 &v);
-	PowerScaledScalar(float f1, float f2);
-	static PowerScaledScalar CreatePSS(double d1);
+    // constructors
+    PowerScaledScalar();
+    PowerScaledScalar(const glm::vec2 &v);
+    PowerScaledScalar(float f1, float f2);
+    static PowerScaledScalar CreatePSS(double d1);
 
-	const glm::vec2& vec2() const;
-	float lengthf() const;
+    const glm::vec2& vec2() const;
+    float lengthf() const;
 
-	// operator overloading
-	PowerScaledScalar& operator=(const PowerScaledScalar& rhs);
-	PowerScaledScalar& operator+=(const PowerScaledScalar& rhs);
-	const PowerScaledScalar operator+(const PowerScaledScalar& rhs) const;
-	PowerScaledScalar& operator-=(const PowerScaledScalar& rhs);
-	const PowerScaledScalar operator-(const PowerScaledScalar& rhs) const;
-	PowerScaledScalar& operator*=(const PowerScaledScalar& rhs);
-	const PowerScaledScalar operator*(const PowerScaledScalar& rhs) const;
-	PowerScaledScalar& operator*=(const float& rhs);
-	const PowerScaledScalar operator*(const float& rhs) const;
-	float& operator[](unsigned int idx);
-	float operator[](unsigned int idx) const;
+    // operator overloading
+    PowerScaledScalar& operator=(const PowerScaledScalar& rhs);
+    PowerScaledScalar& operator+=(const PowerScaledScalar& rhs);
+    const PowerScaledScalar operator+(const PowerScaledScalar& rhs) const;
+    PowerScaledScalar& operator-=(const PowerScaledScalar& rhs);
+    const PowerScaledScalar operator-(const PowerScaledScalar& rhs) const;
+    PowerScaledScalar& operator*=(const PowerScaledScalar& rhs);
+    const PowerScaledScalar operator*(const PowerScaledScalar& rhs) const;
+    PowerScaledScalar& operator*=(const float& rhs);
+    const PowerScaledScalar operator*(const float& rhs) const;
+    float& operator[](unsigned int idx);
+    float operator[](unsigned int idx) const;
 
-	// comparison
-	bool operator==(const PowerScaledScalar& other) const;
-	bool operator<(const PowerScaledScalar& other) const;
-	bool operator>(const PowerScaledScalar& other) const;
-	bool operator<=(const PowerScaledScalar& other) const;
-	bool operator>=(const PowerScaledScalar& other) const;
-	
-	bool operator==(double other) const;
-	bool operator<(double other) const;
-	bool operator>(double other) const;
-	bool operator<=(double other) const;
-	bool operator>=(double other) const;
+    // comparison
+    bool operator==(const PowerScaledScalar& other) const;
+    bool operator<(const PowerScaledScalar& other) const;
+    bool operator>(const PowerScaledScalar& other) const;
+    bool operator<=(const PowerScaledScalar& other) const;
+    bool operator>=(const PowerScaledScalar& other) const;
+    
+    bool operator==(double other) const;
+    bool operator<(double other) const;
+    bool operator>(double other) const;
+    bool operator<=(double other) const;
+    bool operator>=(double other) const;
 
-	// glm integration
-	PowerScaledScalar& operator=(const glm::vec2& rhs);
-	PowerScaledScalar& operator=(float rhs);
+    // glm integration
+    PowerScaledScalar& operator=(const glm::vec2& rhs);
+    PowerScaledScalar& operator=(float rhs);
     
     friend std::ostream& operator<<(std::ostream& os, const PowerScaledScalar& rhs);
-	
-	// allow the power scaled coordinates to access private members
-	friend class PowerScaledCoordinate;
+    
+    // allow the power scaled coordinates to access private members
+    friend class PowerScaledCoordinate;
 private:
-	// float vector used when returning float values
-	glm::vec2 _data;
+    // float vector used when returning float values
+    glm::vec2 _data;
 
 };
 
diff --git a/include/openspace/util/powerscaledsphere.h b/include/openspace/util/powerscaledsphere.h
index 57a606f03a..26d36eb2ce 100644
--- a/include/openspace/util/powerscaledsphere.h
+++ b/include/openspace/util/powerscaledsphere.h
@@ -37,9 +37,9 @@ class PowerScaledSphere {
 public:
     // initializers
     PowerScaledSphere(const PowerScaledScalar& radius, 
-		int segments = 8);
-	PowerScaledSphere(properties::Vec4Property &radius,
-		int segments, std::string planetName);
+        int segments = 8);
+    PowerScaledSphere(properties::Vec4Property &radius,
+        int segments, std::string planetName);
 
     ~PowerScaledSphere();
     PowerScaledSphere(const PowerScaledSphere& cpy);
@@ -57,9 +57,9 @@ public:
         GLubyte padding[28];  // Pads the struct out to 64 bytes for performance increase
     } Vertex;
 
-	GLuint _vaoID;
-	GLuint _vBufferID;
-	GLuint _iBufferID;
+    GLuint _vaoID;
+    GLuint _vBufferID;
+    GLuint _iBufferID;
 
     unsigned int _isize;
     unsigned int _vsize;
diff --git a/include/openspace/util/progressbar.h b/include/openspace/util/progressbar.h
index 0faa543142..ee8567efcc 100644
--- a/include/openspace/util/progressbar.h
+++ b/include/openspace/util/progressbar.h
@@ -31,18 +31,18 @@ namespace openspace {
 
 class ProgressBar {
 public:
-	ProgressBar(int end, int width = 70, std::ostream& stream = std::cout);
-	~ProgressBar();
+    ProgressBar(int end, int width = 70, std::ostream& stream = std::cout);
+    ~ProgressBar();
 
     ProgressBar& operator=(const ProgressBar& rhs) = delete;
 
-	void print(int current);
+    void print(int current);
 
 private:
-	int _width;
-	int _previous;
-	int _end;
-	std::ostream& _stream;
+    int _width;
+    int _previous;
+    int _end;
+    std::ostream& _stream;
 
 };
 
diff --git a/include/openspace/util/screenlog.h b/include/openspace/util/screenlog.h
index 6372926672..01c9e9283e 100644
--- a/include/openspace/util/screenlog.h
+++ b/include/openspace/util/screenlog.h
@@ -45,22 +45,22 @@ public:
      * This struct stores the incoming log entries with their #level, #timeString,
      * #category, #message, and the generated #timeStamp used for the expiry calculation.
      */
-	struct LogEntry {
+    struct LogEntry {
         /// The ghoul::logging::LogManager::LogLevel of the log message
-		LogLevel level;
+        LogLevel level;
         
         /// The timepoint when the log message arrived at the ScreenLog
         std::chrono::time_point<std::chrono::steady_clock> timeStamp;
         
         /// The time string as retrieved from the log message
-		std::string timeString;
+        std::string timeString;
         
         /// The category as retrieved from the log message
-		std::string category;
+        std::string category;
         
         /// The actual message of the log entry
-		std::string message;
-	};
+        std::string message;
+    };
 
     /**
      * Constructor that creates a ScreenLog with the provided \p timeToLive, and the
@@ -80,8 +80,8 @@ public:
      * \param category The category of the log message
      * \param message The actual log message that was transmitted
      */
-	void log(ghoul::logging::LogManager::LogLevel level, const std::string& category,
-		const std::string& message) override;
+    void log(ghoul::logging::LogManager::LogLevel level, const std::string& category,
+        const std::string& message) override;
     
     /**
      * This method removes all the stored LogEntry%s that have expired, calculated by
@@ -100,7 +100,7 @@ public:
 
 private:
     /// The list of all LogEntry%s stored by this ScreenLog
-	std::vector<LogEntry> _entries;
+    std::vector<LogEntry> _entries;
 
     /// The time-to-live for the LogEntry%s in this ScreenLog. Is used by the
     /// #removeExpiredEntries method to remove expired entries.
diff --git a/include/openspace/util/time.h b/include/openspace/util/time.h
index 44f279bc8d..992d2804e3 100644
--- a/include/openspace/util/time.h
+++ b/include/openspace/util/time.h
@@ -58,85 +58,85 @@ class SyncBuffer;
 
 class Time {
 public:
-	/**
-	 * Initializes the Time singleton.
-	 * \return <code>true</code> if the initialization succeeded, <code>false</code>
-	 * otherwise
+    /**
+     * Initializes the Time singleton.
+     * \return <code>true</code> if the initialization succeeded, <code>false</code>
+     * otherwise
      * \pre The Time singleton must not have been initialized
-	 */
-	static void initialize();
+     */
+    static void initialize();
 
-	/**
-	 * Deinitializes the Time singleton. This method will not unload the kernel that was
-	 * possibly loaded during the initialize method.
+    /**
+     * Deinitializes the Time singleton. This method will not unload the kernel that was
+     * possibly loaded during the initialize method.
      * \pre The Time singleton must have been initialized
-	 */
-	static void deinitialize();
+     */
+    static void deinitialize();
 
-	/**
-	 * Returns the reference to the Time singleton object.
-	 * \return The reference to the Time singleton object
+    /**
+     * Returns the reference to the Time singleton object.
+     * \return The reference to the Time singleton object
      * \pre The Time singleton must have been initialized
-	 */
+     */
     static Time& ref();
 
-	/**
-	 * Returns <code>true</code> if the singleton has been successfully initialized,
-	 * <code>false</code> otherwise
-	 * \return <code>true</code> if the singleton has been successfully initialized,
-	 * <code>false</code> otherwise
-	 */
-	static bool isInitialized();
-	
-	/**
-	 * Sets the current time to the specified value in seconds past the J2000 epoch. This
-	 * value can be negative to represent dates before the epoch.
-	 * \param value The number of seconds after the J2000 epoch
+    /**
+     * Returns <code>true</code> if the singleton has been successfully initialized,
+     * <code>false</code> otherwise
+     * \return <code>true</code> if the singleton has been successfully initialized,
+     * <code>false</code> otherwise
+     */
+    static bool isInitialized();
+    
+    /**
+     * Sets the current time to the specified value in seconds past the J2000 epoch. This
+     * value can be negative to represent dates before the epoch.
+     * \param value The number of seconds after the J2000 epoch
      * \param requireJump Whether or not the time change is big enough to require a
      * time-jump; defaults to true as most calls to set time will require recomputation of
      * planetary paths etc.
-	 */
-	void setTime(double value, bool requireJump = true);
+     */
+    void setTime(double value, bool requireJump = true);
 
-	/**
-	 * Sets the current time to the specified value given as a Spice compliant string as
-	 * described in the Spice documentation
-	 * (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html)
-	 * \param time The time to be set as a date string
+    /**
+     * Sets the current time to the specified value given as a Spice compliant string as
+     * described in the Spice documentation
+     * (http://naif.jpl.nasa.gov/pub/naif/toolkit_docs/C/cspice/str2et_c.html)
+     * \param time The time to be set as a date string
      * \param requireJump Whether or not the time change is big enough to require a
      * time-jump; defaults to true as most calls to set time will require recomputation of
      * planetary paths etc.
-	 */
-	void setTime(std::string time, bool requireJump = true);
+     */
+    void setTime(std::string time, bool requireJump = true);
 
-	/**
-	 * Returns the current time as the number of seconds past the J2000 epoch. If the
-	 * current time is a date before that epoch, the returned value will be negative.
-	 * \return The current time as the number of seconds past the J2000 epoch
-	 */
-	double currentTime() const;
+    /**
+     * Returns the current time as the number of seconds past the J2000 epoch. If the
+     * current time is a date before that epoch, the returned value will be negative.
+     * \return The current time as the number of seconds past the J2000 epoch
+     */
+    double currentTime() const;
 
-	/**
-	 * Returns the current time as a formatted date string compliant with ISO 8601 and
-	 * thus also compliant with the Spice library.
-	 * \return The current time as a formatted date string
-	 */
-	std::string currentTimeUTC() const;
+    /**
+     * Returns the current time as a formatted date string compliant with ISO 8601 and
+     * thus also compliant with the Spice library.
+     * \return The current time as a formatted date string
+     */
+    std::string currentTimeUTC() const;
 
-	/**
-	 * Sets the delta time value that is the number of seconds that should pass for each
-	 * real-time second. This value is used in the advanceTime(double) method to easily
-	 * advance the simulation time.
-	 * \param deltaT The number of seconds that should pass for each real-time second
-	 */
-	void setDeltaTime(double deltaT);
+    /**
+     * Sets the delta time value that is the number of seconds that should pass for each
+     * real-time second. This value is used in the advanceTime(double) method to easily
+     * advance the simulation time.
+     * \param deltaT The number of seconds that should pass for each real-time second
+     */
+    void setDeltaTime(double deltaT);
 
-	/**
-	 * Returns the delta time, that is the number of seconds that pass in the simulation
-	 * for each real-time second
-	 * \return The number of seconds that pass for each real-time second
-	 */
-	double deltaTime() const;
+    /**
+     * Returns the delta time, that is the number of seconds that pass in the simulation
+     * for each real-time second
+     * \return The number of seconds that pass for each real-time second
+     */
+    double deltaTime() const;
 
     /**
      * Sets the pause function, i.e. setting the deltaTime to 0 (<code>pause</code> = 
@@ -156,67 +156,67 @@ public:
      */
     bool togglePause();
 
-	/**
-	 * Advances the simulation time using the deltaTime() and the <code>tickTime</code>.
-	 * The deltaTime() is the number of simulation seconds that pass for each real-time
-	 * second. <code>tickTime</code> is the number of real-time seconds that passed since
-	 * the last call to this method. If this method is called in the render loop, the
-	 * <code>tickTime</code> should be equivalent to the frame time.
-	 * \param tickTime The number of real-time seconds that passed since the last call
-	 * to this method
-	 * \return The new time value after advancing the time
-	 */
-	double advanceTime(double tickTime);
+    /**
+     * Advances the simulation time using the deltaTime() and the <code>tickTime</code>.
+     * The deltaTime() is the number of simulation seconds that pass for each real-time
+     * second. <code>tickTime</code> is the number of real-time seconds that passed since
+     * the last call to this method. If this method is called in the render loop, the
+     * <code>tickTime</code> should be equivalent to the frame time.
+     * \param tickTime The number of real-time seconds that passed since the last call
+     * to this method
+     * \return The new time value after advancing the time
+     */
+    double advanceTime(double tickTime);
 
-	void serialize(SyncBuffer* syncBuffer);
+    void serialize(SyncBuffer* syncBuffer);
 
-	void deserialize(SyncBuffer* syncBuffer);
+    void deserialize(SyncBuffer* syncBuffer);
 
-	void postSynchronizationPreDraw();
+    void postSynchronizationPreDraw();
 
-	void preSynchronization();
+    void preSynchronization();
 
-	bool timeJumped() const;
+    bool timeJumped() const;
 
-	void setTimeJumped(bool jumped);
+    void setTimeJumped(bool jumped);
     
     bool paused() const;
 
-	/**
-	 * Returns the Lua library that contains all Lua functions available to change the
-	 * current time, retrieve the current time etc. The functions contained are
-	 * - openspace::luascriptfunctions::time_setDeltaTime
-	 * - openspace::luascriptfunctions::time_deltaTime
-	 * - openspace::luascriptfunctions::time_setTime
-	 * - openspace::luascriptfunctions::time_currentTime
-	 * - openspace::luascriptfunctions::time_currentTimeUTC
-	 * \return The Lua library that contains all Lua functions available to change the
-	 * Time singleton
-	 */
-	static scripting::ScriptEngine::LuaLibrary luaLibrary();
+    /**
+     * Returns the Lua library that contains all Lua functions available to change the
+     * current time, retrieve the current time etc. The functions contained are
+     * - openspace::luascriptfunctions::time_setDeltaTime
+     * - openspace::luascriptfunctions::time_deltaTime
+     * - openspace::luascriptfunctions::time_setTime
+     * - openspace::luascriptfunctions::time_currentTime
+     * - openspace::luascriptfunctions::time_currentTimeUTC
+     * \return The Lua library that contains all Lua functions available to change the
+     * Time singleton
+     */
+    static scripting::ScriptEngine::LuaLibrary luaLibrary();
 
 private:
-	static Time* _instance; ///< The singleton instance
-		
-	//local copies
+    static Time* _instance; ///< The singleton instance
+        
+    //local copies
     /// The time stored as the number of seconds past the J2000 epoch
-	double _time = -1.0;
-	double _dt = 1.0;
-	bool _timeJumped = false;
+    double _time = -1.0;
+    double _dt = 1.0;
+    bool _timeJumped = false;
     bool _timePaused = false;
     bool _jockeHasToFixThisLater;
 
-	//shared copies
-	double _sharedTime = -1.0;
-	double _sharedDt = 1.0;
-	bool _sharedTimeJumped = false;
+    //shared copies
+    double _sharedTime = -1.0;
+    double _sharedDt = 1.0;
+    bool _sharedTimeJumped = false;
 
-	//synced copies
-	double _syncedTime = -1.0;
-	double _syncedDt = 1.0;
-	bool _syncedTimeJumped = false;
-	
-	std::mutex _syncMutex;
+    //synced copies
+    double _syncedTime = -1.0;
+    double _syncedDt = 1.0;
+    bool _syncedTimeJumped = false;
+    
+    std::mutex _syncMutex;
 };
 
 } // namespace openspace
diff --git a/include/openspace/util/updatestructures.h b/include/openspace/util/updatestructures.h
index 1a2e43f1f2..08ea000572 100644
--- a/include/openspace/util/updatestructures.h
+++ b/include/openspace/util/updatestructures.h
@@ -37,16 +37,16 @@ struct InitializeData {
 };
 
 struct UpdateData {
-	double time;
+    double time;
     bool isTimeJump;
-	double delta;
-	bool doPerformanceMeasurement;
+    double delta;
+    bool doPerformanceMeasurement;
 };
 
 struct RenderData {
-	const Camera& camera;
-	psc position;
-	bool doPerformanceMeasurement;
+    const Camera& camera;
+    psc position;
+    bool doPerformanceMeasurement;
 };
 
 struct RaycasterTask {
diff --git a/modules/base/ephemeris/dynamicephemeris.cpp b/modules/base/ephemeris/dynamicephemeris.cpp
index 6deb32922e..4efb8274fc 100644
--- a/modules/base/ephemeris/dynamicephemeris.cpp
+++ b/modules/base/ephemeris/dynamicephemeris.cpp
@@ -48,7 +48,7 @@ const psc& DynamicEphemeris::position() const {
 }
 
 void DynamicEphemeris::setPosition(psc pos) {
-	_position = pos;
+    _position = pos;
 }
 
 void DynamicEphemeris::update(const UpdateData&) {}
diff --git a/modules/base/ephemeris/dynamicephemeris.h b/modules/base/ephemeris/dynamicephemeris.h
index fdb857523c..f6d679d7dd 100644
--- a/modules/base/ephemeris/dynamicephemeris.h
+++ b/modules/base/ephemeris/dynamicephemeris.h
@@ -35,8 +35,8 @@ public:
                                 = ghoul::Dictionary());
     virtual ~DynamicEphemeris();
     virtual const psc& position() const;
-	virtual void update(const UpdateData& data) override;
-	void setPosition(psc pos);
+    virtual void update(const UpdateData& data) override;
+    void setPosition(psc pos);
 private:
     psc _position;
 };
diff --git a/modules/base/ephemeris/spiceephemeris.cpp b/modules/base/ephemeris/spiceephemeris.cpp
index d597ea96a4..be78d1238c 100644
--- a/modules/base/ephemeris/spiceephemeris.cpp
+++ b/modules/base/ephemeris/spiceephemeris.cpp
@@ -29,7 +29,7 @@
 
 namespace {
     const std::string _loggerCat = "SpiceEphemeris";
-	//const std::string keyGhosting = "EphmerisGhosting";
+    //const std::string keyGhosting = "EphmerisGhosting";
 
     const std::string KeyBody = "Body";
     const std::string KeyOrigin = "Observer";
@@ -42,7 +42,7 @@ SpiceEphemeris::SpiceEphemeris(const ghoul::Dictionary& dictionary)
     : _targetName("")
     , _originName("")
     , _position()
-	, _kernelsLoadedSuccessfully(true)
+    , _kernelsLoadedSuccessfully(true)
 {
     const bool hasBody = dictionary.getValue(KeyBody, _targetName);
     if (!hasBody)
@@ -52,15 +52,15 @@ SpiceEphemeris::SpiceEphemeris(const ghoul::Dictionary& dictionary)
     if (!hasObserver)
         LERROR("SpiceEphemeris does not contain the key '" << KeyOrigin << "'");
 
-	//dictionary.getValue(keyGhosting, _ghosting);
+    //dictionary.getValue(keyGhosting, _ghosting);
 
-	ghoul::Dictionary kernels;
-	dictionary.getValue(KeyKernels, kernels);
-	for (size_t i = 1; i <= kernels.size(); ++i) {
-		std::string kernel;
-		bool success = kernels.getValue(std::to_string(i), kernel);
-		if (!success)
-			LERROR("'" << KeyKernels << "' has to be an array-style table");
+    ghoul::Dictionary kernels;
+    dictionary.getValue(KeyKernels, kernels);
+    for (size_t i = 1; i <= kernels.size(); ++i) {
+        std::string kernel;
+        bool success = kernels.getValue(std::to_string(i), kernel);
+        if (!success)
+            LERROR("'" << KeyKernels << "' has to be an array-style table");
 
         try {
             SpiceManager::ref().loadKernel(kernel);
@@ -70,7 +70,7 @@ SpiceEphemeris::SpiceEphemeris(const ghoul::Dictionary& dictionary)
             LERROR("Could not load SPICE kernel: " << e.what());
             _kernelsLoadedSuccessfully = false;
         }
-	}
+    }
 }
     
 const psc& SpiceEphemeris::position() const {
@@ -78,21 +78,21 @@ const psc& SpiceEphemeris::position() const {
 }
 
 void SpiceEphemeris::update(const UpdateData& data) {
-	if (!_kernelsLoadedSuccessfully)
-		return;
+    if (!_kernelsLoadedSuccessfully)
+        return;
 
-	double lightTime = 0.0;
-	glm::dvec3 position = SpiceManager::ref().targetPosition(_targetName, _originName, "GALACTIC", {}, data.time, lightTime);
-	
-	//double interval = openspace::ImageSequencer::ref().getIntervalLength();
-	//if (_ghosting == "TRUE" && interval > 60){
-	//	double _time = openspace::ImageSequencer::ref().getNextCaptureTime();
-	//	SpiceManager::ref().getTargetPosition(_targetName, _originName,
-	//		"GALACTIC", "NONE", _time, position, lightTime);
-	//}
-	//
-	_position = psc::CreatePowerScaledCoordinate(position.x, position.y, position.z);
-	_position[3] += 3;
+    double lightTime = 0.0;
+    glm::dvec3 position = SpiceManager::ref().targetPosition(_targetName, _originName, "GALACTIC", {}, data.time, lightTime);
+    
+    //double interval = openspace::ImageSequencer::ref().getIntervalLength();
+    //if (_ghosting == "TRUE" && interval > 60){
+    //    double _time = openspace::ImageSequencer::ref().getNextCaptureTime();
+    //    SpiceManager::ref().getTargetPosition(_targetName, _originName,
+    //        "GALACTIC", "NONE", _time, position, lightTime);
+    //}
+    //
+    _position = psc::CreatePowerScaledCoordinate(position.x, position.y, position.z);
+    _position[3] += 3;
 }
 
 } // namespace openspace
\ No newline at end of file
diff --git a/modules/base/ephemeris/spiceephemeris.h b/modules/base/ephemeris/spiceephemeris.h
index eff6ddbe78..cb833a06cd 100644
--- a/modules/base/ephemeris/spiceephemeris.h
+++ b/modules/base/ephemeris/spiceephemeris.h
@@ -35,15 +35,15 @@ class SpiceEphemeris : public Ephemeris {
 public:
     SpiceEphemeris(const ghoul::Dictionary& dictionary);
     const psc& position() const;
-	void update(const UpdateData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
     std::string _targetName;
     std::string _originName;
     psc _position;
-	bool _kernelsLoadedSuccessfully;
-	//std::string _ghosting;
-	std::string _name;
+    bool _kernelsLoadedSuccessfully;
+    //std::string _ghosting;
+    std::string _name;
 };
     
 } // namespace openspace
diff --git a/modules/base/ephemeris/staticephemeris.h b/modules/base/ephemeris/staticephemeris.h
index 0f372e3b45..ed26db99de 100644
--- a/modules/base/ephemeris/staticephemeris.h
+++ b/modules/base/ephemeris/staticephemeris.h
@@ -35,7 +35,7 @@ public:
                                 = ghoul::Dictionary());
     virtual ~StaticEphemeris();
     virtual const psc& position() const;
-	virtual void update(const UpdateData& data) override;
+    virtual void update(const UpdateData& data) override;
 private:
     psc _position;
 };
diff --git a/modules/base/rendering/modelgeometry.cpp b/modules/base/rendering/modelgeometry.cpp
index bb5d1eab15..0285598fa0 100644
--- a/modules/base/rendering/modelgeometry.cpp
+++ b/modules/base/rendering/modelgeometry.cpp
@@ -31,29 +31,29 @@
 
 namespace {
     const std::string _loggerCat = "ModelGeometry";
-	const std::string keyGeomModelFile = "GeometryFile";
-	const int8_t CurrentCacheVersion = 3;
+    const std::string keyGeomModelFile = "GeometryFile";
+    const int8_t CurrentCacheVersion = 3;
     const std::string keyType = "Type";
-	const std::string keyName = "Name";
-	const std::string keySize = "Magnification";
+    const std::string keyName = "Name";
+    const std::string keySize = "Magnification";
 }
 
 namespace openspace {
 namespace modelgeometry {
 
 ModelGeometry* ModelGeometry::createFromDictionary(const ghoul::Dictionary& dictionary) {
-	std::string geometryType;
-	const bool success = dictionary.getValue(
-		keyType, geometryType);
-	if (!success) {
+    std::string geometryType;
+    const bool success = dictionary.getValue(
+        keyType, geometryType);
+    if (!success) {
         LERROR("ModelGeometry did not contain a correct value of the key '"
-			<< keyType << "'");
+            << keyType << "'");
         return nullptr;
-	}
-	ghoul::TemplateFactory<ModelGeometry>* factory
-		= FactoryManager::ref().factory<ModelGeometry>();
+    }
+    ghoul::TemplateFactory<ModelGeometry>* factory
+        = FactoryManager::ref().factory<ModelGeometry>();
 
-	ModelGeometry* result = factory->create(geometryType, dictionary);
+    ModelGeometry* result = factory->create(geometryType, dictionary);
     if (result == nullptr) {
         LERROR("Failed to create a ModelGeometry object of type '" << geometryType
                                                                     << "'");
@@ -65,27 +65,27 @@ ModelGeometry* ModelGeometry::createFromDictionary(const ghoul::Dictionary& dict
 ModelGeometry::ModelGeometry(const ghoul::Dictionary& dictionary)
     : _parent(nullptr)
     , _magnification("magnification", "Magnification", 0.f, 0.f, 10.f)
-	, _mode(GL_TRIANGLES)
+    , _mode(GL_TRIANGLES)
 {
-	setName("ModelGeometry");
+    setName("ModelGeometry");
 
-	std::string name;
-	bool success = dictionary.getValue(keyName, name);
-	ghoul_assert(success, "Name tag was not present");
+    std::string name;
+    bool success = dictionary.getValue(keyName, name);
+    ghoul_assert(success, "Name tag was not present");
 
     if (dictionary.hasKeyAndValue<double>(keySize))
         _magnification = static_cast<float>(dictionary.value<double>(keySize));
 
-	success = dictionary.getValue(keyGeomModelFile, _file);
-	if (!success) {
-		LERROR("Geometric Model file of '" << name << "' did not provide a key '"
-			<< keyGeomModelFile << "'");
-	}
-	_file = FileSys.absolutePath(_file);
+    success = dictionary.getValue(keyGeomModelFile, _file);
+    if (!success) {
+        LERROR("Geometric Model file of '" << name << "' did not provide a key '"
+            << keyGeomModelFile << "'");
+    }
+    _file = FileSys.absolutePath(_file);
 
     if (!FileSys.fileExists(_file, ghoul::filesystem::FileSystem::RawPath::Yes))
-		LERROR("Could not load the geometric model file '" << _file << "': File not found");
-	
+        LERROR("Could not load the geometric model file '" << _file << "': File not found");
+    
 
     addProperty(_magnification);
 }
@@ -94,53 +94,53 @@ ModelGeometry::~ModelGeometry() {
 }
 
 void ModelGeometry::render() {
-	glBindVertexArray(_vaoID);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
-	glDrawElements(_mode, static_cast<GLsizei>(_indices.size()), GL_UNSIGNED_INT, 0);
-	glBindVertexArray(0);
+    glBindVertexArray(_vaoID);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
+    glDrawElements(_mode, static_cast<GLsizei>(_indices.size()), GL_UNSIGNED_INT, 0);
+    glBindVertexArray(0);
 }
 
 void ModelGeometry::changeRenderMode(const GLenum mode) {
-	_mode = mode;
+    _mode = mode;
 }
 
 bool ModelGeometry::initialize(Renderable* parent) {
     _parent = parent;
-	PowerScaledScalar ps = PowerScaledScalar(1.0, 0.0); // will set proper bounding soon.
-	_parent->setBoundingSphere(ps);
+    PowerScaledScalar ps = PowerScaledScalar(1.0, 0.0); // will set proper bounding soon.
+    _parent->setBoundingSphere(ps);
 
-	if (_vertices.empty())
-		return false;
-	glGenVertexArrays(1, &_vaoID);
-	glGenBuffers(1, &_vbo);
-	glGenBuffers(1, &_ibo);
+    if (_vertices.empty())
+        return false;
+    glGenVertexArrays(1, &_vaoID);
+    glGenBuffers(1, &_vbo);
+    glGenBuffers(1, &_ibo);
 
-	glBindVertexArray(_vaoID);
-	glBindBuffer(GL_ARRAY_BUFFER, _vbo);
-	glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(Vertex), _vertices.data(), GL_STATIC_DRAW);
+    glBindVertexArray(_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
+    glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(Vertex), _vertices.data(), GL_STATIC_DRAW);
 
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, location)));
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex)));
-	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, location)));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex)));
+    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
 
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(int), _indices.data(), GL_STATIC_DRAW);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, _indices.size() * sizeof(int), _indices.data(), GL_STATIC_DRAW);
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
     return true;
 }
 
 void ModelGeometry::deinitialize() {
-	glDeleteBuffers(1, &_vbo);
-	glDeleteVertexArrays(1, &_vaoID);
-	glDeleteBuffers(1, &_ibo);
+    glDeleteBuffers(1, &_vbo);
+    glDeleteVertexArrays(1, &_vaoID);
+    glDeleteBuffers(1, &_ibo);
 }
 
 bool ModelGeometry::loadObj(const std::string& filename) {
@@ -235,19 +235,19 @@ bool ModelGeometry::loadCachedFile(const std::string& filename) {
 }
 
 bool ModelGeometry::getVertices(std::vector<Vertex>* vertexList) {
-	vertexList->clear();
-	for (auto v : _vertices)
-		vertexList->push_back(v);
+    vertexList->clear();
+    for (auto v : _vertices)
+        vertexList->push_back(v);
 
-	return !(vertexList->empty());
+    return !(vertexList->empty());
 }
 
 bool ModelGeometry::getIndices(std::vector<int>* indexList) {
-	indexList->clear();
-	for (auto i : _indices)
-		indexList->push_back(i);
+    indexList->clear();
+    for (auto i : _indices)
+        indexList->push_back(i);
 
-	return !(indexList->empty());
+    return !(indexList->empty());
 }
 
 void ModelGeometry::setUniforms(ghoul::opengl::ProgramObject& program) {
diff --git a/modules/base/rendering/modelgeometry.h b/modules/base/rendering/modelgeometry.h
index ec5fa81e68..3de8dc11c2 100644
--- a/modules/base/rendering/modelgeometry.h
+++ b/modules/base/rendering/modelgeometry.h
@@ -37,42 +37,42 @@ namespace modelgeometry {
 
 class ModelGeometry : public properties::PropertyOwner {
 public:
-	static ModelGeometry* createFromDictionary(const ghoul::Dictionary& dictionary);
+    static ModelGeometry* createFromDictionary(const ghoul::Dictionary& dictionary);
 
-	struct Vertex {
-		GLfloat location[4];
-		GLfloat tex[2];
-		GLfloat normal[3];
-	};
+    struct Vertex {
+        GLfloat location[4];
+        GLfloat tex[2];
+        GLfloat normal[3];
+    };
 
-	ModelGeometry(const ghoul::Dictionary& dictionary);
-	virtual ~ModelGeometry();
-	virtual bool initialize(Renderable* parent);
-	virtual void deinitialize();
-	void render();
-	virtual bool loadModel(const std::string& filename) = 0;
-	void changeRenderMode(const GLenum mode);
-	bool getVertices(std::vector<Vertex>* vertexList);
-	bool getIndices(std::vector<int>* indexList);
+    ModelGeometry(const ghoul::Dictionary& dictionary);
+    virtual ~ModelGeometry();
+    virtual bool initialize(Renderable* parent);
+    virtual void deinitialize();
+    void render();
+    virtual bool loadModel(const std::string& filename) = 0;
+    void changeRenderMode(const GLenum mode);
+    bool getVertices(std::vector<Vertex>* vertexList);
+    bool getIndices(std::vector<int>* indexList);
 
     virtual void setUniforms(ghoul::opengl::ProgramObject& program);
 
 protected:
-	Renderable* _parent;
+    Renderable* _parent;
 
-	bool loadObj(const std::string& filename);
-	bool loadCachedFile(const std::string& filename);
-	bool saveCachedFile(const std::string& filename);
+    bool loadObj(const std::string& filename);
+    bool loadCachedFile(const std::string& filename);
+    bool saveCachedFile(const std::string& filename);
     properties::FloatProperty _magnification;
 
-	GLuint _vaoID;
-	GLuint _vbo;
-	GLuint _ibo;
-	GLenum _mode;
+    GLuint _vaoID;
+    GLuint _vbo;
+    GLuint _ibo;
+    GLenum _mode;
 
-	std::vector<Vertex> _vertices;
-	std::vector<int> _indices;
-	std::string _file;
+    std::vector<Vertex> _vertices;
+    std::vector<int> _indices;
+    std::string _file;
 };
 
 }  // namespace modelgeometry
diff --git a/modules/base/rendering/planetgeometry.cpp b/modules/base/rendering/planetgeometry.cpp
index a51473ca38..a53b7e2f7d 100644
--- a/modules/base/rendering/planetgeometry.cpp
+++ b/modules/base/rendering/planetgeometry.cpp
@@ -34,13 +34,13 @@ namespace openspace {
 namespace planetgeometry {
 
 PlanetGeometry* PlanetGeometry::createFromDictionary(const ghoul::Dictionary& dictionary) {
-	std::string geometryType;
-	const bool success = dictionary.getValue(KeyType, geometryType);
-	if (!success) {
+    std::string geometryType;
+    const bool success = dictionary.getValue(KeyType, geometryType);
+    if (!success) {
         LERROR("PlanetGeometry did not contain a correct value of the key '"
-			<< KeyType << "'");
+            << KeyType << "'");
         return nullptr;
-	}
+    }
     ghoul::TemplateFactory<PlanetGeometry>* factory
           = FactoryManager::ref().factory<PlanetGeometry>();
 
@@ -56,7 +56,7 @@ PlanetGeometry* PlanetGeometry::createFromDictionary(const ghoul::Dictionary& di
 PlanetGeometry::PlanetGeometry()
     : _parent(nullptr)
 {
-	setName("PlanetGeometry");
+    setName("PlanetGeometry");
 }
 
 PlanetGeometry::~PlanetGeometry()
diff --git a/modules/base/rendering/renderableconstellationbounds.cpp b/modules/base/rendering/renderableconstellationbounds.cpp
index 0dd67d5b8a..ea7b07c85c 100644
--- a/modules/base/rendering/renderableconstellationbounds.cpp
+++ b/modules/base/rendering/renderableconstellationbounds.cpp
@@ -38,54 +38,54 @@
 #include <math.h>
 
 namespace {
-	const std::string _loggerCat = "RenderableConstellationBounds";
+    const std::string _loggerCat = "RenderableConstellationBounds";
 
-	const std::string keyVertexFile = "File";
-	const std::string keyConstellationFile = "ConstellationFile";
-	const std::string keyReferenceFrame = "ReferenceFrame";
+    const std::string keyVertexFile = "File";
+    const std::string keyConstellationFile = "ConstellationFile";
+    const std::string keyReferenceFrame = "ReferenceFrame";
 
-	const std::string defaultReferenceFrame = "J2000";
+    const std::string defaultReferenceFrame = "J2000";
 
-	float deg2rad(float deg) {
-		return static_cast<float>((deg / 360.f) * 2.f * M_PI);
-	}
-	float convertHrsToRadians(float rightAscension) {
-		// 360 degrees / 24h = 15 degrees/h
-		return deg2rad(rightAscension * 15);
-	}
+    float deg2rad(float deg) {
+        return static_cast<float>((deg / 360.f) * 2.f * M_PI);
+    }
+    float convertHrsToRadians(float rightAscension) {
+        // 360 degrees / 24h = 15 degrees/h
+        return deg2rad(rightAscension * 15);
+    }
 }
 
 namespace openspace {
 
 RenderableConstellationBounds::RenderableConstellationBounds(
-			const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _vertexFilename("")
-	, _constellationFilename("")
-	, _distance("distance", "Distance to the celestial Sphere", 15.f, 0.f, 30.f)
-	, _constellationSelection("constellationSelection", "Constellation Selection")
-	, _originReferenceFrame("")
-	, _vao(0)
-	, _vbo(0)
+            const ghoul::Dictionary& dictionary)
+    : Renderable(dictionary)
+    , _vertexFilename("")
+    , _constellationFilename("")
+    , _distance("distance", "Distance to the celestial Sphere", 15.f, 0.f, 30.f)
+    , _constellationSelection("constellationSelection", "Constellation Selection")
+    , _originReferenceFrame("")
+    , _vao(0)
+    , _vbo(0)
 {
-	bool success = dictionary.getValue(keyVertexFile, _vertexFilename);
-	if (!success) {
-		LERROR("RenderableConstellationBounds did not contain a key '" <<
-			keyVertexFile << "'");
-	}
+    bool success = dictionary.getValue(keyVertexFile, _vertexFilename);
+    if (!success) {
+        LERROR("RenderableConstellationBounds did not contain a key '" <<
+            keyVertexFile << "'");
+    }
 
-	dictionary.getValue(keyConstellationFile, _constellationFilename);
+    dictionary.getValue(keyConstellationFile, _constellationFilename);
 
-	success = dictionary.getValue(keyReferenceFrame, _originReferenceFrame);
-	if (!success) {
-		_originReferenceFrame = defaultReferenceFrame;
-	}
+    success = dictionary.getValue(keyReferenceFrame, _originReferenceFrame);
+    if (!success) {
+        _originReferenceFrame = defaultReferenceFrame;
+    }
 
-	addProperty(_distance);
-	addProperty(_constellationSelection);
-	_constellationSelection.onChange(
-		std::bind(&RenderableConstellationBounds::selectionPropertyHasChanged, this)
-	);
+    addProperty(_distance);
+    addProperty(_constellationSelection);
+    _constellationSelection.onChange(
+        std::bind(&RenderableConstellationBounds::selectionPropertyHasChanged, this)
+    );
 }
 
 RenderableConstellationBounds::~RenderableConstellationBounds() {
@@ -97,50 +97,50 @@ bool RenderableConstellationBounds::initialize() {
         "${MODULE_BASE}/shaders/constellationbounds_vs.glsl",
         "${MODULE_BASE}/shaders/constellationbounds_fs.glsl");
 
-	if (!_program)
-		return false;
+    if (!_program)
+        return false;
 
-	bool loadSuccess = loadVertexFile();
-	if (!loadSuccess)
-		return false;
-	loadSuccess = loadConstellationFile();
-	if (!loadSuccess)
-		return false;
+    bool loadSuccess = loadVertexFile();
+    if (!loadSuccess)
+        return false;
+    loadSuccess = loadConstellationFile();
+    if (!loadSuccess)
+        return false;
 
-	fillSelectionProperty();
+    fillSelectionProperty();
 
-	if (_vao == 0) {
-		glGenVertexArrays(1, &_vao);
-		LDEBUG("Generating Vertex Array id '" << _vao << "'");
-	}
-	if (_vbo == 0) {
-		glGenBuffers(1, &_vbo);
-		LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
-	}
+    if (_vao == 0) {
+        glGenVertexArrays(1, &_vao);
+        LDEBUG("Generating Vertex Array id '" << _vao << "'");
+    }
+    if (_vbo == 0) {
+        glGenBuffers(1, &_vbo);
+        LDEBUG("Generating Vertex Buffer Object id '" << _vbo << "'");
+    }
 
-	glBindVertexArray(_vao);
-	glBindBuffer(GL_ARRAY_BUFFER, _vbo);
-	glBufferData(GL_ARRAY_BUFFER,
-			_vertexValues.size() * 3 * sizeof(float),
-			&_vertexValues[0],
-			GL_STATIC_DRAW
-			);
+    glBindVertexArray(_vao);
+    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
+    glBufferData(GL_ARRAY_BUFFER,
+            _vertexValues.size() * 3 * sizeof(float),
+            &_vertexValues[0],
+            GL_STATIC_DRAW
+            );
 
-	GLint positionAttrib = _program->attributeLocation("in_position");
-	glEnableVertexAttribArray(positionAttrib);
-	glVertexAttribPointer(positionAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    GLint positionAttrib = _program->attributeLocation("in_position");
+    glEnableVertexAttribArray(positionAttrib);
+    glVertexAttribPointer(positionAttrib, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-	glBindVertexArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindVertexArray(0);
 
-	return true;
+    return true;
 }
 
 bool RenderableConstellationBounds::deinitialize() {
-	glDeleteBuffers(1, &_vbo);
-	_vbo = 0;
-	glDeleteVertexArrays(1, &_vao);
-	_vao = 0;
+    glDeleteBuffers(1, &_vbo);
+    _vbo = 0;
+    glDeleteVertexArrays(1, &_vao);
+    _vao = 0;
 
     RenderEngine& renderEngine = OsEng.renderEngine();
     if (_program) {
@@ -148,204 +148,204 @@ bool RenderableConstellationBounds::deinitialize() {
         _program = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 bool RenderableConstellationBounds::isReady() const {
-	return (_vao != 0) && (_vbo != 0) && (_program != nullptr);
+    return (_vao != 0) && (_vbo != 0) && (_program != nullptr);
 }
 
 void RenderableConstellationBounds::render(const RenderData& data) {
-	_program->activate();
+    _program->activate();
 
-	//glm::mat4 modelMatrix      = data.camera.modelMatrix();
-	glm::mat4 viewMatrix       = data.camera.viewMatrix();
-	glm::mat4 projectionMatrix = data.camera.projectionMatrix();
+    //glm::mat4 modelMatrix      = data.camera.modelMatrix();
+    glm::mat4 viewMatrix       = data.camera.viewMatrix();
+    glm::mat4 projectionMatrix = data.camera.projectionMatrix();
 
-	setPscUniforms(*_program.get(), data.camera, data.position);
+    setPscUniforms(*_program.get(), data.camera, data.position);
 
-	_program->setUniform("exponent", _distance);
-	_program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_program->setUniform("ModelTransform", glm::mat4(glm::dmat4(_stateMatrix)));
+    _program->setUniform("exponent", _distance);
+    _program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _program->setUniform("ModelTransform", glm::mat4(glm::dmat4(_stateMatrix)));
 
-	glBindVertexArray(_vao);
-	for (const ConstellationBound& bound : _constellationBounds) {
-		if (bound.isEnabled) {
-			glDrawArrays(
-				//GL_LINE_STRIP,
-				GL_LINE_LOOP,
-				static_cast<GLsizei>(bound.startIndex),
-				static_cast<GLsizei>(bound.nVertices)
-			);
-		}
-	}
-	glBindVertexArray(0);
-	_program->deactivate();
+    glBindVertexArray(_vao);
+    for (const ConstellationBound& bound : _constellationBounds) {
+        if (bound.isEnabled) {
+            glDrawArrays(
+                //GL_LINE_STRIP,
+                GL_LINE_LOOP,
+                static_cast<GLsizei>(bound.startIndex),
+                static_cast<GLsizei>(bound.nVertices)
+            );
+        }
+    }
+    glBindVertexArray(0);
+    _program->deactivate();
 }
 
 void RenderableConstellationBounds::update(const UpdateData& data) {
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(
-		_originReferenceFrame,
-		"GALACTIC",
-		data.time
-	);
+        _originReferenceFrame,
+        "GALACTIC",
+        data.time
+    );
 }
 
 bool RenderableConstellationBounds::loadVertexFile() {
-	if (_vertexFilename.empty())
-		return false;
+    if (_vertexFilename.empty())
+        return false;
 
-	std::string fileName = absPath(_vertexFilename);
-	std::ifstream file(fileName);
-	if (!file.good()) {
-		LERROR("Could not open file '" << fileName << "' for reading");
-		return false;
-	}
+    std::string fileName = absPath(_vertexFilename);
+    std::ifstream file(fileName);
+    if (!file.good()) {
+        LERROR("Could not open file '" << fileName << "' for reading");
+        return false;
+    }
 
-	ConstellationBound currentBound;
-	currentBound.constellationAbbreviation = "";
+    ConstellationBound currentBound;
+    currentBound.constellationAbbreviation = "";
 
-	std::string currentLine;
-	int currentLineNumber = 1;
+    std::string currentLine;
+    int currentLineNumber = 1;
 
-	float ra;
-	float dec;
-	std::string constellationName;
-	SpiceDouble rectangularValues[3];
+    float ra;
+    float dec;
+    std::string constellationName;
+    SpiceDouble rectangularValues[3];
 
-	// Overview of the reading algorithm:
-	// We keep an active ConstellationBound (currentBound) and update it until we read
-	// a new constellation name, at which point the currentBound is stored away, a new,
-	// empty ConstellationBound is created and set at the currentBound
-	while (file.good()) {
-		std::getline(file, currentLine);
-		if (currentLine.empty())
-			continue;
+    // Overview of the reading algorithm:
+    // We keep an active ConstellationBound (currentBound) and update it until we read
+    // a new constellation name, at which point the currentBound is stored away, a new,
+    // empty ConstellationBound is created and set at the currentBound
+    while (file.good()) {
+        std::getline(file, currentLine);
+        if (currentLine.empty())
+            continue;
 
-		// @CHECK: Is this the best way of doing this? ---abock
-		std::stringstream s(currentLine);
-		s >> ra;
-		s >> dec;
-		s >> constellationName;
+        // @CHECK: Is this the best way of doing this? ---abock
+        std::stringstream s(currentLine);
+        s >> ra;
+        s >> dec;
+        s >> constellationName;
 
-		if (!s.good()) {
-			// If this evaluates to true, the stream was not completely filled, which
-			// means that the line was incomplete, so there was an error
-			LERROR("Error reading file '" << fileName << "' at line #" << currentLineNumber);
-			break;
-		}
+        if (!s.good()) {
+            // If this evaluates to true, the stream was not completely filled, which
+            // means that the line was incomplete, so there was an error
+            LERROR("Error reading file '" << fileName << "' at line #" << currentLineNumber);
+            break;
+        }
 
-		// Did we arrive at a new constellation?
-		if (constellationName != currentBound.constellationAbbreviation) {
-			// Store how many vertices we read during the active time of the constellation
-			currentBound.nVertices = (_vertexValues.size() - currentBound.startIndex);
-			// Store the constellation and start a new one
-			_constellationBounds.push_back(currentBound);
-			currentBound = ConstellationBound();
-			currentBound.isEnabled = true;
-			currentBound.constellationAbbreviation = constellationName;
-			currentBound.constellationFullName = constellationName;
-			currentBound.startIndex = _vertexValues.size();
-		}
+        // Did we arrive at a new constellation?
+        if (constellationName != currentBound.constellationAbbreviation) {
+            // Store how many vertices we read during the active time of the constellation
+            currentBound.nVertices = (_vertexValues.size() - currentBound.startIndex);
+            // Store the constellation and start a new one
+            _constellationBounds.push_back(currentBound);
+            currentBound = ConstellationBound();
+            currentBound.isEnabled = true;
+            currentBound.constellationAbbreviation = constellationName;
+            currentBound.constellationFullName = constellationName;
+            currentBound.startIndex = _vertexValues.size();
+        }
 
-		// The file format stores the right ascension in hours, while SPICE expects them
-		// to be in radians
-		ra = convertHrsToRadians(ra);
+        // The file format stores the right ascension in hours, while SPICE expects them
+        // to be in radians
+        ra = convertHrsToRadians(ra);
 
-		// Likewise, the declination is stored in degrees and needs to be converted
-		dec = deg2rad(dec);
+        // Likewise, the declination is stored in degrees and needs to be converted
+        dec = deg2rad(dec);
 
-		// Convert the (right ascension, declination) to rectangular coordinates)
-		// The 1.0 is the distance of the celestial sphere, we will scale that in the
-		// render function
-		radrec_c(1.0, ra, dec, rectangularValues);
+        // Convert the (right ascension, declination) to rectangular coordinates)
+        // The 1.0 is the distance of the celestial sphere, we will scale that in the
+        // render function
+        radrec_c(1.0, ra, dec, rectangularValues);
 
-		// Add the new vertex to our list of vertices
-		_vertexValues.push_back({{
-			static_cast<float>(rectangularValues[0]),
-			static_cast<float>(rectangularValues[1]),
-			static_cast<float>(rectangularValues[2])
-		}});
-		++currentLineNumber;
-	}
+        // Add the new vertex to our list of vertices
+        _vertexValues.push_back({{
+            static_cast<float>(rectangularValues[0]),
+            static_cast<float>(rectangularValues[1]),
+            static_cast<float>(rectangularValues[2])
+        }});
+        ++currentLineNumber;
+    }
 
-	// Due to the way we read the file, the first (empty) constellation bounds will not
-	// contain any valid values. So we have to remove it
-	_constellationBounds.erase(_constellationBounds.begin());
+    // Due to the way we read the file, the first (empty) constellation bounds will not
+    // contain any valid values. So we have to remove it
+    _constellationBounds.erase(_constellationBounds.begin());
 
-	// And we still have the one value that was left when we exited the loop
-	currentBound.nVertices = (_vertexValues.size() - currentBound.startIndex);
-	_constellationBounds.push_back(currentBound);
+    // And we still have the one value that was left when we exited the loop
+    currentBound.nVertices = (_vertexValues.size() - currentBound.startIndex);
+    _constellationBounds.push_back(currentBound);
 
-	return true;
+    return true;
 }
 
 bool RenderableConstellationBounds::loadConstellationFile() {
-	if (_constellationFilename.empty())
-		return true;
+    if (_constellationFilename.empty())
+        return true;
 
-	std::string fileName = absPath(_constellationFilename);
-	std::ifstream file(fileName);
-	if (!file.good()) {
-		LERROR("Could not open file '" << fileName << "' for reading");
-		return false;
-	}
+    std::string fileName = absPath(_constellationFilename);
+    std::ifstream file(fileName);
+    if (!file.good()) {
+        LERROR("Could not open file '" << fileName << "' for reading");
+        return false;
+    }
 
-	std::string line;
-	int index = 0;
-	while (file.good()) {
- 		std::getline(file, line);
-		if (line.empty())
-			continue;
+    std::string line;
+    int index = 0;
+    while (file.good()) {
+         std::getline(file, line);
+        if (line.empty())
+            continue;
 
-		std::string abbreviation;
-		std::stringstream s(line);
-		s >> abbreviation;
+        std::string abbreviation;
+        std::stringstream s(line);
+        s >> abbreviation;
 
-		auto it = std::find_if(_constellationBounds.begin(), _constellationBounds.end(),
-			[abbreviation](const ConstellationBound& bound) {
-				return bound.constellationAbbreviation == abbreviation;
-			});
-		if (it == _constellationBounds.end()) {
-			LERROR("Could not find constellation '" << abbreviation << "' in list");
-			return false;
-		}
+        auto it = std::find_if(_constellationBounds.begin(), _constellationBounds.end(),
+            [abbreviation](const ConstellationBound& bound) {
+                return bound.constellationAbbreviation == abbreviation;
+            });
+        if (it == _constellationBounds.end()) {
+            LERROR("Could not find constellation '" << abbreviation << "' in list");
+            return false;
+        }
 
-		// Update the constellations full name
-		s >> it->constellationFullName;
+        // Update the constellations full name
+        s >> it->constellationFullName;
 
-		++index;
-	}
+        ++index;
+    }
 
-	return true;
+    return true;
 }
 
 void RenderableConstellationBounds::fillSelectionProperty() {
-	// Each constellation is associated with its position in the array as this is unique
-	// and will be constant during the runtime
-	for (int i = 0 ; i < _constellationBounds.size(); ++i) {
-		const ConstellationBound& bound = _constellationBounds[i];
-		_constellationSelection.addOption( { i, bound.constellationFullName } );
-	}
+    // Each constellation is associated with its position in the array as this is unique
+    // and will be constant during the runtime
+    for (int i = 0 ; i < _constellationBounds.size(); ++i) {
+        const ConstellationBound& bound = _constellationBounds[i];
+        _constellationSelection.addOption( { i, bound.constellationFullName } );
+    }
 }
 
 void RenderableConstellationBounds::selectionPropertyHasChanged() {
-	const std::vector<int>& values = _constellationSelection;
-	// If no values are selected (the default), we want to show all constellations
-	if (values.size() == 0) {
-		for (ConstellationBound& b : _constellationBounds)
-			b.isEnabled = true;
-	}
-	else {
-		// In the worst case, this algorithm runs with 2 * nConstellations, which is
-		// acceptable as the number of constellations is < 100
-		// First disable all constellations
-		for (ConstellationBound& b : _constellationBounds)
-			b.isEnabled = false;
-		// then re-enable the ones for which we have indices
-		for (int value : values)
-			_constellationBounds[value].isEnabled = true;
-	}
+    const std::vector<int>& values = _constellationSelection;
+    // If no values are selected (the default), we want to show all constellations
+    if (values.size() == 0) {
+        for (ConstellationBound& b : _constellationBounds)
+            b.isEnabled = true;
+    }
+    else {
+        // In the worst case, this algorithm runs with 2 * nConstellations, which is
+        // acceptable as the number of constellations is < 100
+        // First disable all constellations
+        for (ConstellationBound& b : _constellationBounds)
+            b.isEnabled = false;
+        // then re-enable the ones for which we have indices
+        for (int value : values)
+            _constellationBounds[value].isEnabled = true;
+    }
 }
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderableconstellationbounds.h b/modules/base/rendering/renderableconstellationbounds.h
index f4c8b50c3f..b4b7774c0f 100644
--- a/modules/base/rendering/renderableconstellationbounds.h
+++ b/modules/base/rendering/renderableconstellationbounds.h
@@ -52,76 +52,76 @@ namespace openspace {
  */
 class RenderableConstellationBounds : public Renderable {
 public:
-	RenderableConstellationBounds(const ghoul::Dictionary& dictionary);
-	~RenderableConstellationBounds();
+    RenderableConstellationBounds(const ghoul::Dictionary& dictionary);
+    ~RenderableConstellationBounds();
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
-	/// Stores the constellation bounds
-	struct ConstellationBound {
-		std::string constellationAbbreviation; ///< The abbreviation of the constellation
-		std::string constellationFullName;
-		bool isEnabled;
-		size_t startIndex; ///< The index of the first vertex describing the bounds
-		size_t nVertices; ///< The number of vertices describing the bounds
-	};
+    /// Stores the constellation bounds
+    struct ConstellationBound {
+        std::string constellationAbbreviation; ///< The abbreviation of the constellation
+        std::string constellationFullName;
+        bool isEnabled;
+        size_t startIndex; ///< The index of the first vertex describing the bounds
+        size_t nVertices; ///< The number of vertices describing the bounds
+    };
 
-	/**
-	 * Loads the file specified in <code>_vertexFilename</code> and fills the
-	 * <code>_constellationBounds</code> variable, as well as the
-	 * <code>_vertexValues</code> list. If this method fails, the content of either
-	 * destination is undefined.
-	 * \return <code>true</code> if the loading succeeded, <code>false</code> otherwise
-	 */
-	bool loadVertexFile();
+    /**
+     * Loads the file specified in <code>_vertexFilename</code> and fills the
+     * <code>_constellationBounds</code> variable, as well as the
+     * <code>_vertexValues</code> list. If this method fails, the content of either
+     * destination is undefined.
+     * \return <code>true</code> if the loading succeeded, <code>false</code> otherwise
+     */
+    bool loadVertexFile();
 
-	/**
-	 * Loads the file specified in <code>_constellationFilename</code> that contains the
-	 * mapping between abbreviations and full names of constellations.
-	 * \return <code>true</code> if the loading succeeded, <code>false</code> otherwise
-	 */
-	bool loadConstellationFile();
+    /**
+     * Loads the file specified in <code>_constellationFilename</code> that contains the
+     * mapping between abbreviations and full names of constellations.
+     * \return <code>true</code> if the loading succeeded, <code>false</code> otherwise
+     */
+    bool loadConstellationFile();
 
-	/// Fills the <code>_constellationSelection</code> property with all constellations
-	void fillSelectionProperty();
+    /// Fills the <code>_constellationSelection</code> property with all constellations
+    void fillSelectionProperty();
 
-	/**
-	 * Callback method that gets triggered when <code>_constellationSelection</code>
-	 * changes.
-	 */
-	void selectionPropertyHasChanged();
+    /**
+     * Callback method that gets triggered when <code>_constellationSelection</code>
+     * changes.
+     */
+    void selectionPropertyHasChanged();
 
-	std::string _vertexFilename; ///< The filename containing the constellation bounds
-	std::string _constellationFilename; ///< The file containing constellation names
+    std::string _vertexFilename; ///< The filename containing the constellation bounds
+    std::string _constellationFilename; ///< The file containing constellation names
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
-	/// The list of all loaded constellation bounds
-	std::vector<ConstellationBound> _constellationBounds;
-	
-	typedef std::array<float, 3> Vertex;
-	std::vector<Vertex> _vertexValues; ///< A list of all vertices of all bounds
+    /// The list of all loaded constellation bounds
+    std::vector<ConstellationBound> _constellationBounds;
+    
+    typedef std::array<float, 3> Vertex;
+    std::vector<Vertex> _vertexValues; ///< A list of all vertices of all bounds
 
-	/// The radius of the celestial sphere onto which the bounds are drawn
-	properties::FloatProperty _distance;
+    /// The radius of the celestial sphere onto which the bounds are drawn
+    properties::FloatProperty _distance;
 
-	/// The property that stores all indices of constellations that should be drawn
-	properties::SelectionProperty _constellationSelection;
+    /// The property that stores all indices of constellations that should be drawn
+    properties::SelectionProperty _constellationSelection;
 
-	std::string _originReferenceFrame; ///< Reference frame in which bounds are defined
-	
-	/// Used to translate between the origin reference frame and the target frame
-	glm::dmat3 _stateMatrix;
+    std::string _originReferenceFrame; ///< Reference frame in which bounds are defined
+    
+    /// Used to translate between the origin reference frame and the target frame
+    glm::dmat3 _stateMatrix;
 
-	GLuint _vao;
-	GLuint _vbo;
+    GLuint _vao;
+    GLuint _vbo;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderablecrawlingline.cpp b/modules/base/rendering/renderablecrawlingline.cpp
index 58dcdd354d..0500781d21 100644
--- a/modules/base/rendering/renderablecrawlingline.cpp
+++ b/modules/base/rendering/renderablecrawlingline.cpp
@@ -31,13 +31,13 @@
 //#include <imgui.h>
 
 namespace {
-	const std::string _loggerCat = "RenderableCrawlingLine";
+    const std::string _loggerCat = "RenderableCrawlingLine";
 
     const std::string KeySource = "Source";
     const std::string KeyTarget = "Target";
     const std::string KeyInstrument = "Instrument";
     const std::string KeyReferenceFrame = "Frame";
-	const std::string keyColor = "RGB";
+    const std::string keyColor = "RGB";
 
     static const int SourcePosition = 0;
     static const int TargetPosition = 1;
@@ -58,23 +58,23 @@ RenderableCrawlingLine::RenderableCrawlingLine(const ghoul::Dictionary& dictiona
     dictionary.getValue(KeyReferenceFrame, _referenceFrame);
 
 
-	if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
-		dictionary.getValue(keyColor, _lineColor);
-	else
-		_lineColor = glm::vec3(1);
+    if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
+        dictionary.getValue(keyColor, _lineColor);
+    else
+        _lineColor = glm::vec3(1);
 }
 
 bool RenderableCrawlingLine::isReady() const {
-	bool ready = true;
+    bool ready = true;
     ready &= !_source.empty();
     ready &= !_target.empty();
     ready &= !_instrumentName.empty();
-	ready &= (_program != nullptr);
-	return ready;
+    ready &= (_program != nullptr);
+    return ready;
 }
 
 bool RenderableCrawlingLine::initialize() {
-	_frameCounter = 0;
+    _frameCounter = 0;
     bool completeSuccess = true;
     _program = ghoul::opengl::ProgramObject::Build("RenderableCrawlingLine",
         "${SHADERS}/modules/crawlingline/crawlingline_vs.glsl",
@@ -83,65 +83,65 @@ bool RenderableCrawlingLine::initialize() {
     if (!_program)
         return false;
 
-	glGenVertexArrays(1, &_vao);
-	glGenBuffers(1, &_vbo);
+    glGenVertexArrays(1, &_vao);
+    glGenBuffers(1, &_vbo);
 
     glBindVertexArray(_vao);
     glBindBuffer(GL_ARRAY_BUFFER, _vbo);
     glBufferData(GL_ARRAY_BUFFER, 2 * sizeof(psc), NULL, GL_DYNAMIC_DRAW);
 
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 bool RenderableCrawlingLine::deinitialize(){
-	glDeleteVertexArrays(1, &_vao);
+    glDeleteVertexArrays(1, &_vao);
     _vao = 0;
-	glDeleteBuffers(1, &_vbo);
+    glDeleteBuffers(1, &_vbo);
     _vbo = 0;
-	return true;
+    return true;
 }
 
 void RenderableCrawlingLine::render(const RenderData& data) {
-	if (_drawLine) {
-	    _program->activate();
-		_frameCounter++;
-	    // fetch data
-	    psc currentPosition = data.position;
-	    psc campos = data.camera.position();
-	    glm::mat4 camrot = data.camera.viewRotationMatrix();
+    if (_drawLine) {
+        _program->activate();
+        _frameCounter++;
+        // fetch data
+        psc currentPosition = data.position;
+        psc campos = data.camera.position();
+        glm::mat4 camrot = data.camera.viewRotationMatrix();
 
-	    glm::mat4 transform = glm::mat4(1);
+        glm::mat4 transform = glm::mat4(1);
 
-	    // setup the data to the shader
-	    _program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	    _program->setUniform("ModelTransform", transform);
+        // setup the data to the shader
+        _program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+        _program->setUniform("ModelTransform", transform);
 
-		int frame = _frameCounter % 60;
-		float fadingFactor = static_cast<float>(sin((frame * pi_c()) / 60));
-		float alpha = 0.6f + fadingFactor*0.4f;
+        int frame = _frameCounter % 60;
+        float fadingFactor = static_cast<float>(sin((frame * pi_c()) / 60));
+        float alpha = 0.6f + fadingFactor*0.4f;
 
-		glLineWidth(2.f);
+        glLineWidth(2.f);
 
         _program->setUniform("_alpha", alpha);
-		_program->setUniform("color", _lineColor);
-	    setPscUniforms(_program, &data.camera, data.position);
+        _program->setUniform("color", _lineColor);
+        setPscUniforms(_program, &data.camera, data.position);
 
-	    glBindVertexArray(_vao);
+        glBindVertexArray(_vao);
         glBindBuffer(GL_ARRAY_BUFFER, _vbo);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(psc) * 2, _positions);
 
         glEnableVertexAttribArray(0);
         glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
 
-	    glDrawArrays(GL_LINES, 0, 2);
-	    glBindVertexArray(0);
-	
-	    _program->deactivate();
+        glDrawArrays(GL_LINES, 0, 2);
+        glBindVertexArray(0);
+    
+        _program->deactivate();
     }
 }
 
@@ -149,28 +149,28 @@ void RenderableCrawlingLine::update(const UpdateData& data) {
     if (_program->isDirty())
         _program->rebuildFromFile();
     glm::dmat3 transformMatrix = glm::dmat3(1);
-	openspace::SpiceManager::ref().getPositionTransformMatrix(_source, _referenceFrame, data.time, transformMatrix);
+    openspace::SpiceManager::ref().getPositionTransformMatrix(_source, _referenceFrame, data.time, transformMatrix);
 
-	glm::mat4 tmp = glm::mat4(1);
-	for (int i = 0; i < 3; i++) {
-		for (int j = 0; j < 3; j++){
-			tmp[i][j] = static_cast<float>(transformMatrix[i][j]);
-		}
-	}
+    glm::mat4 tmp = glm::mat4(1);
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++){
+            tmp[i][j] = static_cast<float>(transformMatrix[i][j]);
+        }
+    }
 
-	_positions[SourcePosition] = PowerScaledCoordinate::CreatePowerScaledCoordinate(0, 0, 0);
+    _positions[SourcePosition] = PowerScaledCoordinate::CreatePowerScaledCoordinate(0, 0, 0);
 
-	std::string shape, instrument;
-	std::vector<glm::dvec3> bounds;
-	glm::dvec3 boresight;
+    std::string shape, instrument;
+    std::vector<glm::dvec3> bounds;
+    glm::dvec3 boresight;
 
-	bool found = openspace::SpiceManager::ref().getFieldOfView(_source, shape, instrument, boresight, bounds);
+    bool found = openspace::SpiceManager::ref().getFieldOfView(_source, shape, instrument, boresight, bounds);
     if (!found)
         LERROR("Could not find field of view for instrument");
-	glm::vec4 target(boresight[0], boresight[1], boresight[2], 12);
-	target = tmp * target;
+    glm::vec4 target(boresight[0], boresight[1], boresight[2], 12);
+    target = tmp * target;
 
-	_positions[TargetPosition] = target;
+    _positions[TargetPosition] = target;
 
     if (ImageSequencer2::ref().isReady()) {
         _imageSequenceTime = ImageSequencer2::ref().instrumentActiveTime(_instrumentName);
diff --git a/modules/base/rendering/renderablemodel.cpp b/modules/base/rendering/renderablemodel.cpp
index f3953a4896..76d16ff58e 100644
--- a/modules/base/rendering/renderablemodel.cpp
+++ b/modules/base/rendering/renderablemodel.cpp
@@ -45,15 +45,15 @@
 #include <math.h>
 
 namespace { 
-	const std::string _loggerCat     = "RenderableModel";
-	const std::string keySource      = "Rotation.Source";
-	const std::string keyDestination = "Rotation.Destination";
+    const std::string _loggerCat     = "RenderableModel";
+    const std::string keySource      = "Rotation.Source";
+    const std::string keyDestination = "Rotation.Destination";
     const std::string keyGeometry    = "Geometry";
-	const std::string keyBody        = "Body";
-	const std::string keyStart       = "StartTime";
-	const std::string keyEnd         = "EndTime";
-	const std::string keyFading      = "Shading.Fadeable";
-	//const std::string keyGhosting      = "Shading.Ghosting";
+    const std::string keyBody        = "Body";
+    const std::string keyStart       = "StartTime";
+    const std::string keyEnd         = "EndTime";
+    const std::string keyFading      = "Shading.Fadeable";
+    //const std::string keyGhosting      = "Shading.Ghosting";
 
 }
 
@@ -61,8 +61,8 @@ namespace openspace {
 
 RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
     : Renderable(dictionary)
-	, _colorTexturePath("colorTexture", "Color Texture")
-	, _performFade("performFading", "Perform Fading", false)
+    , _colorTexturePath("colorTexture", "Color Texture")
+    , _performFade("performFading", "Perform Fading", false)
     , _fading("fading", "Fade", 0)
     , _programObject(nullptr)
     , _texture(nullptr)
@@ -70,57 +70,57 @@ RenderableModel::RenderableModel(const ghoul::Dictionary& dictionary)
     , _alpha(1.f)
     //, _isGhost(false)
     , _performShading("performShading", "Perform Shading", true)
-	, _frameCount(0)
+    , _frameCount(0)
 {
-	std::string name;
+    std::string name;
     bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
     ghoul_assert(success, "Name was not passed to RenderableModel");
 
-	ghoul::Dictionary geometryDictionary;
-	success = dictionary.getValue(keyGeometry, geometryDictionary);
-	if (success) {
-		geometryDictionary.setValue(SceneGraphNode::KeyName, name);
-		_geometry = modelgeometry::ModelGeometry::createFromDictionary(geometryDictionary);
-	}
+    ghoul::Dictionary geometryDictionary;
+    success = dictionary.getValue(keyGeometry, geometryDictionary);
+    if (success) {
+        geometryDictionary.setValue(SceneGraphNode::KeyName, name);
+        _geometry = modelgeometry::ModelGeometry::createFromDictionary(geometryDictionary);
+    }
 
-	std::string texturePath = "";
-	success = dictionary.getValue("Textures.Color", texturePath);
-	if (success)
+    std::string texturePath = "";
+    success = dictionary.getValue("Textures.Color", texturePath);
+    if (success)
         _colorTexturePath = absPath(texturePath);
 
-	addPropertySubOwner(_geometry);
+    addPropertySubOwner(_geometry);
 
-	addProperty(_colorTexturePath);
-	_colorTexturePath.onChange(std::bind(&RenderableModel::loadTexture, this));
+    addProperty(_colorTexturePath);
+    _colorTexturePath.onChange(std::bind(&RenderableModel::loadTexture, this));
 
-	dictionary.getValue(keySource, _source);
-	dictionary.getValue(keyDestination, _destination);
-	dictionary.getValue(keyBody, _target);
+    dictionary.getValue(keySource, _source);
+    dictionary.getValue(keyDestination, _destination);
+    dictionary.getValue(keyBody, _target);
 
-	openspace::SpiceManager::ref().addFrame(_target, _source);
+    openspace::SpiceManager::ref().addFrame(_target, _source);
 
     setBoundingSphere(pss(1.f, 9.f));
-	addProperty(_performShading);
+    addProperty(_performShading);
 
-	if (dictionary.hasKeyAndValue<bool>(keyFading)) {
-		bool fading;
-		dictionary.getValue(keyFading, fading);
-		_performFade = fading;
-	}
-	addProperty(_performFade);
+    if (dictionary.hasKeyAndValue<bool>(keyFading)) {
+        bool fading;
+        dictionary.getValue(keyFading, fading);
+        _performFade = fading;
+    }
+    addProperty(_performFade);
 
-	//if (dictionary.hasKeyAndValue<bool>(keyGhosting)) {
-	//	bool ghosting;
-	//	dictionary.getValue(keyGhosting, ghosting);
-	//	_isGhost = ghosting;
-	//}
+    //if (dictionary.hasKeyAndValue<bool>(keyGhosting)) {
+    //    bool ghosting;
+    //    dictionary.getValue(keyGhosting, ghosting);
+    //    _isGhost = ghosting;
+    //}
 }
 
 bool RenderableModel::isReady() const {
-	bool ready = true;
-	ready &= (_programObject != nullptr);
-	ready &= (_texture != nullptr);
-	return ready;
+    bool ready = true;
+    ready &= (_programObject != nullptr);
+    ready &= (_texture != nullptr);
+    return ready;
 }
 
 bool RenderableModel::initialize() {
@@ -141,18 +141,18 @@ bool RenderableModel::initialize() {
 
     completeSuccess &= (_texture != nullptr);
     completeSuccess &= _geometry->initialize(this); 
-	completeSuccess &= !_source.empty();
-	completeSuccess &= !_destination.empty();
+    completeSuccess &= !_source.empty();
+    completeSuccess &= !_destination.empty();
 
     return completeSuccess;
 }
 
 bool RenderableModel::deinitialize() {
-	if (_geometry) {
-		_geometry->deinitialize();
-		delete _geometry;
+    if (_geometry) {
+        _geometry->deinitialize();
+        delete _geometry;
         _geometry = nullptr;
-	}
+    }
     _texture = nullptr;
 
 
@@ -162,59 +162,59 @@ bool RenderableModel::deinitialize() {
         _programObject = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 void RenderableModel::render(const RenderData& data) {
     _programObject->activate();
-	_frameCount++;
+    _frameCount++;
 
-	double lt;
+    double lt;
     glm::mat4 transform = glm::mat4(1);
 
-	glm::mat4 tmp = glm::mat4(1);
-	for (int i = 0; i < 3; i++){
-		for (int j = 0; j < 3; j++){
-			tmp[i][j] = static_cast<float>(_stateMatrix[i][j]);
-		}
-	}
-	transform *= tmp;
-	
-	double time = openspace::Time::ref().currentTime();
-	bool targetPositionCoverage = openspace::SpiceManager::ref().hasSpkCoverage(_target, time);
-	if (!targetPositionCoverage){
-		int frame = _frameCount % 180;
+    glm::mat4 tmp = glm::mat4(1);
+    for (int i = 0; i < 3; i++){
+        for (int j = 0; j < 3; j++){
+            tmp[i][j] = static_cast<float>(_stateMatrix[i][j]);
+        }
+    }
+    transform *= tmp;
+    
+    double time = openspace::Time::ref().currentTime();
+    bool targetPositionCoverage = openspace::SpiceManager::ref().hasSpkCoverage(_target, time);
+    if (!targetPositionCoverage){
+        int frame = _frameCount % 180;
         
-		float fadingFactor = static_cast<float>(sin((frame * M_PI) / 180));
-		_alpha = 0.5f + fadingFactor * 0.5f;
-	}
-	else
-		_alpha = 1.0f;
+        float fadingFactor = static_cast<float>(sin((frame * M_PI) / 180));
+        _alpha = 0.5f + fadingFactor * 0.5f;
+    }
+    else
+        _alpha = 1.0f;
 
     glm::dvec3 p =
     SpiceManager::ref().targetPosition(_target, "SUN", "GALACTIC", {}, time, lt);
     psc tmppos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
-	glm::vec3 cam_dir = glm::normalize(data.camera.position().vec3() - tmppos.vec3());
-	_programObject->setUniform("cam_dir", cam_dir);
-	_programObject->setUniform("transparency", _alpha);
-	_programObject->setUniform("sun_pos", _sunPosition.vec3());
-	_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_programObject->setUniform("ModelTransform", transform);
-	setPscUniforms(*_programObject.get(), data.camera, data.position);
-	
-	_programObject->setUniform("_performShading", _performShading);
+    glm::vec3 cam_dir = glm::normalize(data.camera.position().vec3() - tmppos.vec3());
+    _programObject->setUniform("cam_dir", cam_dir);
+    _programObject->setUniform("transparency", _alpha);
+    _programObject->setUniform("sun_pos", _sunPosition.vec3());
+    _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _programObject->setUniform("ModelTransform", transform);
+    setPscUniforms(*_programObject.get(), data.camera, data.position);
+    
+    _programObject->setUniform("_performShading", _performShading);
 
     _geometry->setUniforms(*_programObject);
 
-	if (_performFade && _fading > 0.f){
-		_fading = _fading - 0.01f;
-	}
-	else if (!_performFade && _fading < 1.f){
-		_fading = _fading + 0.01f;
+    if (_performFade && _fading > 0.f){
+        _fading = _fading - 0.01f;
+    }
+    else if (!_performFade && _fading < 1.f){
+        _fading = _fading + 0.01f;
 
-	}
+    }
 
-	_programObject->setUniform("fading", _fading);
+    _programObject->setUniform("fading", _fading);
 
     // Bind texture
     ghoul::opengl::TextureUnit unit;
@@ -222,7 +222,7 @@ void RenderableModel::render(const RenderData& data) {
     _texture->bind();
     _programObject->setUniform("texture1", unit);
 
-	_geometry->render();
+    _geometry->render();
 
     // disable shader
     _programObject->deactivate();
@@ -231,25 +231,25 @@ void RenderableModel::render(const RenderData& data) {
 void RenderableModel::update(const UpdateData& data) {
     if (_programObject->isDirty())
         _programObject->rebuildFromFile();
-	double _time = data.time;
+    double _time = data.time;
 
-	//if (_isGhost){
-	//	futureTime = openspace::ImageSequencer::ref().getNextCaptureTime();
-	//	double remaining = openspace::ImageSequencer::ref().getNextCaptureTime() - data.time;
-	//	double interval = openspace::ImageSequencer::ref().getIntervalLength();
-	//	double t = 1.f - remaining / openspace::ImageSequencer::ref().getIntervalLength();
-	//	if (interval > 60) {
-	//		if (t < 0.8)
-	//			_fading = static_cast<float>(t);
-	//		else if (t >= 0.95)
-	//			_fading = _fading - 0.5f;
-	//	}
-	//	else
-	//		_fading = 0.f;
-	//	_time = futureTime;
-	//}
+    //if (_isGhost){
+    //    futureTime = openspace::ImageSequencer::ref().getNextCaptureTime();
+    //    double remaining = openspace::ImageSequencer::ref().getNextCaptureTime() - data.time;
+    //    double interval = openspace::ImageSequencer::ref().getIntervalLength();
+    //    double t = 1.f - remaining / openspace::ImageSequencer::ref().getIntervalLength();
+    //    if (interval > 60) {
+    //        if (t < 0.8)
+    //            _fading = static_cast<float>(t);
+    //        else if (t >= 0.95)
+    //            _fading = _fading - 0.5f;
+    //    }
+    //    else
+    //        _fading = 0.f;
+    //    _time = futureTime;
+    //}
 
-	// set spice-orientation in accordance to timestamp
+    // set spice-orientation in accordance to timestamp
     if (!_source.empty()) {
         _stateMatrix = SpiceManager::ref().positionTransformMatrix(_source, _destination, _time);
     }
diff --git a/modules/base/rendering/renderablemodel.h b/modules/base/rendering/renderablemodel.h
index 112ba31693..5cd4f61abe 100644
--- a/modules/base/rendering/renderablemodel.h
+++ b/modules/base/rendering/renderablemodel.h
@@ -41,14 +41,14 @@ class ModelGeometry;
 
 class RenderableModel : public Renderable {
 public:
-	RenderableModel(const ghoul::Dictionary& dictionary);
+    RenderableModel(const ghoul::Dictionary& dictionary);
 
     bool initialize() override;
     bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
+    void render(const RenderData& data) override;
     void update(const UpdateData& data) override;
 
 
@@ -57,26 +57,26 @@ protected:
 
 private:
     properties::StringProperty _colorTexturePath;
-	properties::BoolProperty _performFade;
-	properties::FloatProperty _fading;
+    properties::BoolProperty _performFade;
+    properties::FloatProperty _fading;
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
 
-	modelgeometry::ModelGeometry* _geometry;
+    modelgeometry::ModelGeometry* _geometry;
 
-	float _alpha;
-	glm::dmat3 _stateMatrix; 
+    float _alpha;
+    glm::dmat3 _stateMatrix; 
 
-	std::string _source;
-	std::string _destination;
-	std::string _target;
+    std::string _source;
+    std::string _destination;
+    std::string _target;
 
-	//bool _isGhost;
-	int _frameCount;
+    //bool _isGhost;
+    int _frameCount;
 
     psc _sunPosition;
 
-	properties::BoolProperty _performShading;
+    properties::BoolProperty _performShading;
 };
 
 }  // namespace openspace
diff --git a/modules/base/rendering/renderablepath.cpp b/modules/base/rendering/renderablepath.cpp
index 9a3db1f4dd..d9f2b3b3ef 100644
--- a/modules/base/rendering/renderablepath.cpp
+++ b/modules/base/rendering/renderablepath.cpp
@@ -40,88 +40,88 @@
 */
 
 namespace {
-	const std::string _loggerCat = "RenderableTrail";
-	//constants
-	const std::string keyName = "Name";
-	const std::string keyBody = "Body";
-	const std::string keyObserver = "Observer";
-	const std::string keyFrame = "Frame";
-	const std::string keyPathModule = "ModulePath";
-	const std::string keyColor = "RGB";
-	const std::string keyTimeSteps = "TimeSteps";
-	const std::string keyDrawLine = "DrawLine";
+    const std::string _loggerCat = "RenderableTrail";
+    //constants
+    const std::string keyName = "Name";
+    const std::string keyBody = "Body";
+    const std::string keyObserver = "Observer";
+    const std::string keyFrame = "Frame";
+    const std::string keyPathModule = "ModulePath";
+    const std::string keyColor = "RGB";
+    const std::string keyTimeSteps = "TimeSteps";
+    const std::string keyDrawLine = "DrawLine";
 
 }
 
 namespace openspace {
 
 RenderablePath::RenderablePath(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _lineFade("lineFade", "Line Fade", 0.75f, 0.f, 5.f)
-	, _lineWidth("lineWidth", "Line Width", 2.f, 1.f, 20.f)
+    : Renderable(dictionary)
+    , _lineFade("lineFade", "Line Fade", 0.75f, 0.f, 5.f)
+    , _lineWidth("lineWidth", "Line Width", 2.f, 1.f, 20.f)
     , _drawLine("drawline", "Draw Line", false)
-	, _programObject(nullptr)
+    , _programObject(nullptr)
     , _successfullDictionaryFetch(true)
-	, _vaoID(0)
-	, _vBufferID(0)
-	, _needsSweep(true)
+    , _vaoID(0)
+    , _vBufferID(0)
+    , _needsSweep(true)
     , _start(0.0)
     , _stop(0.0)
 {
-	_successfullDictionaryFetch &= dictionary.getValue(keyBody, _target);
-	_successfullDictionaryFetch &= dictionary.getValue(keyObserver, _observer);
-	_successfullDictionaryFetch &= dictionary.getValue(keyFrame, _frame);
-	_successfullDictionaryFetch &= dictionary.getValue(keyTimeSteps, _increment);
+    _successfullDictionaryFetch &= dictionary.getValue(keyBody, _target);
+    _successfullDictionaryFetch &= dictionary.getValue(keyObserver, _observer);
+    _successfullDictionaryFetch &= dictionary.getValue(keyFrame, _frame);
+    _successfullDictionaryFetch &= dictionary.getValue(keyTimeSteps, _increment);
 
-	glm::vec3 color(0.f);
-	if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
-		dictionary.getValue(keyColor, color);
-	_lineColor = color;
+    glm::vec3 color(0.f);
+    if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
+        dictionary.getValue(keyColor, color);
+    _lineColor = color;
 
-	bool drawLine = false;
-	if (dictionary.hasKeyAndValue<bool>(keyDrawLine))
-		dictionary.getValue(keyDrawLine, drawLine);
-	_drawLine = drawLine;
-	addProperty(_drawLine);
-	addProperty(_lineFade);
-	addProperty(_lineWidth);
-	_distanceFade = 1.0;
+    bool drawLine = false;
+    if (dictionary.hasKeyAndValue<bool>(keyDrawLine))
+        dictionary.getValue(keyDrawLine, drawLine);
+    _drawLine = drawLine;
+    addProperty(_drawLine);
+    addProperty(_lineFade);
+    addProperty(_lineWidth);
+    _distanceFade = 1.0;
 }
 
 bool RenderablePath::initialize() {
-	if (!_successfullDictionaryFetch) {
-		LERROR("The following keys need to be set in the Dictionary. Cannot initialize!");
-		LERROR(keyBody << ": " << _target);
-		LERROR(keyObserver << ": " << _observer);
-		LERROR(keyFrame << ": " << _frame);
-		return false;
-	}
+    if (!_successfullDictionaryFetch) {
+        LERROR("The following keys need to be set in the Dictionary. Cannot initialize!");
+        LERROR(keyBody << ": " << _target);
+        LERROR(keyObserver << ": " << _observer);
+        LERROR(keyFrame << ": " << _frame);
+        return false;
+    }
 
-	bool completeSuccess = true;
+    bool completeSuccess = true;
 
 
     RenderEngine& renderEngine = OsEng.renderEngine();
     _programObject = renderEngine.buildRenderProgram("PathProgram",
         "${MODULE_BASE}/shaders/path_vs.glsl",
         "${MODULE_BASE}/shaders/path_fs.glsl");
-	if (!_programObject)
-		return false;
+    if (!_programObject)
+        return false;
 
-	bool intervalSet = hasTimeInterval();
-	if (intervalSet) {
-		getInterval(_start, _stop);
+    bool intervalSet = hasTimeInterval();
+    if (intervalSet) {
+        getInterval(_start, _stop);
         std::string start = SpiceManager::ref().dateFromEphemerisTime(_start);
         std::string stop = SpiceManager::ref().dateFromEphemerisTime(_stop);
-	}
+    }
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 bool RenderablePath::deinitialize() {
-	glDeleteVertexArrays(1, &_vaoID);
+    glDeleteVertexArrays(1, &_vaoID);
     _vaoID = 0;
 
-	glDeleteBuffers(1, &_vBufferID);
+    glDeleteBuffers(1, &_vBufferID);
     _vBufferID = 0;
 
     RenderEngine& renderEngine = OsEng.renderEngine();
@@ -130,148 +130,148 @@ bool RenderablePath::deinitialize() {
         _programObject = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 bool RenderablePath::isReady() const {
-	return (_programObject != nullptr) && _successfullDictionaryFetch;
+    return (_programObject != nullptr) && _successfullDictionaryFetch;
 }
 
 void RenderablePath::render(const RenderData& data) {
-	double time = openspace::Time::ref().currentTime();
-	if (_start > time || _stop < time)
-		return;
+    double time = openspace::Time::ref().currentTime();
+    if (_start > time || _stop < time)
+        return;
 
-	//const psc& position = data.camera.position();
-	//const psc& origin = openspace::OpenSpaceEngine::ref().interactionHandler()->focusNode()->worldPosition();
-	//const PowerScaledScalar& pssl = (position - origin).length();
-	//double properLength = static_cast<double>(pssl.lengthf());
-	//const PowerScaledScalar corrected = PowerScaledScalar::CreatePSS(properLength);
-	//float exp = corrected[1];
-	//
-	//if (exp > 11)
-	//	return;
-	
-	_programObject->activate();
-	psc currentPosition = data.position;
-	glm::mat4 camrot = data.camera.viewRotationMatrix();
-	glm::mat4 transform = glm::mat4(1);
+    //const psc& position = data.camera.position();
+    //const psc& origin = openspace::OpenSpaceEngine::ref().interactionHandler()->focusNode()->worldPosition();
+    //const PowerScaledScalar& pssl = (position - origin).length();
+    //double properLength = static_cast<double>(pssl.lengthf());
+    //const PowerScaledScalar corrected = PowerScaledScalar::CreatePSS(properLength);
+    //float exp = corrected[1];
+    //
+    //if (exp > 11)
+    //    return;
+    
+    _programObject->activate();
+    psc currentPosition = data.position;
+    glm::mat4 camrot = data.camera.viewRotationMatrix();
+    glm::mat4 transform = glm::mat4(1);
 
-	// setup the data to the shader
-	_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_programObject->setUniform("ModelTransform", transform);
-	_programObject->setUniform("color", _lineColor);
-	_programObject->setUniform("lastPosition", _lastPosition);
-	setPscUniforms(*_programObject.get(), data.camera, data.position);
+    // setup the data to the shader
+    _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _programObject->setUniform("ModelTransform", transform);
+    _programObject->setUniform("color", _lineColor);
+    _programObject->setUniform("lastPosition", _lastPosition);
+    setPscUniforms(*_programObject.get(), data.camera, data.position);
 
-	if (_drawLine) {
-		glLineWidth(_lineWidth);
-		glBindVertexArray(_vaoID);
-		glDrawArrays(GL_LINE_STRIP, 0, static_cast<GLsizei>(_vertexArray.size()));
-		glBindVertexArray(0);
-		glLineWidth(1.f);
-	}
-	
-	//float pointSize = std::min((11-exp),5.f);
-	//glPointSize(5);
-	glEnable(GL_PROGRAM_POINT_SIZE);
-	
-	//GLfloat distanceParams[] = { 1.0f, 5.0f, 10.f }; //a, b, c
-	//GLfloat fadeThreshold[] = { 0.1f };
-	//
-	//glPointParameterf(GL_POINT_SIZE_MAX, 5.0f);
-	//glPointParameterf(GL_POINT_SIZE_MIN, 1.0f);
-	//glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, distanceParams);
-	////=> size = clamp(size*sqrt(1/(a+b*d+c*d^2)));
-	//glPointParameterfv(GL_POINT_FADE_THRESHOLD_SIZE, fadeThreshold);
+    if (_drawLine) {
+        glLineWidth(_lineWidth);
+        glBindVertexArray(_vaoID);
+        glDrawArrays(GL_LINE_STRIP, 0, static_cast<GLsizei>(_vertexArray.size()));
+        glBindVertexArray(0);
+        glLineWidth(1.f);
+    }
+    
+    //float pointSize = std::min((11-exp),5.f);
+    //glPointSize(5);
+    glEnable(GL_PROGRAM_POINT_SIZE);
+    
+    //GLfloat distanceParams[] = { 1.0f, 5.0f, 10.f }; //a, b, c
+    //GLfloat fadeThreshold[] = { 0.1f };
+    //
+    //glPointParameterf(GL_POINT_SIZE_MAX, 5.0f);
+    //glPointParameterf(GL_POINT_SIZE_MIN, 1.0f);
+    //glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, distanceParams);
+    ////=> size = clamp(size*sqrt(1/(a+b*d+c*d^2)));
+    //glPointParameterfv(GL_POINT_FADE_THRESHOLD_SIZE, fadeThreshold);
 
-	glBindVertexArray(_vaoID);
-	glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(_vertexArray.size()));
-	glBindVertexArray(0);
-	
+    glBindVertexArray(_vaoID);
+    glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(_vertexArray.size()));
+    glBindVertexArray(0);
+    
     glDisable(GL_PROGRAM_POINT_SIZE);
 
-	_programObject->deactivate();
+    _programObject->deactivate();
 }
 
 void RenderablePath::update(const UpdateData& data) {
-	if (data.isTimeJump)
-		_needsSweep = true;
+    if (data.isTimeJump)
+        _needsSweep = true;
 
-	if (_needsSweep) {
-		calculatePath(_observer);
-		sendToGPU();
-		_needsSweep = false;
-	}
+    if (_needsSweep) {
+        calculatePath(_observer);
+        sendToGPU();
+        _needsSweep = false;
+    }
 
-	if (_programObject->isDirty())
-		_programObject->rebuildFromFile();
+    if (_programObject->isDirty())
+        _programObject->rebuildFromFile();
 }
 
 void RenderablePath::calculatePath(std::string observer) {
-	double interval = (_stop - _start);
-	int segments = static_cast<int>(interval /_increment);
+    double interval = (_stop - _start);
+    int segments = static_cast<int>(interval /_increment);
 
     if (segments == 0)
         return;
 
-	double lightTime;
-//	bool correctPosition = true;
+    double lightTime;
+//    bool correctPosition = true;
 
-	double currentTime = _start;
-	_vertexArray.resize(segments);
+    double currentTime = _start;
+    _vertexArray.resize(segments);
 
     psc pscPos;
-	//float r, g, b;
-	//float g = _lineColor[1];
-	//float b = _lineColor[2];
-	for (int i = 0; i < segments; i++) {
+    //float r, g, b;
+    //float g = _lineColor[1];
+    //float b = _lineColor[2];
+    for (int i = 0; i < segments; i++) {
         glm::dvec3 p =
         SpiceManager::ref().targetPosition(_target, observer, _frame, {}, currentTime, lightTime);
         pscPos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
-		pscPos[3] += 3;
-			
-		//if (!correctPosition) {
-		//	r = 1.f;
-		//	g = b = 0.5f;
-		//}
-		//else if ((i % 8) == 0) {
-		//	r = _lineColor[0];
-		//	g = _lineColor[1];
-		//	b = _lineColor[2];
-		//}
-		//else {
-		//	r = g = b = 0.6f;
-		//}
-		//add position
-		_vertexArray[i] = { pscPos[0], pscPos[1], pscPos[2], pscPos[3] };
-		//add color for position
-		//_vertexArray[i + 1] = { r, g, b, a };
-		currentTime += _increment;
-	}
-	_lastPosition = pscPos.dvec4();
+        pscPos[3] += 3;
+            
+        //if (!correctPosition) {
+        //    r = 1.f;
+        //    g = b = 0.5f;
+        //}
+        //else if ((i % 8) == 0) {
+        //    r = _lineColor[0];
+        //    g = _lineColor[1];
+        //    b = _lineColor[2];
+        //}
+        //else {
+        //    r = g = b = 0.6f;
+        //}
+        //add position
+        _vertexArray[i] = { pscPos[0], pscPos[1], pscPos[2], pscPos[3] };
+        //add color for position
+        //_vertexArray[i + 1] = { r, g, b, a };
+        currentTime += _increment;
+    }
+    _lastPosition = pscPos.dvec4();
 
-	glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vertexArray.size() *  sizeof(VertexInfo), &_vertexArray[0]);
+    glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vertexArray.size() *  sizeof(VertexInfo), &_vertexArray[0]);
 }
 
 void RenderablePath::sendToGPU() {
-	glGenVertexArrays(1, &_vaoID);
-	glGenBuffers(1, &_vBufferID);
+    glGenVertexArrays(1, &_vaoID);
+    glGenBuffers(1, &_vBufferID);
 
-	glBindVertexArray(_vaoID);
-	
-	glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
-	glBufferData(GL_ARRAY_BUFFER, _vertexArray.size() * sizeof(VertexInfo), NULL, GL_STREAM_DRAW); // orphaning the buffer, sending NULL data.
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vertexArray.size() * sizeof(VertexInfo), &_vertexArray[0]);
+    glBindVertexArray(_vaoID);
+    
+    glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
+    glBufferData(GL_ARRAY_BUFFER, _vertexArray.size() * sizeof(VertexInfo), NULL, GL_STREAM_DRAW); // orphaning the buffer, sending NULL data.
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vertexArray.size() * sizeof(VertexInfo), &_vertexArray[0]);
 
-	
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
-	//glEnableVertexAttribArray(1);
-	//glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(VertexInfo) * 2, (void*)(sizeof(VertexInfo)));
+    
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
+    //glEnableVertexAttribArray(1);
+    //glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(VertexInfo) * 2, (void*)(sizeof(VertexInfo)));
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 }
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderablepath.h b/modules/base/rendering/renderablepath.h
index a97cfd576b..7affba2732 100644
--- a/modules/base/rendering/renderablepath.h
+++ b/modules/base/rendering/renderablepath.h
@@ -32,61 +32,61 @@
 #include <ghoul/opengl/ghoul_gl.h>
 
 namespace ghoul {
-	namespace opengl {
-		class ProgramObject;
-		class Texture;
-	}
+    namespace opengl {
+        class ProgramObject;
+        class Texture;
+    }
 }
 
 namespace openspace {
 
 class RenderablePath : public Renderable {
 public:
-	RenderablePath(const ghoul::Dictionary& dictionary);
+    RenderablePath(const ghoul::Dictionary& dictionary);
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
-	void calculatePath(std::string observer);
+    void calculatePath(std::string observer);
 private:
-	struct VertexInfo {
-		float x, y, z, e;
-		//float r, g, b, a;
-	};
-	void sendToGPU();
-	void addPosition(psc pos);
-	void addColor(glm::vec4 col);
+    struct VertexInfo {
+        float x, y, z, e;
+        //float r, g, b, a;
+    };
+    void sendToGPU();
+    void addPosition(psc pos);
+    void addColor(glm::vec4 col);
 
-	glm::vec3 _lineColor;
-	glm::vec4 _lastPosition;
-	properties::FloatProperty _lineFade;
-	properties::FloatProperty _lineWidth;
-	properties::BoolProperty _drawLine;
+    glm::vec3 _lineColor;
+    glm::vec4 _lastPosition;
+    properties::FloatProperty _lineFade;
+    properties::FloatProperty _lineWidth;
+    properties::BoolProperty _drawLine;
 
-	std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
-	bool _successfullDictionaryFetch;
+    bool _successfullDictionaryFetch;
 
-	std::string _target;
-	std::string _observer;
-	std::string _frame;
+    std::string _target;
+    std::string _observer;
+    std::string _frame;
 
-	GLuint _vaoID;
-	GLuint _vBufferID;
-		
-	bool _needsSweep;
+    GLuint _vaoID;
+    GLuint _vBufferID;
+        
+    bool _needsSweep;
 
-	std::vector<VertexInfo> _vertexArray;
-		
-	float _increment;
-	double _start;
-	double _stop;
-	float _distanceFade;
+    std::vector<VertexInfo> _vertexArray;
+        
+    float _increment;
+    double _start;
+    double _stop;
+    float _distanceFade;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderableplane.cpp b/modules/base/rendering/renderableplane.cpp
index 08af66a937..0274e4882b 100644
--- a/modules/base/rendering/renderableplane.cpp
+++ b/modules/base/rendering/renderableplane.cpp
@@ -38,80 +38,80 @@
 #include <ghoul/opengl/textureunit.h>
 
 namespace {
-	const std::string _loggerCat = "RenderablePlane";
+    const std::string _loggerCat = "RenderablePlane";
 
-	const std::string keyFieldlines = "Fieldlines";
-	const std::string keyFilename = "File";
-	const std::string keyHints = "Hints";
-	const std::string keyShaders = "Shaders";
-	const std::string keyVertexShader = "VertexShader";
-	const std::string keyFragmentShader = "FragmentShader";
+    const std::string keyFieldlines = "Fieldlines";
+    const std::string keyFilename = "File";
+    const std::string keyHints = "Hints";
+    const std::string keyShaders = "Shaders";
+    const std::string keyVertexShader = "VertexShader";
+    const std::string keyFragmentShader = "FragmentShader";
 }
 
 namespace openspace {
 
 RenderablePlane::RenderablePlane(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _texturePath("texture", "Texture")
-	, _billboard("billboard", "Billboard", false)
-	, _projectionListener("projectionListener", "DisplayProjections", false)
-	, _size("size", "Size", glm::vec2(1,1), glm::vec2(0.f), glm::vec2(1.f, 25.f))
-	, _origin(Origin::Center)
-	, _shader(nullptr)
+    : Renderable(dictionary)
+    , _texturePath("texture", "Texture")
+    , _billboard("billboard", "Billboard", false)
+    , _projectionListener("projectionListener", "DisplayProjections", false)
+    , _size("size", "Size", glm::vec2(1,1), glm::vec2(0.f), glm::vec2(1.f, 25.f))
+    , _origin(Origin::Center)
+    , _shader(nullptr)
     , _textureIsDirty(false)
     , _texture(nullptr)
-	, _quad(0)
-	, _vertexPositionBuffer(0)
+    , _quad(0)
+    , _vertexPositionBuffer(0)
 {
     glm::vec2 size;
-	dictionary.getValue("Size", size);
+    dictionary.getValue("Size", size);
     _size = size;
 
-	if (dictionary.hasKey("Name")){
-		dictionary.getValue("Name", _nodeName);
-	}
+    if (dictionary.hasKey("Name")){
+        dictionary.getValue("Name", _nodeName);
+    }
 
-	std::string origin;
-	if (dictionary.getValue("Origin", origin)) {
-		if (origin == "LowerLeft") {
-			_origin = Origin::LowerLeft;
-		}
-		else if (origin == "LowerRight") {
-			_origin = Origin::LowerRight;
-		}
-		else if (origin == "UpperLeft") {
-			_origin = Origin::UpperLeft;
-		}
-		else if (origin == "UpperRight") {
-			_origin = Origin::UpperRight;
-		}
-		else if (origin == "Center") {
-			_origin = Origin::Center;
-		}
-	}
+    std::string origin;
+    if (dictionary.getValue("Origin", origin)) {
+        if (origin == "LowerLeft") {
+            _origin = Origin::LowerLeft;
+        }
+        else if (origin == "LowerRight") {
+            _origin = Origin::LowerRight;
+        }
+        else if (origin == "UpperLeft") {
+            _origin = Origin::UpperLeft;
+        }
+        else if (origin == "UpperRight") {
+            _origin = Origin::UpperRight;
+        }
+        else if (origin == "Center") {
+            _origin = Origin::Center;
+        }
+    }
 
-	// Attempt to get the billboard value
-	bool billboard = false;
-	if (dictionary.getValue("Billboard", billboard)) {
-		_billboard = billboard;
-	}
-	if (dictionary.hasKey("ProjectionListener")){
-		bool projectionListener = false;
-		if (dictionary.getValue("ProjectionListener", projectionListener)) {
-			_projectionListener = projectionListener;
-		}
-	}
+    // Attempt to get the billboard value
+    bool billboard = false;
+    if (dictionary.getValue("Billboard", billboard)) {
+        _billboard = billboard;
+    }
+    if (dictionary.hasKey("ProjectionListener")){
+        bool projectionListener = false;
+        if (dictionary.getValue("ProjectionListener", projectionListener)) {
+            _projectionListener = projectionListener;
+        }
+    }
 
 
-	std::string texturePath = "";
-	bool success = dictionary.getValue("Texture", texturePath);
-	if (success) {
-		_texturePath = absPath(texturePath);
+    std::string texturePath = "";
+    bool success = dictionary.getValue("Texture", texturePath);
+    if (success) {
+        _texturePath = absPath(texturePath);
         _textureFile = new ghoul::filesystem::File(_texturePath);
     }
 
     addProperty(_billboard);
-	addProperty(_texturePath);
+    addProperty(_texturePath);
     _texturePath.onChange(std::bind(&RenderablePlane::loadTexture, this));
     _textureFile->setCallback([&](const ghoul::filesystem::File&) { _textureIsDirty = true; });
 
@@ -119,7 +119,7 @@ RenderablePlane::RenderablePlane(const ghoul::Dictionary& dictionary)
     //_size.onChange(std::bind(&RenderablePlane::createPlane, this));
     _size.onChange([this](){ _planeIsDirty = true; });
 
-	setBoundingSphere(_size.value());
+    setBoundingSphere(_size.value());
 }
 
 RenderablePlane::~RenderablePlane() {
@@ -128,12 +128,12 @@ RenderablePlane::~RenderablePlane() {
 }
 
 bool RenderablePlane::isReady() const {
-	bool ready = true;
-	if (!_shader)
-		ready &= false;
-	if(!_texture)
-		ready &= false;
-	return ready;
+    bool ready = true;
+    if (!_shader)
+        ready &= false;
+    if(!_texture)
+        ready &= false;
+    return ready;
 }
 
 bool RenderablePlane::initialize() {
@@ -141,7 +141,7 @@ bool RenderablePlane::initialize() {
     glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
     createPlane();
 
-	if (_shader == nullptr) {
+    if (_shader == nullptr) {
         // Plane Program
 
         RenderEngine& renderEngine = OsEng.renderEngine();
@@ -155,21 +155,21 @@ bool RenderablePlane::initialize() {
 
     loadTexture();
 
-	return isReady();
+    return isReady();
 }
 
 bool RenderablePlane::deinitialize() {
-	glDeleteVertexArrays(1, &_quad);
-	_quad = 0;
+    glDeleteVertexArrays(1, &_quad);
+    _quad = 0;
 
-	glDeleteBuffers(1, &_vertexPositionBuffer);
-	_vertexPositionBuffer = 0;
+    glDeleteBuffers(1, &_vertexPositionBuffer);
+    _vertexPositionBuffer = 0;
 
-	if (!_projectionListener){
-		// its parents job to kill texture
-		// iff projectionlistener 
-		_texture = nullptr;
-	}
+    if (!_projectionListener){
+        // its parents job to kill texture
+        // iff projectionlistener 
+        _texture = nullptr;
+    }
 
     delete _textureFile;
     _textureFile = nullptr;
@@ -181,42 +181,42 @@ bool RenderablePlane::deinitialize() {
         _shader = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 void RenderablePlane::render(const RenderData& data) {
-	glm::mat4 transform = glm::mat4(1.0);
-	if (_billboard)
-		transform = glm::inverse(data.camera.viewRotationMatrix());
+    glm::mat4 transform = glm::mat4(1.0);
+    if (_billboard)
+        transform = glm::inverse(data.camera.viewRotationMatrix());
 
-	// Activate shader
-	_shader->activate();
-	if (_projectionListener){
-		//get parent node-texture and set with correct dimensions  
-		SceneGraphNode* textureNode = OsEng.renderEngine().scene()->sceneGraphNode(_nodeName)->parent();
-		if (textureNode != nullptr){
-			RenderablePlanetProjection* t = static_cast<RenderablePlanetProjection*>(textureNode->renderable());
+    // Activate shader
+    _shader->activate();
+    if (_projectionListener){
+        //get parent node-texture and set with correct dimensions  
+        SceneGraphNode* textureNode = OsEng.renderEngine().scene()->sceneGraphNode(_nodeName)->parent();
+        if (textureNode != nullptr){
+            RenderablePlanetProjection* t = static_cast<RenderablePlanetProjection*>(textureNode->renderable());
             _texture = std::unique_ptr<ghoul::opengl::Texture>(t->baseTexture());
-			float h = _texture->height();
-			float w = _texture->width();
-			float scale = h / w;
-			transform = glm::scale(transform, glm::vec3(1.f, scale, 1.f));
-		}
-	}
+            float h = _texture->height();
+            float w = _texture->width();
+            float scale = h / w;
+            transform = glm::scale(transform, glm::vec3(1.f, scale, 1.f));
+        }
+    }
 
-	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(*_shader.get(), data.camera, data.position);
+    _shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _shader->setUniform("ModelTransform", transform);
+    setPscUniforms(*_shader.get(), data.camera, data.position);
 
-	ghoul::opengl::TextureUnit unit;
-	unit.activate();
-	_texture->bind();
-	_shader->setUniform("texture1", unit);
+    ghoul::opengl::TextureUnit unit;
+    unit.activate();
+    _texture->bind();
+    _shader->setUniform("texture1", unit);
 
-	glBindVertexArray(_quad);
-	glDrawArrays(GL_TRIANGLES, 0, 6);
+    glBindVertexArray(_quad);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
 
-	_shader->deactivate();
+    _shader->deactivate();
 }
 
 void RenderablePlane::update(const UpdateData& data) {
@@ -233,32 +233,32 @@ void RenderablePlane::update(const UpdateData& data) {
 }
 
 void RenderablePlane::loadTexture() {
-	if (_texturePath.value() != "") {
+    if (_texturePath.value() != "") {
         std::unique_ptr<ghoul::opengl::Texture> texture = ghoul::io::TextureReader::ref().loadTexture(absPath(_texturePath));
-		if (texture) {
-			LDEBUG("Loaded texture from '" << absPath(_texturePath) << "'");
-			texture->uploadTexture();
+        if (texture) {
+            LDEBUG("Loaded texture from '" << absPath(_texturePath) << "'");
+            texture->uploadTexture();
 
-			// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
-			texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
+            // Textures of planets looks much smoother with AnisotropicMipMap rather than linear
+            texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
 
             _texture = std::move(texture);
 
             delete _textureFile;
             _textureFile = new ghoul::filesystem::File(_texturePath);
             _textureFile->setCallback([&](const ghoul::filesystem::File&) { _textureIsDirty = true; });
-		}
-	}
+        }
+    }
 }
 
 void RenderablePlane::createPlane() {
     // ============================
-    // 		GEOMETRY (quad)
+    //         GEOMETRY (quad)
     // ============================
     const GLfloat size = _size.value()[0];
     const GLfloat w = _size.value()[1];
     const GLfloat vertex_data[] = { // square of two triangles (sigh)
-        //	  x      y     z     w     s     t
+        //      x      y     z     w     s     t
         -size, -size, 0.0f, w, 0, 1,
         size, size, 0.0f, w, 1, 0,
         -size, size, 0.0f, w, 0, 0,
diff --git a/modules/base/rendering/renderableplane.h b/modules/base/rendering/renderableplane.h
index 734edc17d3..eaa5cf4445 100644
--- a/modules/base/rendering/renderableplane.h
+++ b/modules/base/rendering/renderableplane.h
@@ -42,46 +42,46 @@ namespace ghoul {
 }
 
 namespace openspace {
-	struct LinePoint;
+    struct LinePoint;
 
 class RenderablePlane : public Renderable {
 
-	enum class Origin {
-		LowerLeft, LowerRight, UpperLeft, UpperRight, Center
-	};
+    enum class Origin {
+        LowerLeft, LowerRight, UpperLeft, UpperRight, Center
+    };
 
 public:
-	RenderablePlane(const ghoul::Dictionary& dictionary);
+    RenderablePlane(const ghoul::Dictionary& dictionary);
     ~RenderablePlane();
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
-	void loadTexture();
+    void loadTexture();
     void createPlane();
 
-	properties::StringProperty _texturePath;
-	properties::BoolProperty _billboard;
-	properties::BoolProperty _projectionListener;
+    properties::StringProperty _texturePath;
+    properties::BoolProperty _billboard;
+    properties::BoolProperty _projectionListener;
     properties::Vec2Property _size;
 
-	Origin _origin;
-	std::string _nodeName;
+    Origin _origin;
+    std::string _nodeName;
 
     bool _planeIsDirty;
 
-	std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
+    std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
     bool _textureIsDirty;
     std::unique_ptr<ghoul::opengl::Texture> _texture;
     ghoul::filesystem::File* _textureFile;
-	GLuint _quad;
-	GLuint _vertexPositionBuffer;
+    GLuint _quad;
+    GLuint _vertexPositionBuffer;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderableplanet.cpp b/modules/base/rendering/renderableplanet.cpp
index 3f91eb1d81..6a3c333c1a 100644
--- a/modules/base/rendering/renderableplanet.cpp
+++ b/modules/base/rendering/renderableplanet.cpp
@@ -209,7 +209,7 @@ void RenderablePlanet::render(const RenderData& data)
     psc sun_pos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
 
     // setup the data to the shader
-//	_programObject->setUniform("camdir", camSpaceEye);
+//    _programObject->setUniform("camdir", camSpaceEye);
     _programObject->setUniform("transparency", _alpha);
     _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
     _programObject->setUniform("ModelTransform", transform);
diff --git a/modules/base/rendering/renderableplanet.h b/modules/base/rendering/renderableplanet.h
index d7157d3f10..69447e1d3d 100644
--- a/modules/base/rendering/renderableplanet.h
+++ b/modules/base/rendering/renderableplanet.h
@@ -52,9 +52,9 @@ public:
 
     bool initialize() override;
     bool deinitialize() override;
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
+    void render(const RenderData& data) override;
     void update(const UpdateData& data) override;
 
 protected:
@@ -67,15 +67,15 @@ private:
     std::unique_ptr<ghoul::opengl::Texture> _nightTexture;
     planetgeometry::PlanetGeometry* _geometry;
     properties::BoolProperty _performShading;
-	properties::IntProperty _rotation;
-	float _alpha;
+    properties::IntProperty _rotation;
+    float _alpha;
 
-	glm::dmat3 _stateMatrix;
-	std::string _nightTexturePath;
-	std::string _frame;
-	std::string _target;
-	bool _hasNightTexture;
-	double _time;
+    glm::dmat3 _stateMatrix;
+    std::string _nightTexturePath;
+    std::string _frame;
+    std::string _target;
+    bool _hasNightTexture;
+    double _time;
 };
 
 }  // namespace openspace
diff --git a/modules/base/rendering/renderablesphere.cpp b/modules/base/rendering/renderablesphere.cpp
index 879086eb33..259afdf6c7 100644
--- a/modules/base/rendering/renderablesphere.cpp
+++ b/modules/base/rendering/renderablesphere.cpp
@@ -37,7 +37,7 @@
 #include <math.h>
 
 namespace {
-	const std::string _loggerCat = "RenderableSphere";
+    const std::string _loggerCat = "RenderableSphere";
 
     const std::string keySize = "Size";
     const std::string keySegments = "Segments";
@@ -53,15 +53,15 @@ namespace {
 namespace openspace {
 
 RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _texturePath("texture", "Texture")
+    : Renderable(dictionary)
+    , _texturePath("texture", "Texture")
     , _orientation("orientation", "Orientation")
     , _size("size", "Size", glm::vec2(1.f, 1.f), glm::vec2(0.f), glm::vec2(100.f))
     , _segments("segments", "Segments", 8, 4, 100)
     , _transparency("transparency", "Transparency", 1.f, 0.f, 1.f)
-	, _shader(nullptr)
-	, _texture(nullptr)
-	, _sphere(nullptr)
+    , _shader(nullptr)
+    , _texture(nullptr)
+    , _sphere(nullptr)
     , _sphereIsDirty(false)
 {
     if (dictionary.hasKeyAndValue<glm::vec2>(keySize)) {
@@ -105,8 +105,8 @@ RenderableSphere::RenderableSphere(const ghoul::Dictionary& dictionary)
 
     addProperty(_transparency);
 
-	addProperty(_texturePath);
-	_texturePath.onChange(std::bind(&RenderableSphere::loadTexture, this));
+    addProperty(_texturePath);
+    _texturePath.onChange(std::bind(&RenderableSphere::loadTexture, this));
 }
 
 bool RenderableSphere::isReady() const {
@@ -128,7 +128,7 @@ bool RenderableSphere::initialize() {
 
     loadTexture();
 
-	return isReady();
+    return isReady();
 }
 
 bool RenderableSphere::deinitialize() {
@@ -144,12 +144,12 @@ bool RenderableSphere::deinitialize() {
     }
 
 
-	return true;
+    return true;
 }
 
 void RenderableSphere::render(const RenderData& data) {
 
-	glm::mat4 transform = glm::mat4(1.0);
+    glm::mat4 transform = glm::mat4(1.0);
 
     transform = glm::rotate(transform, static_cast<float>(M_PI_2), glm::vec3(1, 0, 0));
 
@@ -159,16 +159,16 @@ void RenderableSphere::render(const RenderData& data) {
     _shader->activate();
     _shader->setIgnoreUniformLocationError(IgnoreError::Yes);
 
-	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_shader->setUniform("ModelTransform", transform);
+    _shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _shader->setUniform("ModelTransform", transform);
 
-	setPscUniforms(*_shader.get(), data.camera, data.position);
+    setPscUniforms(*_shader.get(), data.camera, data.position);
     _shader->setUniform("alpha", _transparency);
 
-	ghoul::opengl::TextureUnit unit;
-	unit.activate();
-	_texture->bind();
-	_shader->setUniform("texture1", unit);
+    ghoul::opengl::TextureUnit unit;
+    unit.activate();
+    _texture->bind();
+    _shader->setUniform("texture1", unit);
 
     glEnable(GL_CULL_FACE);
     glCullFace(GL_BACK);
@@ -176,7 +176,7 @@ void RenderableSphere::render(const RenderData& data) {
     _sphere->render();
 
     _shader->setIgnoreUniformLocationError(IgnoreError::No);
-	_shader->deactivate();
+    _shader->deactivate();
 }
 
 void RenderableSphere::update(const UpdateData& data) {
@@ -192,20 +192,20 @@ void RenderableSphere::update(const UpdateData& data) {
 }
 
 void RenderableSphere::loadTexture() {
-	if (_texturePath.value() != "") {
+    if (_texturePath.value() != "") {
         std::unique_ptr<ghoul::opengl::Texture> texture = ghoul::io::TextureReader::ref().loadTexture(_texturePath);
-		if (texture) {
-			LDEBUG("Loaded texture from '" << absPath(_texturePath) << "'");
-			texture->uploadTexture();
+        if (texture) {
+            LDEBUG("Loaded texture from '" << absPath(_texturePath) << "'");
+            texture->uploadTexture();
 
-			// Textures of planets looks much smoother with AnisotropicMipMap rather than linear
+            // Textures of planets looks much smoother with AnisotropicMipMap rather than linear
             // TODO: AnisotropicMipMap crashes on ATI cards ---abock
             //texture->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
             texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
 
             _texture = std::move(texture);
-		}
-	}
+        }
+    }
 }
 
 } // namespace openspace
diff --git a/modules/base/rendering/renderablesphere.h b/modules/base/rendering/renderablesphere.h
index 6b4e737c6f..2a2d49c1b0 100644
--- a/modules/base/rendering/renderablesphere.h
+++ b/modules/base/rendering/renderablesphere.h
@@ -40,20 +40,20 @@ class PowerScaledSphere;
 
 class RenderableSphere : public Renderable {
 public:
-	RenderableSphere(const ghoul::Dictionary& dictionary);
+    RenderableSphere(const ghoul::Dictionary& dictionary);
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
-	void loadTexture();
+    void loadTexture();
 
-	properties::StringProperty _texturePath;
+    properties::StringProperty _texturePath;
     properties::OptionProperty _orientation;
 
     properties::Vec2Property _size;
diff --git a/modules/base/rendering/renderablesphericalgrid.cpp b/modules/base/rendering/renderablesphericalgrid.cpp
index 8de5c30c83..b1f62cdb87 100644
--- a/modules/base/rendering/renderablesphericalgrid.cpp
+++ b/modules/base/rendering/renderablesphericalgrid.cpp
@@ -32,7 +32,7 @@
 #include <math.h>
 
 namespace {
-	const std::string _loggerCat = "RenderableSphericalGrid";
+    const std::string _loggerCat = "RenderableSphericalGrid";
     const std::string KeyGridType = "GridType";
     const std::string KeyGridColor = "GridColor";
     const std::string KeyGridMatrix = "GridMatrix";
@@ -53,179 +53,179 @@ RenderableSphericalGrid::RenderableSphericalGrid(const ghoul::Dictionary& dictio
     , _iBufferID(0)
     , _mode(GL_LINES)
 {
-	_gridMatrix = glm::mat4(1);
-	dictionary.getValue(KeyGridType, _gridType);
-	dictionary.getValue(KeyGridColor, _gridColor);
+    _gridMatrix = glm::mat4(1);
+    dictionary.getValue(KeyGridType, _gridType);
+    dictionary.getValue(KeyGridColor, _gridColor);
 
-	staticGrid = dictionary.getValue(KeyGridMatrix, _gridMatrix);
-	if (!staticGrid){
-		staticGrid = dictionary.getValue(KeyGridParentsRotation, _parentsRotation);
-	}
-	
-	dictionary.getValue(KeyGridSegments, _segments);
+    staticGrid = dictionary.getValue(KeyGridMatrix, _gridMatrix);
+    if (!staticGrid){
+        staticGrid = dictionary.getValue(KeyGridParentsRotation, _parentsRotation);
+    }
+    
+    dictionary.getValue(KeyGridSegments, _segments);
 
 
-	/*glm::vec2 radius;
-	dictionary.getValue(constants::renderablesphericalgrid::gridRadius, radius);
-	*/
+    /*glm::vec2 radius;
+    dictionary.getValue(constants::renderablesphericalgrid::gridRadius, radius);
+    */
 
-	_isize = int(6 * _segments * _segments);
-	_vsize = int((_segments + 1) * (_segments + 1));
-	_varray = new Vertex[_vsize];
-	_iarray = new int[_isize];
+    _isize = int(6 * _segments * _segments);
+    _vsize = int((_segments + 1) * (_segments + 1));
+    _varray = new Vertex[_vsize];
+    _iarray = new int[_isize];
 
-	static_assert(sizeof(Vertex) == 64, "The size of the Vertex needs to be 64 for performance");
+    static_assert(sizeof(Vertex) == 64, "The size of the Vertex needs to be 64 for performance");
 
-	int nr = 0;
-	const float fsegments = static_cast<float>(_segments);
-	const float r = static_cast<float>(radius[0]);
+    int nr = 0;
+    const float fsegments = static_cast<float>(_segments);
+    const float r = static_cast<float>(radius[0]);
 
-	//int nr2 = 0;
+    //int nr2 = 0;
 
-	for (int i = 0; i <= _segments; i++) {
-		// define an extra vertex around the y-axis due to texture mapping
-		for (int j = 0; j <= _segments; j++) {
-			const float fi = static_cast<float>(i);
-			const float fj = static_cast<float>(j);
+    for (int i = 0; i <= _segments; i++) {
+        // define an extra vertex around the y-axis due to texture mapping
+        for (int j = 0; j <= _segments; j++) {
+            const float fi = static_cast<float>(i);
+            const float fj = static_cast<float>(j);
 
-			// inclination angle (north to south)
-			const float theta = fi * float(M_PI) / fsegments*2.f;  // 0 -> PI
+            // inclination angle (north to south)
+            const float theta = fi * float(M_PI) / fsegments*2.f;  // 0 -> PI
 
-			// azimuth angle (east to west)
-			const float phi = fj * float(M_PI) * 2.0f / fsegments;  // 0 -> 2*PI
+            // azimuth angle (east to west)
+            const float phi = fj * float(M_PI) * 2.0f / fsegments;  // 0 -> 2*PI
 
-			const float x = r * sin(phi) * sin(theta);  //
-			const float y = r * cos(theta);             // up
-			const float z = r * cos(phi) * sin(theta);  //
-			
-			glm::vec3 normal = glm::vec3(x, y, z);
-			if (!(x == 0.f && y == 0.f && z == 0.f))
-				normal = glm::normalize(normal);
+            const float x = r * sin(phi) * sin(theta);  //
+            const float y = r * cos(theta);             // up
+            const float z = r * cos(phi) * sin(theta);  //
+            
+            glm::vec3 normal = glm::vec3(x, y, z);
+            if (!(x == 0.f && y == 0.f && z == 0.f))
+                normal = glm::normalize(normal);
 
-			//const float t1 = fj / fsegments;
-			const float t2 = fi / fsegments;
+            //const float t1 = fj / fsegments;
+            const float t2 = fi / fsegments;
 
-			// tex coord. not used, use to manip color 
-			if (round(y) == 0.0f) _varray[nr].tex[0] = -2;
-			_varray[nr].tex[1] = t2;
+            // tex coord. not used, use to manip color 
+            if (round(y) == 0.0f) _varray[nr].tex[0] = -2;
+            _varray[nr].tex[1] = t2;
 
-			glm::vec4 tmp(x, y, z, 1);
-			glm::mat4 rot = glm::rotate(glm::mat4(1), static_cast<float>(M_PI_2), glm::vec3(1, 0, 0));
-			tmp = _gridMatrix*rot*tmp;
-			
-			for (int i = 0; i < 3; i++){
-				_varray[nr].location[i]  = tmp[i];
-				_varray[nr].normal[i] = normal[i];
-			}
-			_varray[nr].location[3] = static_cast<GLfloat>(radius[1]);			
-			++nr;
-		}
-	}
-	nr = 0;
-	// define indices for all triangles
-	for (int i = 1; i <= _segments; ++i) {
-		for (int j = 0; j < _segments; ++j) {
-			const int t = _segments + 1;
-			_iarray[nr] = t * (i - 1) + j + 0; ++nr;
-			_iarray[nr] = t * (i + 0) + j + 0; ++nr;
-			_iarray[nr] = t * (i + 0) + j + 1; ++nr;
-			_iarray[nr] = t * (i - 1) + j + 1; ++nr;
-			_iarray[nr] = t * (i - 1) + j + 0; ++nr;
-		}
-	}
+            glm::vec4 tmp(x, y, z, 1);
+            glm::mat4 rot = glm::rotate(glm::mat4(1), static_cast<float>(M_PI_2), glm::vec3(1, 0, 0));
+            tmp = _gridMatrix*rot*tmp;
+            
+            for (int i = 0; i < 3; i++){
+                _varray[nr].location[i]  = tmp[i];
+                _varray[nr].normal[i] = normal[i];
+            }
+            _varray[nr].location[3] = static_cast<GLfloat>(radius[1]);            
+            ++nr;
+        }
+    }
+    nr = 0;
+    // define indices for all triangles
+    for (int i = 1; i <= _segments; ++i) {
+        for (int j = 0; j < _segments; ++j) {
+            const int t = _segments + 1;
+            _iarray[nr] = t * (i - 1) + j + 0; ++nr;
+            _iarray[nr] = t * (i + 0) + j + 0; ++nr;
+            _iarray[nr] = t * (i + 0) + j + 1; ++nr;
+            _iarray[nr] = t * (i - 1) + j + 1; ++nr;
+            _iarray[nr] = t * (i - 1) + j + 0; ++nr;
+        }
+    }
 }
 
 RenderableSphericalGrid::~RenderableSphericalGrid(){
-	deinitialize();
+    deinitialize();
 
-	// Delete not done in deinitialize because new is done in constructor
-	delete[] _varray;
-	delete[] _iarray;
+    // Delete not done in deinitialize because new is done in constructor
+    delete[] _varray;
+    delete[] _iarray;
 }
 
 bool RenderableSphericalGrid::isReady() const {
-	bool ready = true;
-	ready &= (_gridProgram != nullptr);
-	return ready;
+    bool ready = true;
+    ready &= (_gridProgram != nullptr);
+    return ready;
 }
 
 bool RenderableSphericalGrid::deinitialize(){
-	glDeleteVertexArrays(1,&_vaoID);
-	_vaoID = 0;
+    glDeleteVertexArrays(1,&_vaoID);
+    _vaoID = 0;
 
-	glDeleteBuffers(1,&_vBufferID);
-	_vBufferID = 0;
+    glDeleteBuffers(1,&_vBufferID);
+    _vBufferID = 0;
 
-	glDeleteBuffers(1,&_iBufferID);
-	_iBufferID = 0;
+    glDeleteBuffers(1,&_iBufferID);
+    _iBufferID = 0;
 
-	return true;
+    return true;
 }
 
 bool RenderableSphericalGrid::initialize(){
-	bool completeSuccess = true;
-	if (_gridProgram == nullptr)
-		completeSuccess &= OsEng.ref().configurationManager().getValue("GridProgram", _gridProgram);
+    bool completeSuccess = true;
+    if (_gridProgram == nullptr)
+        completeSuccess &= OsEng.ref().configurationManager().getValue("GridProgram", _gridProgram);
 
-	// Initialize and upload to graphics card
-	glGenVertexArrays(1, &_vaoID);
-	glGenBuffers(1, &_vBufferID);
-	glGenBuffers(1, &_iBufferID);
+    // Initialize and upload to graphics card
+    glGenVertexArrays(1, &_vaoID);
+    glGenBuffers(1, &_vBufferID);
+    glGenBuffers(1, &_iBufferID);
 
-	// First VAO setup
-	glBindVertexArray(_vaoID);
-	glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
-	glBufferData(GL_ARRAY_BUFFER, _vsize * sizeof(Vertex), _varray, GL_STATIC_DRAW);
+    // First VAO setup
+    glBindVertexArray(_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, _vBufferID);
+    glBufferData(GL_ARRAY_BUFFER, _vsize * sizeof(Vertex), _varray, GL_STATIC_DRAW);
 
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, location)));
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex)));
-	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
-		reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
-	
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, _isize * sizeof(int), _iarray, GL_STATIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, location)));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, tex)));
+    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex),
+        reinterpret_cast<const GLvoid*>(offsetof(Vertex, normal)));
+    
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, _isize * sizeof(int), _iarray, GL_STATIC_DRAW);
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 void RenderableSphericalGrid::render(const RenderData& data){
-	_gridProgram->activate();
+    _gridProgram->activate();
 
-	glm::mat4 transform;
-	for (int i = 0; i < 3; i++){
-		for (int j = 0; j < 3; j++){
-			transform[i][j] = static_cast<float>(_parentMatrix[i][j]);
-		}
-	}
+    glm::mat4 transform;
+    for (int i = 0; i < 3; i++){
+        for (int j = 0; j < 3; j++){
+            transform[i][j] = static_cast<float>(_parentMatrix[i][j]);
+        }
+    }
 
 
     using IgnoreError = ghoul::opengl::ProgramObject::IgnoreError;
 
-	// setup the data to the shader
-	_gridProgram->setIgnoreUniformLocationError(IgnoreError::Yes);
-	_gridProgram->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_gridProgram->setUniform("ModelTransform", transform);
-	setPscUniforms(*_gridProgram, data.camera, data.position);
-	_gridProgram->setUniform("gridColor", _gridColor);
+    // setup the data to the shader
+    _gridProgram->setIgnoreUniformLocationError(IgnoreError::Yes);
+    _gridProgram->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _gridProgram->setUniform("ModelTransform", transform);
+    setPscUniforms(*_gridProgram, data.camera, data.position);
+    _gridProgram->setUniform("gridColor", _gridColor);
 
-	glLineWidth(0.5f);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	glEnable(GL_BLEND);
-	glEnable(GL_LINE_SMOOTH);
+    glLineWidth(0.5f);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    glEnable(GL_BLEND);
+    glEnable(GL_LINE_SMOOTH);
 
-	glBindVertexArray(_vaoID);  // select first VAO
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID);
-	glDrawElements(_mode, _isize, GL_UNSIGNED_INT, 0);
-	glBindVertexArray(0);
+    glBindVertexArray(_vaoID);  // select first VAO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _iBufferID);
+    glDrawElements(_mode, _isize, GL_UNSIGNED_INT, 0);
+    glBindVertexArray(0);
 
-	_gridProgram->deactivate();
+    _gridProgram->deactivate();
 }
 
 void RenderableSphericalGrid::update(const UpdateData& data) {
diff --git a/modules/base/rendering/renderablesphericalgrid.h b/modules/base/rendering/renderablesphericalgrid.h
index b695364ac0..6c7cf37da2 100644
--- a/modules/base/rendering/renderablesphericalgrid.h
+++ b/modules/base/rendering/renderablesphericalgrid.h
@@ -38,46 +38,46 @@
 namespace openspace {
 class RenderableSphericalGrid : public Renderable{
 public:
-	RenderableSphericalGrid(const ghoul::Dictionary& dictionary);
-	~RenderableSphericalGrid();
+    RenderableSphericalGrid(const ghoul::Dictionary& dictionary);
+    ~RenderableSphericalGrid();
 
-	bool initialize()   override;
-	bool deinitialize() override;
+    bool initialize()   override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 private:
 protected:
-	typedef struct {
-		GLfloat location[4];
-		GLfloat tex[2];
-		GLfloat normal[3];
-		GLubyte padding[28];  // Pads the struct out to 64 bytes for performance increase
-	} Vertex;
+    typedef struct {
+        GLfloat location[4];
+        GLfloat tex[2];
+        GLfloat normal[3];
+        GLubyte padding[28];  // Pads the struct out to 64 bytes for performance increase
+    } Vertex;
 
 
-	ghoul::opengl::ProgramObject* _gridProgram;
-	std::string _gridType;
-	glm::vec4 _gridColor;
-	glm::mat4 _gridMatrix;
-	int _segments;
+    ghoul::opengl::ProgramObject* _gridProgram;
+    std::string _gridType;
+    glm::vec4 _gridColor;
+    glm::mat4 _gridMatrix;
+    int _segments;
 
-	bool staticGrid;
-	std::string _parentsRotation;
-	glm::dmat3 _parentMatrix;
-	PowerScaledScalar _radius;
+    bool staticGrid;
+    std::string _parentsRotation;
+    glm::dmat3 _parentMatrix;
+    PowerScaledScalar _radius;
 
-	GLuint _vaoID = 3;
-	GLuint _vBufferID = 4;
-	GLuint _iBufferID = 5;
+    GLuint _vaoID = 3;
+    GLuint _vBufferID = 4;
+    GLuint _iBufferID = 5;
 
-	GLenum _mode;
-	unsigned int _isize;
-	unsigned int _vsize;
-	Vertex* _varray;
-	int* _iarray;
+    GLenum _mode;
+    unsigned int _isize;
+    unsigned int _vsize;
+    Vertex* _varray;
+    int* _iarray;
 };
 }// namespace openspace
 #endif
\ No newline at end of file
diff --git a/modules/base/rendering/renderablestars.cpp b/modules/base/rendering/renderablestars.cpp
index cf3fc50022..9cc959270f 100644
--- a/modules/base/rendering/renderablestars.cpp
+++ b/modules/base/rendering/renderablestars.cpp
@@ -309,7 +309,7 @@ void RenderableStars::update(const UpdateData& data) {
         glBindVertexArray(0);
 
         _dataIsDirty = false;
-    }	
+    }    
 
     if (_pointSpreadFunctionTextureIsDirty) {
         LDEBUG("Reloading Point Spread Function texture");
diff --git a/modules/base/rendering/renderabletrail.cpp b/modules/base/rendering/renderabletrail.cpp
index 279792bb07..134586ae5b 100644
--- a/modules/base/rendering/renderabletrail.cpp
+++ b/modules/base/rendering/renderabletrail.cpp
@@ -45,7 +45,7 @@
 namespace {
     const std::string _loggerCat = "RenderableTrail";
     //constants
-	const std::string keyName                    = "Name";
+    const std::string keyName                    = "Name";
         const std::string keyBody                = "Body";
         const std::string keyObserver            = "Observer";
         const std::string keyFrame               = "Frame";
@@ -54,7 +54,7 @@ namespace {
         const std::string keyTropicalOrbitPeriod = "TropicalOrbitPeriod";
         const std::string keyEarthOrbitRatio     = "EarthOrbitRatio";
         const std::string keyDayLength           = "DayLength";
-		const std::string keyStamps				 = "TimeStamps";
+        const std::string keyStamps                 = "TimeStamps";
 }
 
 namespace openspace {
@@ -86,11 +86,11 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
         dictionary.getValue(keyColor, color);
     _lineColor = color;
 
-	bool timeStamps = false;
-	if (dictionary.hasKeyAndValue<bool>(keyStamps))
-		dictionary.getValue(keyStamps, timeStamps);
-	_showTimestamps = timeStamps;
-	addProperty(_showTimestamps);
+    bool timeStamps = false;
+    if (dictionary.hasKeyAndValue<bool>(keyStamps))
+        dictionary.getValue(keyStamps, timeStamps);
+    _showTimestamps = timeStamps;
+    addProperty(_showTimestamps);
 
     _lineColor.setViewOption(properties::Property::ViewOptions::Color);
     addProperty(_lineColor);
@@ -98,7 +98,7 @@ RenderableTrail::RenderableTrail(const ghoul::Dictionary& dictionary)
     addProperty(_lineFade);
 
     addProperty(_lineWidth);
-	_distanceFade = 1.0;
+    _distanceFade = 1.0;
 }
 
 bool RenderableTrail::initialize() {
@@ -160,20 +160,20 @@ void RenderableTrail::render(const RenderData& data) {
     _programObject->setUniform("color", _lineColor);
     _programObject->setUniform("nVertices", static_cast<unsigned int>(_vertexArray.size()));
     _programObject->setUniform("lineFade", _lineFade);
-	_programObject->setUniform("forceFade", _distanceFade);
+    _programObject->setUniform("forceFade", _distanceFade);
 
-	//const psc& position = data.camera.position();
-	//const psc& origin = openspace::OpenSpaceEngine::ref().interactionHandler()->focusNode()->worldPosition();
-	//const PowerScaledScalar& pssl = (position - origin).length();
-	//
-	//if (pssl[0] < 0.000001){
-	//	if (_distanceFade > 0.0f) _distanceFade -= 0.05f;
-	//	_programObject->setUniform("forceFade", _distanceFade);
-	//}
-	//else{
-	//	if (_distanceFade < 1.0f) _distanceFade += 0.05f;
-	//	_programObject->setUniform("forceFade", _distanceFade);
-	//}
+    //const psc& position = data.camera.position();
+    //const psc& origin = openspace::OpenSpaceEngine::ref().interactionHandler()->focusNode()->worldPosition();
+    //const PowerScaledScalar& pssl = (position - origin).length();
+    //
+    //if (pssl[0] < 0.000001){
+    //    if (_distanceFade > 0.0f) _distanceFade -= 0.05f;
+    //    _programObject->setUniform("forceFade", _distanceFade);
+    //}
+    //else{
+    //    if (_distanceFade < 1.0f) _distanceFade += 0.05f;
+    //    _programObject->setUniform("forceFade", _distanceFade);
+    //}
 
     glLineWidth(_lineWidth);
 
@@ -183,18 +183,18 @@ void RenderableTrail::render(const RenderData& data) {
 
     glLineWidth(1.f);
 
-	if (_showTimestamps){
-		glPointSize(5.f);
-		glBindVertexArray(_vaoID);
-		glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(_vertexArray.size()));
-		glBindVertexArray(0);
-	}
+    if (_showTimestamps){
+        glPointSize(5.f);
+        glBindVertexArray(_vaoID);
+        glDrawArrays(GL_POINTS, 0, static_cast<GLsizei>(_vertexArray.size()));
+        glBindVertexArray(0);
+    }
 
     _programObject->deactivate();
 }
 
 void RenderableTrail::update(const UpdateData& data) {
-	if (data.isTimeJump)
+    if (data.isTimeJump)
         _needsSweep = true;
 
     if (_needsSweep) {
@@ -206,12 +206,12 @@ void RenderableTrail::update(const UpdateData& data) {
 
     double lightTime = 0.0;
 
-	bool intervalSet = hasTimeInterval();
-	double start = DBL_MIN;
-	double end = DBL_MAX;
-	if (intervalSet) {
-		getInterval(start, end);
-	}
+    bool intervalSet = hasTimeInterval();
+    double start = DBL_MIN;
+    double end = DBL_MAX;
+    if (intervalSet) {
+        getInterval(start, end);
+    }
 
     // Points in the vertex array should always have a fixed distance. For this reason we
     // keep the first entry in the array floating and always pointing to the current date
@@ -222,11 +222,11 @@ void RenderableTrail::update(const UpdateData& data) {
 
     glm::dvec3 p;
     // Update the floating current time
-	if (start > data.time)
+    if (start > data.time)
         p = SpiceManager::ref().targetPosition(_target, _observer, _frame, {}, start, lightTime);
-	else if (end < data.time)
+    else if (end < data.time)
         p = SpiceManager::ref().targetPosition(_target, _observer, _frame, {}, end, lightTime);
-	else
+    else
         p = SpiceManager::ref().targetPosition(_target, _observer, _frame, {}, data.time, lightTime);
     
     psc pscPos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
@@ -246,14 +246,14 @@ void RenderableTrail::update(const UpdateData& data) {
 
         for (int i = nValues; i > 0; --i) {
             double et = _oldTime + i * _increment;
-			if (start > et)
-				et = start;
-			else if (end < et)
-				et = end;
+            if (start > et)
+                et = start;
+            else if (end < et)
+                et = end;
             glm::dvec3 p =
             SpiceManager::ref().targetPosition(_target, _observer, _frame, {}, et, lightTime);
             pscPos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
-			pscPos[3] += 3;
+            pscPos[3] += 3;
             _vertexArray[i] = { pscPos[0], pscPos[1], pscPos[2], pscPos[3] };
         }
 
@@ -281,12 +281,12 @@ void RenderableTrail::fullYearSweep(double time) {
     float planetYear = SecondsPerEarthYear * _ratio;
     int segments = static_cast<int>(_tropic);
 
-	bool intervalSet = hasTimeInterval();
-	double start = DBL_MIN;
-	double end = DBL_MAX;
-	if (intervalSet) {
-		intervalSet &= getInterval(start, end);
-	}
+    bool intervalSet = hasTimeInterval();
+    double start = DBL_MIN;
+    double end = DBL_MAX;
+    if (intervalSet) {
+        intervalSet &= getInterval(start, end);
+    }
 
     _increment = planetYear / _tropic;
     
@@ -296,12 +296,12 @@ void RenderableTrail::fullYearSweep(double time) {
     glm::dvec3 p;
     bool failed = false;
     for (int i = 0; i < segments+2; i++) {
-		if (start > time && intervalSet) {
-			time = start;
-		}
-		else if (end < time && intervalSet) {
-			time = end;
-		}
+        if (start > time && intervalSet) {
+            time = start;
+        }
+        else if (end < time && intervalSet) {
+            time = end;
+        }
 
         if (!failed || intervalSet) {
             try {
@@ -317,7 +317,7 @@ void RenderableTrail::fullYearSweep(double time) {
         }
         
         psc pscPos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
-		pscPos[3] += 3;
+        pscPos[3] += 3;
 
         _vertexArray[i] = {pscPos[0], pscPos[1], pscPos[2], pscPos[3]};
         time -= _increment;
diff --git a/modules/base/rendering/renderabletrail.h b/modules/base/rendering/renderabletrail.h
index 6760eee54a..8159acf1cf 100644
--- a/modules/base/rendering/renderabletrail.h
+++ b/modules/base/rendering/renderabletrail.h
@@ -63,7 +63,7 @@ private:
     properties::Vec3Property _lineColor;
     properties::FloatProperty _lineFade;
     properties::FloatProperty _lineWidth;
-	properties::BoolProperty _showTimestamps;
+    properties::BoolProperty _showTimestamps;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
 
@@ -86,7 +86,7 @@ private:
 
     float _increment;
     double _oldTime = 0.0;
-	float _distanceFade;
+    float _distanceFade;
 };
 
 } // namespace openspace
diff --git a/modules/base/rendering/simplespheregeometry.cpp b/modules/base/rendering/simplespheregeometry.cpp
index 43e5fde47e..c02d4e4b4d 100644
--- a/modules/base/rendering/simplespheregeometry.cpp
+++ b/modules/base/rendering/simplespheregeometry.cpp
@@ -43,45 +43,45 @@ namespace planetgeometry {
 
 SimpleSphereGeometry::SimpleSphereGeometry(const ghoul::Dictionary& dictionary)
     : PlanetGeometry()
-	, _realRadius("radius", "Radius", glm::vec4(1.f, 1.f, 1.f, 0.f), glm::vec4(-10.f, -10.f, -10.f, -20.f),
-				glm::vec4(10.f, 10.f, 10.f, 20.f))
+    , _realRadius("radius", "Radius", glm::vec4(1.f, 1.f, 1.f, 0.f), glm::vec4(-10.f, -10.f, -10.f, -20.f),
+                glm::vec4(10.f, 10.f, 10.f, 20.f))
     , _segments("segments", "Segments", 20, 1, 50)
     , _sphere(nullptr)
 {
-	using constants::simplespheregeometry::keyRadius;
-	using constants::simplespheregeometry::keySegments;
+    using constants::simplespheregeometry::keyRadius;
+    using constants::simplespheregeometry::keySegments;
 
-	// The name is passed down from the SceneGraphNode
+    // The name is passed down from the SceneGraphNode
     bool success = dictionary.getValue(SceneGraphNode::KeyName, _name);
-	assert(success);
-	
-	glm::vec4 radius;
-	success = dictionary.getValue(keyRadius, _modRadius);
-	if (!success) {
-		LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
+    assert(success);
+    
+    glm::vec4 radius;
+    success = dictionary.getValue(keyRadius, _modRadius);
+    if (!success) {
+        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                            << keyRadius << "'");
-	}
-	else {
-		radius[0] = _modRadius[0];
-		radius[1] = _modRadius[0];
-		radius[2] = _modRadius[0];
-		radius[3] = _modRadius[1];
-		_realRadius = radius; // In case the kernels does not supply a real
-	}
+    }
+    else {
+        radius[0] = _modRadius[0];
+        radius[1] = _modRadius[0];
+        radius[2] = _modRadius[0];
+        radius[3] = _modRadius[1];
+        _realRadius = radius; // In case the kernels does not supply a real
+    }
 
     double segments;
     success = dictionary.getValue(keySegments, segments);
-	if (!success) {
-		LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
+    if (!success) {
+        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                            << keySegments << "'");
-	}
-	else
-		_segments = static_cast<int>(segments);
+    }
+    else
+        _segments = static_cast<int>(segments);
 
-	// The shader need the radii values but they are not changeable runtime
-	// TODO: Possibly add a scaling property @AA
+    // The shader need the radii values but they are not changeable runtime
+    // TODO: Possibly add a scaling property @AA
     addProperty(_realRadius);
-	// Changing the radius/scaling should affect the shader but not the geometry? @AA
+    // Changing the radius/scaling should affect the shader but not the geometry? @AA
     //_radius.onChange(std::bind(&SimpleSphereGeometry::createSphere, this));
     addProperty(_segments);
     _segments.onChange(std::bind(&SimpleSphereGeometry::createSphere, this));
@@ -100,8 +100,8 @@ bool SimpleSphereGeometry::initialize(RenderablePlanet* parent)
 
 void SimpleSphereGeometry::deinitialize()
 {
-	if (_sphere)
-	    delete _sphere;
+    if (_sphere)
+        delete _sphere;
     _sphere = nullptr;
 }
 
@@ -118,8 +118,8 @@ void SimpleSphereGeometry::createSphere(){
 
     if(_sphere)
         delete _sphere;
-	//_sphere = new PowerScaledSphere(planetSize, _segments);
-	_sphere = new PowerScaledSphere(_realRadius, _segments, _name);
+    //_sphere = new PowerScaledSphere(planetSize, _segments);
+    _sphere = new PowerScaledSphere(_realRadius, _segments, _name);
     _sphere->initialize();
 }
 
diff --git a/modules/base/rendering/simplespheregeometry.h b/modules/base/rendering/simplespheregeometry.h
index fc506f00bf..acd61c0112 100644
--- a/modules/base/rendering/simplespheregeometry.h
+++ b/modules/base/rendering/simplespheregeometry.h
@@ -45,15 +45,15 @@ public:
     bool initialize(RenderablePlanet* parent) override;
     void deinitialize() override;
     void render() override;
-	PowerScaledSphere* _planet;
+    PowerScaledSphere* _planet;
 
 private:
     void createSphere();
 
-	glm::vec2 _modRadius;
-	properties::Vec4Property _realRadius;
+    glm::vec2 _modRadius;
+    properties::Vec4Property _realRadius;
     properties::IntProperty _segments;
-	std::string _name;
+    std::string _name;
 
     PowerScaledSphere* _sphere;
 };
diff --git a/modules/base/rendering/wavefrontgeometry.cpp b/modules/base/rendering/wavefrontgeometry.cpp
index 9c45458adf..8125e73dd2 100644
--- a/modules/base/rendering/wavefrontgeometry.cpp
+++ b/modules/base/rendering/wavefrontgeometry.cpp
@@ -37,21 +37,21 @@ namespace modelgeometry {
 WavefrontGeometry::WavefrontGeometry(const ghoul::Dictionary& dictionary)
     : ModelGeometry(dictionary) 
 {
-	loadObj(_file);
+    loadObj(_file);
 }
 
 bool WavefrontGeometry::initialize(Renderable* parent) {
-	bool success = ModelGeometry::initialize(parent);
+    bool success = ModelGeometry::initialize(parent);
     return success;
 }
 
 void WavefrontGeometry::deinitialize() {
-	ModelGeometry::deinitialize();
+    ModelGeometry::deinitialize();
 }
 
 bool WavefrontGeometry::loadModel(const std::string& filename) {
-	std::vector<tinyobj::shape_t> shapes;
-	std::vector<tinyobj::material_t> materials;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
     std::string err;
     bool success = tinyobj::LoadObj(shapes, materials, err, filename.c_str(), filename.c_str());
 
@@ -86,18 +86,18 @@ bool WavefrontGeometry::loadModel(const std::string& filename) {
     // The _shapeCounts array stores for each shape, how many vertices that shape has
     size_t currentPosition = 0;
     size_t p = 0;
-	psc tmp;
-	for (int i = 0; i < shapes.size(); ++i) {
-		for (int j = 0; j < shapes[i].mesh.positions.size() / 3; ++j) {
-			tmp = PowerScaledCoordinate::CreatePowerScaledCoordinate(shapes[i].mesh.positions[3 * j + 0],
-				shapes[i].mesh.positions[3 * j + 1],
-				shapes[i].mesh.positions[3 * j + 2]
-				);
+    psc tmp;
+    for (int i = 0; i < shapes.size(); ++i) {
+        for (int j = 0; j < shapes[i].mesh.positions.size() / 3; ++j) {
+            tmp = PowerScaledCoordinate::CreatePowerScaledCoordinate(shapes[i].mesh.positions[3 * j + 0],
+                shapes[i].mesh.positions[3 * j + 1],
+                shapes[i].mesh.positions[3 * j + 2]
+                );
 
-			_vertices[j + currentPosition].location[0] = tmp[0];
-			_vertices[j + currentPosition].location[1] = tmp[1];
-			_vertices[j + currentPosition].location[2] = tmp[2];
-			_vertices[j + currentPosition].location[3] = tmp[3];
+            _vertices[j + currentPosition].location[0] = tmp[0];
+            _vertices[j + currentPosition].location[1] = tmp[1];
+            _vertices[j + currentPosition].location[2] = tmp[2];
+            _vertices[j + currentPosition].location[3] = tmp[3];
 
             _vertices[j + currentPosition].normal[0] = shapes[i].mesh.normals[3 * j + 0];
             _vertices[j + currentPosition].normal[1] = shapes[i].mesh.normals[3 * j + 1];
@@ -107,7 +107,7 @@ bool WavefrontGeometry::loadModel(const std::string& filename) {
                 _vertices[j + currentPosition].tex[0] = shapes[i].mesh.texcoords[2 * j + 0];
                 _vertices[j + currentPosition].tex[1] = shapes[i].mesh.texcoords[2 * j + 1];
             }
-			
+            
         }
         currentPosition += shapes[i].mesh.positions.size() / 3;
 
@@ -119,7 +119,7 @@ bool WavefrontGeometry::loadModel(const std::string& filename) {
         p += shapes[i].mesh.indices.size();
     }
 
-	return true;
+    return true;
 }
 
 
diff --git a/modules/base/rendering/wavefrontgeometry.h b/modules/base/rendering/wavefrontgeometry.h
index bc26bcfb24..5bc949942f 100644
--- a/modules/base/rendering/wavefrontgeometry.h
+++ b/modules/base/rendering/wavefrontgeometry.h
@@ -34,16 +34,16 @@ class RenderableModelProjection;
 
 namespace modelgeometry {
 
-	class WavefrontGeometry : public ModelGeometry {
-	public:
-		WavefrontGeometry(const ghoul::Dictionary& dictionary);
+    class WavefrontGeometry : public ModelGeometry {
+    public:
+        WavefrontGeometry(const ghoul::Dictionary& dictionary);
 
-		bool initialize(Renderable* parent) override;
-		void deinitialize() override;
+        bool initialize(Renderable* parent) override;
+        void deinitialize() override;
 
-	private:
-		bool loadModel(const std::string& filename);
-	};
+    private:
+        bool loadModel(const std::string& filename);
+    };
 
 }  // namespace modelgeometry
 }  // namespace openspace
diff --git a/modules/base/shaders/constellationbounds_fs.glsl b/modules/base/shaders/constellationbounds_fs.glsl
index 59f2d4d22a..b970189e84 100644
--- a/modules/base/shaders/constellationbounds_fs.glsl
+++ b/modules/base/shaders/constellationbounds_fs.glsl
@@ -33,8 +33,8 @@ in vec4 vs_position;
 
 Fragment getFragment()
 {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
     Fragment frag;
 
     frag.color = vec4(1.0, 0.0, 0.0, 1.0);
diff --git a/modules/base/shaders/constellationbounds_vs.glsl b/modules/base/shaders/constellationbounds_vs.glsl
index 49faefa671..7c05a3c178 100644
--- a/modules/base/shaders/constellationbounds_vs.glsl
+++ b/modules/base/shaders/constellationbounds_vs.glsl
@@ -35,11 +35,11 @@ out vec4 vs_position;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vec4 tmp = vec4(in_position, exponent);
-	vs_position = tmp;
+    vec4 tmp = vec4(in_position, exponent);
+    vs_position = tmp;
 
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/ephemeris_vs.glsl b/modules/base/shaders/ephemeris_vs.glsl
index 0f18057acf..f1081b63d9 100644
--- a/modules/base/shaders/ephemeris_vs.glsl
+++ b/modules/base/shaders/ephemeris_vs.glsl
@@ -40,12 +40,12 @@ uniform float lineFade;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	float id = float(gl_VertexID) / float(nVertices * lineFade);
-	fade = 1.0 - id;
+    float id = float(gl_VertexID) / float(nVertices * lineFade);
+    fade = 1.0 - id;
 
-	vec4 tmp = in_point_position;
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_point_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vec4 tmp = in_point_position;
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_point_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/imageplane_fs.glsl b/modules/base/shaders/imageplane_fs.glsl
index 69544de87c..be0ec77fb6 100644
--- a/modules/base/shaders/imageplane_fs.glsl
+++ b/modules/base/shaders/imageplane_fs.glsl
@@ -33,14 +33,14 @@ in vec4 vs_position;
 
 Fragment getFragment()
 {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse;
-	if (gl_FrontFacing)
-		diffuse = texture(texture1, vs_st);
-	else {
-		diffuse = vec4(0.8);
-	}
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse;
+    if (gl_FrontFacing)
+        diffuse = texture(texture1, vs_st);
+    else {
+        diffuse = vec4(0.8);
+    }
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/base/shaders/imageplane_vs.glsl b/modules/base/shaders/imageplane_vs.glsl
index 911f770991..c13225412f 100644
--- a/modules/base/shaders/imageplane_vs.glsl
+++ b/modules/base/shaders/imageplane_vs.glsl
@@ -38,12 +38,12 @@ out float s;
 
 void main()
 {
-	vec4 tmp = in_position;
-	vec4 position = pscTransform(tmp, ModelTransform);
+    vec4 tmp = in_position;
+    vec4 position = pscTransform(tmp, ModelTransform);
 
-	vs_position = tmp;
-	vs_st = in_st;
-	
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vs_position = tmp;
+    vs_st = in_st;
+    
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/model_fs.glsl b/modules/base/shaders/model_fs.glsl
index f952a8d21a..710fbfa1f3 100644
--- a/modules/base/shaders/model_fs.glsl
+++ b/modules/base/shaders/model_fs.glsl
@@ -45,40 +45,40 @@ in vec4 vs_position;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	//depth = length(campos - position);
-	vec4 diffuse = texture(texture1, vs_st);
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    //depth = length(campos - position);
+    vec4 diffuse = texture(texture1, vs_st);
 
-	diffuse[3] = fading;
+    diffuse[3] = fading;
 
-	if (_performShading) {
-		vec4 spec = vec4(0.0);
-		
-		vec3 n = normalize(vs_normal.xyz);
-		vec3 l_pos = vec3(sun_pos); // sun.
-		vec3 l_dir = normalize(l_pos-objpos.xyz);
-		float intensity = min(max(1*dot(n,l_dir), 0.0), 1);
-	
-		float shine = 100;
-	
-		vec4 specular = vec4(1.0);
-		vec4 ambient =diffuse*0.4;
-		ambient[3] = transparency;
- 		if(intensity > 0.0f){
-			// halfway vector
-			vec3 h = normalize(l_dir + normalize(cam_dir));
-			// specular factor
-			float intSpec = max(dot(n,h),0.0);
-			spec = specular * pow(intSpec, shine);
-		}
-		diffuse = vec4(max(intensity * diffuse , ambient).xyz,1) +spec*1.5*diffuse ;
-	}
+    if (_performShading) {
+        vec4 spec = vec4(0.0);
+        
+        vec3 n = normalize(vs_normal.xyz);
+        vec3 l_pos = vec3(sun_pos); // sun.
+        vec3 l_dir = normalize(l_pos-objpos.xyz);
+        float intensity = min(max(1*dot(n,l_dir), 0.0), 1);
+    
+        float shine = 100;
+    
+        vec4 specular = vec4(1.0);
+        vec4 ambient =diffuse*0.4;
+        ambient[3] = transparency;
+         if(intensity > 0.0f){
+            // halfway vector
+            vec3 h = normalize(l_dir + normalize(cam_dir));
+            // specular factor
+            float intSpec = max(dot(n,h),0.0);
+            spec = specular * pow(intSpec, shine);
+        }
+        diffuse = vec4(max(intensity * diffuse , ambient).xyz,1) +spec*1.5*diffuse ;
+    }
 
-	diffuse[3] = fading*transparency;
+    diffuse[3] = fading*transparency;
 
-	Fragment frag;
-	frag.color = diffuse;
-	frag.depth = depth;
-	return frag;
+    Fragment frag;
+    frag.color = diffuse;
+    frag.depth = depth;
+    return frag;
 }
diff --git a/modules/base/shaders/model_vs.glsl b/modules/base/shaders/model_vs.glsl
index 8b7b035ed9..b01c4a69d7 100644
--- a/modules/base/shaders/model_vs.glsl
+++ b/modules/base/shaders/model_vs.glsl
@@ -42,20 +42,20 @@ out float s;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vec4 pos = in_position;
-	pos.w += _magnification;
+    vec4 pos = in_position;
+    pos.w += _magnification;
 
-	// set variables
-	vs_st = in_st;
-	//vs_stp = in_position.xyz;
-	vs_position = pos;
-	vec4 tmp = pos;
+    // set variables
+    vs_st = in_st;
+    //vs_stp = in_position.xyz;
+    vs_position = pos;
+    vec4 tmp = pos;
 
-	// this is wrong for the normal. The normal transform is the transposed inverse of the model transform
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    // this is wrong for the normal. The normal transform is the transposed inverse of the model transform
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/path_fs.glsl b/modules/base/shaders/path_fs.glsl
index 2f4dfb6d9f..727968a5e0 100644
--- a/modules/base/shaders/path_fs.glsl
+++ b/modules/base/shaders/path_fs.glsl
@@ -34,8 +34,8 @@ uniform vec3 color;
 Fragment getFragment() {
     vec4 position = vs_point_position;
     float depth = pscDepth(position);
-	
-	vec4 diffuse = vs_point_color;
+    
+    vec4 diffuse = vs_point_color;
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/base/shaders/path_gs.glsl b/modules/base/shaders/path_gs.glsl
index c47af01869..871001236f 100644
--- a/modules/base/shaders/path_gs.glsl
+++ b/modules/base/shaders/path_gs.glsl
@@ -58,11 +58,11 @@ uniform mat4 projection;
 
 void main() {
   
-	gs_point_color = vs_point_color[0];
-	gs_point_position = vs_point_position[0];
-	//gs_point_position = gl_in[0].gl_Position;
-	if (isHour[0] == 1) {
-	/*vec4 projPos[4];
+    gs_point_color = vs_point_color[0];
+    gs_point_position = vs_point_position[0];
+    //gs_point_position = gl_in[0].gl_Position;
+    if (isHour[0] == 1) {
+    /*vec4 projPos[4];
     for (int i = 0; i < 4; ++i) {
         vec4 p1     = gl_in[0].gl_Position;
         p1.xy      += vec2(99999999*(corners[i] - vec2(0.5))); 
@@ -82,26 +82,26 @@ void main() {
     //    return;
 
     for(int i = 0; i < 4; i++) {
-		gs_point_position = gl_in[0].gl_Position;
+        gs_point_position = gl_in[0].gl_Position;
         gl_Position = projPos[i];
        // billboardSize = sizeInPixels;
-		EmitVertex();
+        EmitVertex();
     }
 
-		
-	    for(int i = 0; i < 4; i++) {
+        
+        for(int i = 0; i < 4; i++) {
         gl_Position = gl_in[0].gl_Position;;
        // billboardSize = sizeInPixels;
       
-		}*/
-		gl_Position =  gl_in[0].gl_Position;
-		EmitVertex();
-		EndPrimitive();
-	}
-	else {
-		gl_Position =  gl_in[0].gl_Position;
-		EmitVertex();
-		EndPrimitive();
-	return;
-	}
+        }*/
+        gl_Position =  gl_in[0].gl_Position;
+        EmitVertex();
+        EndPrimitive();
+    }
+    else {
+        gl_Position =  gl_in[0].gl_Position;
+        EmitVertex();
+        EndPrimitive();
+    return;
+    }
 }
diff --git a/modules/base/shaders/plane_fs.glsl b/modules/base/shaders/plane_fs.glsl
index 1a90e669ac..778763430e 100644
--- a/modules/base/shaders/plane_fs.glsl
+++ b/modules/base/shaders/plane_fs.glsl
@@ -32,22 +32,22 @@ in vec4 vs_position;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse;
-	if(gl_FrontFacing)
-		diffuse = texture(texture1, vs_st);
-	else
-		diffuse = texture(texture1, vec2(1-vs_st.s,vs_st.t));
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse;
+    if(gl_FrontFacing)
+        diffuse = texture(texture1, vs_st);
+    else
+        diffuse = texture(texture1, vec2(1-vs_st.s,vs_st.t));
 
-	//vec4 diffuse = vec4(1,vs_st,1);
-	//vec4 diffuse = vec4(1,0,0,1);
-	// if(position.w > 9.0) {
-	// 	diffuse = vec4(1,0,0,1);
-	// }
+    //vec4 diffuse = vec4(1,vs_st,1);
+    //vec4 diffuse = vec4(1,0,0,1);
+    // if(position.w > 9.0) {
+    //     diffuse = vec4(1,0,0,1);
+    // }
 
-	if (diffuse.a == 0.0)
-		discard;
+    if (diffuse.a == 0.0)
+        discard;
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/base/shaders/plane_vs.glsl b/modules/base/shaders/plane_vs.glsl
index 911f770991..c13225412f 100644
--- a/modules/base/shaders/plane_vs.glsl
+++ b/modules/base/shaders/plane_vs.glsl
@@ -38,12 +38,12 @@ out float s;
 
 void main()
 {
-	vec4 tmp = in_position;
-	vec4 position = pscTransform(tmp, ModelTransform);
+    vec4 tmp = in_position;
+    vec4 position = pscTransform(tmp, ModelTransform);
 
-	vs_position = tmp;
-	vs_st = in_st;
-	
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vs_position = tmp;
+    vs_st = in_st;
+    
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/sphere_vs.glsl b/modules/base/shaders/sphere_vs.glsl
index 90ef6bb6d2..11c4f4c2db 100644
--- a/modules/base/shaders/sphere_vs.glsl
+++ b/modules/base/shaders/sphere_vs.glsl
@@ -38,20 +38,20 @@ out float s;
 
 void main()
 {
-	vec4 tmp = in_position;
+    vec4 tmp = in_position;
 
-	mat4 mt = ModelTransform;
+    mat4 mt = ModelTransform;
 
-	mt = mat4(0, -1, 0, 0,
-			  1, 0, 0, 0,
-			  0, 0, -1, 0,
-			  0, 0, 0, 1) * mt;
+    mt = mat4(0, -1, 0, 0,
+              1, 0, 0, 0,
+              0, 0, -1, 0,
+              0, 0, 0, 1) * mt;
 
-	vec4 position = pscTransform(tmp, mt);
+    vec4 position = pscTransform(tmp, mt);
 
-	vs_position = in_position;
-	vs_st = in_st;
-	
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vs_position = in_position;
+    vs_st = in_st;
+    
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/base/shaders/star_vs.glsl b/modules/base/shaders/star_vs.glsl
index fe621fd1d1..c0ff07a8a9 100644
--- a/modules/base/shaders/star_vs.glsl
+++ b/modules/base/shaders/star_vs.glsl
@@ -43,18 +43,18 @@ out vec4 cam_position;
 
 void main() { 
     vec4 p = in_position;
-	psc_position  = p;
-	vs_brightness = in_brightness;
-	vs_velocity = in_velocity;
-	vs_speed = in_speed;
-	cam_position  = campos;
+    psc_position  = p;
+    vs_brightness = in_brightness;
+    vs_velocity = in_velocity;
+    vs_speed = in_speed;
+    cam_position  = campos;
 
-	vec4 tmp = p;
-	vec4 position = pscTransform(tmp, mat4(1.0));
-	// vec4 position = pscTransform(tmp, model);
-	// psc_position = tmp;
-	position = view * position;
-	// position = ViewProjection * ModelTransform * position;
-	// gl_Position =  z_normalization(position);
-	gl_Position = position;
+    vec4 tmp = p;
+    vec4 position = pscTransform(tmp, mat4(1.0));
+    // vec4 position = pscTransform(tmp, model);
+    // psc_position = tmp;
+    position = view * position;
+    // position = ViewProjection * ModelTransform * position;
+    // gl_Position =  z_normalization(position);
+    gl_Position = position;
 }
\ No newline at end of file
diff --git a/modules/fieldlines/rendering/renderablefieldlines.cpp b/modules/fieldlines/rendering/renderablefieldlines.cpp
index b59e0875f9..05ff35c7d7 100644
--- a/modules/fieldlines/rendering/renderablefieldlines.cpp
+++ b/modules/fieldlines/rendering/renderablefieldlines.cpp
@@ -35,392 +35,392 @@
 #include <fstream>
 
 namespace {
-	std::string _loggerCat = "RenderableFieldlines";
+    std::string _loggerCat = "RenderableFieldlines";
 
-	const float defaultFieldlineStepSize = 0.5f;;
-	const glm::vec4 defaultFieldlineColor = glm::vec4(1.f, 0.f, 0.f, 1.f);
+    const float defaultFieldlineStepSize = 0.5f;;
+    const glm::vec4 defaultFieldlineColor = glm::vec4(1.f, 0.f, 0.f, 1.f);
 
-	const std::string keyVectorField = "VectorField";
-	const std::string keyVectorFieldType = "Type";
-	const std::string keyVectorFieldFile = "File";
-	const std::string keyVectorFieldVolumeModel = "Model";
-	const std::string keyVectorFieldVolumeVariable = "Variables";
+    const std::string keyVectorField = "VectorField";
+    const std::string keyVectorFieldType = "Type";
+    const std::string keyVectorFieldFile = "File";
+    const std::string keyVectorFieldVolumeModel = "Model";
+    const std::string keyVectorFieldVolumeVariable = "Variables";
 
-	const std::string keyFieldlines = "Fieldlines";
-	const std::string keyFieldlinesStepSize = "Stepsize";
-	const std::string keyFieldlinesClassification = "Classification";
-	const std::string keyFieldlinesColor = "Color";
+    const std::string keyFieldlines = "Fieldlines";
+    const std::string keyFieldlinesStepSize = "Stepsize";
+    const std::string keyFieldlinesClassification = "Classification";
+    const std::string keyFieldlinesColor = "Color";
 
-	const std::string keySeedPoints = "SeedPoints";
-	const std::string keySeedPointsType = "Type";
-	const std::string keySeedPointsFile = "File";
-	const std::string keySeedPointsTable = "SeedPoints";
+    const std::string keySeedPoints = "SeedPoints";
+    const std::string keySeedPointsType = "Type";
+    const std::string keySeedPointsFile = "File";
+    const std::string keySeedPointsTable = "SeedPoints";
 
-	const std::string seedPointsSourceFile = "File";
-	const std::string seedPointsSourceTable = "Table";
+    const std::string seedPointsSourceFile = "File";
+    const std::string seedPointsSourceTable = "Table";
 
-	const std::string vectorFieldTypeVolumeKameleon = "VolumeKameleon";
+    const std::string vectorFieldTypeVolumeKameleon = "VolumeKameleon";
 
-	const std::string vectorFieldKameleonModelBATSRUS = "BATSRUS";
+    const std::string vectorFieldKameleonModelBATSRUS = "BATSRUS";
 
-	const std::string vectorFieldKameleonVariableLorentz = "Lorentz";
+    const std::string vectorFieldKameleonVariableLorentz = "Lorentz";
 
-	const int SeedPointSourceFile = 0;
-	const int SeedPointSourceTable = 1;
+    const int SeedPointSourceFile = 0;
+    const int SeedPointSourceTable = 1;
 }
 
 namespace openspace {
 
 RenderableFieldlines::RenderableFieldlines(const ghoul::Dictionary& dictionary) 
-	: Renderable(dictionary)
-	, _stepSize("stepSize", "Fieldline Step Size", defaultFieldlineStepSize, 0.f, 10.f)
-	, _classification("classification", "Fieldline Classification", true)
-	, _fieldlineColor(
-		"fieldlineColor",
-		"Fieldline Color",
-		defaultFieldlineColor,
-		glm::vec4(0.f),
-		glm::vec4(1.f)
-	  )
-	, _seedPointSource("source", "SeedPoint Source")
-	, _seedPointSourceFile("sourceFile", "SeedPoint File")
+    : Renderable(dictionary)
+    , _stepSize("stepSize", "Fieldline Step Size", defaultFieldlineStepSize, 0.f, 10.f)
+    , _classification("classification", "Fieldline Classification", true)
+    , _fieldlineColor(
+        "fieldlineColor",
+        "Fieldline Color",
+        defaultFieldlineColor,
+        glm::vec4(0.f),
+        glm::vec4(1.f)
+      )
+    , _seedPointSource("source", "SeedPoint Source")
+    , _seedPointSourceFile("sourceFile", "SeedPoint File")
     , _program(nullptr)
-	, _seedPointsAreDirty(true)
-	, _fieldLinesAreDirty(true)
+    , _seedPointsAreDirty(true)
+    , _fieldLinesAreDirty(true)
     , _fieldlineVAO(0)
     , _vertexPositionBuffer(0)
 {
-	ghoul_assert(
-		dictionary.hasKeyAndValue<std::string>(SceneGraphNode::KeyName),
-		"Renderable does not have a name"
-	);
+    ghoul_assert(
+        dictionary.hasKeyAndValue<std::string>(SceneGraphNode::KeyName),
+        "Renderable does not have a name"
+    );
 
-	std::string name;
-	dictionary.getValue(SceneGraphNode::KeyName, name);
+    std::string name;
+    dictionary.getValue(SceneGraphNode::KeyName, name);
 
-	_loggerCat = "RenderableFieldlines [" + name + "]";
+    _loggerCat = "RenderableFieldlines [" + name + "]";
 
-	bool success = dictionary.getValue(keyVectorField, _vectorFieldInfo);
-	if (!success) {
-		LERROR("Renderable does not contain a key for '" <<
-			keyVectorField << "'");
-	}
+    bool success = dictionary.getValue(keyVectorField, _vectorFieldInfo);
+    if (!success) {
+        LERROR("Renderable does not contain a key for '" <<
+            keyVectorField << "'");
+    }
 
-	success = dictionary.getValue(keyFieldlines, _fieldlineInfo);
-	if (!success) {
-		LERROR("Renderable does not contain a key for '" <<
-			keyFieldlines << "'");
-	}
+    success = dictionary.getValue(keyFieldlines, _fieldlineInfo);
+    if (!success) {
+        LERROR("Renderable does not contain a key for '" <<
+            keyFieldlines << "'");
+    }
 
-	success = dictionary.getValue(keySeedPoints, _seedPointsInfo);
-	if (!success) {
-		LERROR("Renderable does not contain a key for '" <<
-			keySeedPoints << "'");
-	}
+    success = dictionary.getValue(keySeedPoints, _seedPointsInfo);
+    if (!success) {
+        LERROR("Renderable does not contain a key for '" <<
+            keySeedPoints << "'");
+    }
 
-	// @TODO a non-magic number perhaps ---abock
-	setBoundingSphere(PowerScaledScalar::CreatePSS(250.f*6371000.f));
+    // @TODO a non-magic number perhaps ---abock
+    setBoundingSphere(PowerScaledScalar::CreatePSS(250.f*6371000.f));
 
-	_seedPointSource.addOption(SeedPointSourceFile, "File");
-	_seedPointSource.addOption(SeedPointSourceTable, "Lua Table");
+    _seedPointSource.addOption(SeedPointSourceFile, "File");
+    _seedPointSource.addOption(SeedPointSourceTable, "Lua Table");
 
-	initializeDefaultPropertyValues();
+    initializeDefaultPropertyValues();
 
-	// @TODO hook up visibility changes ---abock
+    // @TODO hook up visibility changes ---abock
 
-	auto dirtyFieldlines = [this]() { this->_fieldLinesAreDirty = true; };
-	auto dirtySeedpoints = [this]() { this->_seedPointsAreDirty = true; };
+    auto dirtyFieldlines = [this]() { this->_fieldLinesAreDirty = true; };
+    auto dirtySeedpoints = [this]() { this->_seedPointsAreDirty = true; };
 
-	_stepSize.onChange(dirtyFieldlines);
-	addProperty(_stepSize);
+    _stepSize.onChange(dirtyFieldlines);
+    addProperty(_stepSize);
 
-	addProperty(_classification);
+    addProperty(_classification);
 
-	_fieldlineColor.setViewOption(properties::Property::ViewOptions::Color);
-	addProperty(_fieldlineColor);
+    _fieldlineColor.setViewOption(properties::Property::ViewOptions::Color);
+    addProperty(_fieldlineColor);
 
-	_seedPointSource.onChange(dirtySeedpoints);
-	addProperty(_seedPointSource);
+    _seedPointSource.onChange(dirtySeedpoints);
+    addProperty(_seedPointSource);
 
-	_seedPointSourceFile.onChange(dirtySeedpoints);
-	addProperty(_seedPointSourceFile);
+    _seedPointSourceFile.onChange(dirtySeedpoints);
+    addProperty(_seedPointSourceFile);
 }
 
 void RenderableFieldlines::initializeDefaultPropertyValues() {
-	bool success;
-	
-	// Step size
-	float stepSize;
-	success = _fieldlineInfo.getValue(keyFieldlinesStepSize, stepSize);
-	if (success)
-		_stepSize = stepSize;
+    bool success;
+    
+    // Step size
+    float stepSize;
+    success = _fieldlineInfo.getValue(keyFieldlinesStepSize, stepSize);
+    if (success)
+        _stepSize = stepSize;
 
-	// Classification
-	bool classification;
-	success = _fieldlineInfo.getValue(keyFieldlinesClassification, classification);
-	if (success)
-		_classification = classification;
+    // Classification
+    bool classification;
+    success = _fieldlineInfo.getValue(keyFieldlinesClassification, classification);
+    if (success)
+        _classification = classification;
 
-	// Fieldline Color
-	glm::vec4 color;
-	success = _fieldlineInfo.getValue(keyFieldlinesColor, color);
-	if (success)
-		_fieldlineColor = color;
+    // Fieldline Color
+    glm::vec4 color;
+    success = _fieldlineInfo.getValue(keyFieldlinesColor, color);
+    if (success)
+        _fieldlineColor = color;
 
-	// Seedpoints Type
-	std::string sourceType;
-	success = _seedPointsInfo.getValue(keySeedPointsType, sourceType);
-	if (success) {
-		if (sourceType == seedPointsSourceFile) {
-			_seedPointSource = SeedPointSourceFile;
+    // Seedpoints Type
+    std::string sourceType;
+    success = _seedPointsInfo.getValue(keySeedPointsType, sourceType);
+    if (success) {
+        if (sourceType == seedPointsSourceFile) {
+            _seedPointSource = SeedPointSourceFile;
 
-			std::string seedPointSourceFile;
-			success = _seedPointsInfo.getValue(keySeedPointsFile, seedPointSourceFile);
-			if (success)
-				_seedPointSourceFile = absPath(seedPointSourceFile);
-		}
-		else if (sourceType == seedPointsSourceTable)
-			_seedPointSource = SeedPointSourceTable;
-	}
+            std::string seedPointSourceFile;
+            success = _seedPointsInfo.getValue(keySeedPointsFile, seedPointSourceFile);
+            if (success)
+                _seedPointSourceFile = absPath(seedPointSourceFile);
+        }
+        else if (sourceType == seedPointsSourceTable)
+            _seedPointSource = SeedPointSourceTable;
+    }
 }
 
 bool RenderableFieldlines::isReady() const {
-	bool programReady = _program != nullptr;
-	bool vectorFieldReady = !_vectorFieldInfo.empty();
-	bool fieldlineReady = !_fieldlineInfo.empty();
-	bool seedPointsReady = !_seedPointsInfo.empty();
-	return programReady && vectorFieldReady && fieldlineReady && seedPointsReady;
+    bool programReady = _program != nullptr;
+    bool vectorFieldReady = !_vectorFieldInfo.empty();
+    bool fieldlineReady = !_fieldlineInfo.empty();
+    bool seedPointsReady = !_seedPointsInfo.empty();
+    return programReady && vectorFieldReady && fieldlineReady && seedPointsReady;
 }
 
 bool RenderableFieldlines::initialize() {
-	if (_vectorFieldInfo.empty() ||
-		_fieldlineInfo.empty() ||
-		_seedPointsInfo.empty())
-	{
-		return false;
-	}
+    if (_vectorFieldInfo.empty() ||
+        _fieldlineInfo.empty() ||
+        _seedPointsInfo.empty())
+    {
+        return false;
+    }
 
-	_program = ghoul::opengl::ProgramObject::Build(
-		"Fieldline",
+    _program = ghoul::opengl::ProgramObject::Build(
+        "Fieldline",
         "${MODULE_FIELDLINES}/shaders/fieldline_vs.glsl",
         "${MODULE_FIELDLINES}/shaders/fieldline_fs.glsl",
         "${MODULE_FIELDLINES}/shaders/fieldline_gs.glsl"
-	);
-	if (!_program)
-		return false;
+    );
+    if (!_program)
+        return false;
 
-	return true;
+    return true;
 }
 
 bool RenderableFieldlines::deinitialize() {
-	glDeleteVertexArrays(1, &_fieldlineVAO);
-	_fieldlineVAO = 0;
-	glDeleteBuffers(1, &_vertexPositionBuffer);
-	_vertexPositionBuffer = 0;
-	return true;
+    glDeleteVertexArrays(1, &_fieldlineVAO);
+    _fieldlineVAO = 0;
+    glDeleteBuffers(1, &_vertexPositionBuffer);
+    _vertexPositionBuffer = 0;
+    return true;
 }
 
 void RenderableFieldlines::render(const RenderData& data) {
-	_program->activate();
-	_program->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
-	_program->setUniform("modelTransform", glm::mat4(1.0));
-	_program->setUniform("cameraViewDir", data.camera.viewDirection());
+    _program->activate();
+    _program->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
+    _program->setUniform("modelTransform", glm::mat4(1.0));
+    _program->setUniform("cameraViewDir", data.camera.viewDirection());
 
-	setPscUniforms(*_program, data.camera, data.position);
+    setPscUniforms(*_program, data.camera, data.position);
 
-	_program->setUniform("classification", _classification);
-	if (!_classification)
-		_program->setUniform("fieldLineColor", _fieldlineColor);
+    _program->setUniform("classification", _classification);
+    if (!_classification)
+        _program->setUniform("fieldLineColor", _fieldlineColor);
 
-	glBindVertexArray(_fieldlineVAO);
-	glMultiDrawArrays(
-		GL_LINE_STRIP_ADJACENCY,
-		&_lineStart[0],
-		&_lineCount[0],
-		static_cast<GLsizei>(_lineStart.size())
-	);
-	glBindVertexArray(0);
+    glBindVertexArray(_fieldlineVAO);
+    glMultiDrawArrays(
+        GL_LINE_STRIP_ADJACENCY,
+        &_lineStart[0],
+        &_lineCount[0],
+        static_cast<GLsizei>(_lineStart.size())
+    );
+    glBindVertexArray(0);
 
-	_program->deactivate();
+    _program->deactivate();
 }
 
 void RenderableFieldlines::update(const UpdateData&) {
-	if (_program->isDirty())
-		_program->rebuildFromFile();
+    if (_program->isDirty())
+        _program->rebuildFromFile();
 
-	if (_seedPointsAreDirty) {
-		loadSeedPoints();
-		_seedPointsAreDirty = false;
-		_fieldLinesAreDirty = true;
-	}
+    if (_seedPointsAreDirty) {
+        loadSeedPoints();
+        _seedPointsAreDirty = false;
+        _fieldLinesAreDirty = true;
+    }
 
-	if (_fieldLinesAreDirty) {
-		std::vector<Line> fieldlines = generateFieldlines();
+    if (_fieldLinesAreDirty) {
+        std::vector<Line> fieldlines = generateFieldlines();
 
-		if (fieldlines.empty())
-			return ;
+        if (fieldlines.empty())
+            return ;
 
-		int prevEnd = 0;
-		std::vector<LinePoint> vertexData;
-		// Arrange data for glMultiDrawArrays
-		for (int j = 0; j < fieldlines.size(); ++j) {
-			_lineStart.push_back(prevEnd);
-			_lineCount.push_back(static_cast<int>(fieldlines[j].size()));
-			prevEnd = prevEnd + static_cast<int>(fieldlines[j].size());
-			vertexData.insert(vertexData.end(), fieldlines[j].begin(), fieldlines[j].end());
-		}
-		LDEBUG("Number of vertices : " << vertexData.size());
+        int prevEnd = 0;
+        std::vector<LinePoint> vertexData;
+        // Arrange data for glMultiDrawArrays
+        for (int j = 0; j < fieldlines.size(); ++j) {
+            _lineStart.push_back(prevEnd);
+            _lineCount.push_back(static_cast<int>(fieldlines[j].size()));
+            prevEnd = prevEnd + static_cast<int>(fieldlines[j].size());
+            vertexData.insert(vertexData.end(), fieldlines[j].begin(), fieldlines[j].end());
+        }
+        LDEBUG("Number of vertices : " << vertexData.size());
 
-		if (_fieldlineVAO == 0)
-			glGenVertexArrays(1, &_fieldlineVAO);
-		glBindVertexArray(_fieldlineVAO);
+        if (_fieldlineVAO == 0)
+            glGenVertexArrays(1, &_fieldlineVAO);
+        glBindVertexArray(_fieldlineVAO);
 
-		if (_vertexPositionBuffer == 0)
-			glGenBuffers(1, &_vertexPositionBuffer);
-		glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer);
+        if (_vertexPositionBuffer == 0)
+            glGenBuffers(1, &_vertexPositionBuffer);
+        glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer);
 
-		glBufferData(GL_ARRAY_BUFFER, vertexData.size()*sizeof(LinePoint), &vertexData.front(), GL_STATIC_DRAW);
+        glBufferData(GL_ARRAY_BUFFER, vertexData.size()*sizeof(LinePoint), &vertexData.front(), GL_STATIC_DRAW);
 
-		GLuint vertexLocation = 0;
-		glEnableVertexAttribArray(vertexLocation);
-		glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(LinePoint), reinterpret_cast<void*>(0));
+        GLuint vertexLocation = 0;
+        glEnableVertexAttribArray(vertexLocation);
+        glVertexAttribPointer(vertexLocation, 3, GL_FLOAT, GL_FALSE, sizeof(LinePoint), reinterpret_cast<void*>(0));
 
-		GLuint colorLocation = 1;
-		glEnableVertexAttribArray(colorLocation);
-		glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, sizeof(LinePoint), (void*)(sizeof(glm::vec3)));
+        GLuint colorLocation = 1;
+        glEnableVertexAttribArray(colorLocation);
+        glVertexAttribPointer(colorLocation, 4, GL_FLOAT, GL_FALSE, sizeof(LinePoint), (void*)(sizeof(glm::vec3)));
 
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-		glBindVertexArray(0);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(0);
 
-		_fieldLinesAreDirty = false;
-	}
+        _fieldLinesAreDirty = false;
+    }
 }
 
 void RenderableFieldlines::loadSeedPoints() {
-	_seedPoints.clear();
-	switch (_seedPointSource.value()) {
-		case SeedPointSourceFile:
-			loadSeedPointsFromFile();
-			break;
-		case SeedPointSourceTable:
-			loadSeedPointsFromTable();
-			break;
-		default:
-			ghoul_assert(false, "Missing case label");
-	}
+    _seedPoints.clear();
+    switch (_seedPointSource.value()) {
+        case SeedPointSourceFile:
+            loadSeedPointsFromFile();
+            break;
+        case SeedPointSourceTable:
+            loadSeedPointsFromTable();
+            break;
+        default:
+            ghoul_assert(false, "Missing case label");
+    }
 }
 
 void RenderableFieldlines::loadSeedPointsFromFile() {
-	LINFO("Reading seed points from file '" << _seedPointSourceFile.value() << "'");
+    LINFO("Reading seed points from file '" << _seedPointSourceFile.value() << "'");
 
-	std::ifstream seedFile(_seedPointSourceFile);
-	if (!seedFile.good())
-		LERROR("Could not open seed points file '" << _seedPointSourceFile.value() << "'");
-	else {
-		std::string line;
-		glm::vec3 point;
-		while (std::getline(seedFile, line)) {
-			std::stringstream s(line);
-			s >> point.x;
-			s >> point.y;
-			s >> point.z;
-			_seedPoints.push_back(std::move(point));
-		}
-	}
+    std::ifstream seedFile(_seedPointSourceFile);
+    if (!seedFile.good())
+        LERROR("Could not open seed points file '" << _seedPointSourceFile.value() << "'");
+    else {
+        std::string line;
+        glm::vec3 point;
+        while (std::getline(seedFile, line)) {
+            std::stringstream s(line);
+            s >> point.x;
+            s >> point.y;
+            s >> point.z;
+            _seedPoints.push_back(std::move(point));
+        }
+    }
 }
 
 void RenderableFieldlines::loadSeedPointsFromTable() {
-	// @TODO needs testing ---abock
-	LINFO("Loading provided list of seed points");
-	ghoul::Dictionary seedpointsDictionary;
-	_seedPointsInfo.getValue(keySeedPointsTable, seedpointsDictionary);
-	glm::vec3 seedPos;
-	for (const std::string& index : seedpointsDictionary.keys()) {
-		_fieldlineInfo.getValue(keySeedPointsTable + "." + index, seedPos);
-		_seedPoints.push_back(seedPos);
-	}
+    // @TODO needs testing ---abock
+    LINFO("Loading provided list of seed points");
+    ghoul::Dictionary seedpointsDictionary;
+    _seedPointsInfo.getValue(keySeedPointsTable, seedpointsDictionary);
+    glm::vec3 seedPos;
+    for (const std::string& index : seedpointsDictionary.keys()) {
+        _fieldlineInfo.getValue(keySeedPointsTable + "." + index, seedPos);
+        _seedPoints.push_back(seedPos);
+    }
 }
 
 std::vector<RenderableFieldlines::Line> RenderableFieldlines::generateFieldlines() {
-	std::string type;
-	bool success = _vectorFieldInfo.getValue(keyVectorFieldType, type);
-	if (!success) {
-		LERROR(keyVectorField << " does not contain a '" <<
-			keyVectorFieldType << "' key");
-		return {};
-	}
+    std::string type;
+    bool success = _vectorFieldInfo.getValue(keyVectorFieldType, type);
+    if (!success) {
+        LERROR(keyVectorField << " does not contain a '" <<
+            keyVectorFieldType << "' key");
+        return {};
+    }
 
-	if (type == vectorFieldTypeVolumeKameleon)
-		return generateFieldlinesVolumeKameleon();
-	else {
-		LERROR(keyVectorField << "." << keyVectorFieldType <<
-			" does not name a valid type");
-		return {};
-	}
+    if (type == vectorFieldTypeVolumeKameleon)
+        return generateFieldlinesVolumeKameleon();
+    else {
+        LERROR(keyVectorField << "." << keyVectorFieldType <<
+            " does not name a valid type");
+        return {};
+    }
 }
 
 std::vector<RenderableFieldlines::Line>
 RenderableFieldlines::generateFieldlinesVolumeKameleon()
 {
-	std::string model;
-	bool success = _vectorFieldInfo.getValue(keyVectorFieldVolumeModel, model);
-	if (!success) {
-		LERROR(keyVectorField << " does not name a model");
-		return {};
-	}
+    std::string model;
+    bool success = _vectorFieldInfo.getValue(keyVectorFieldVolumeModel, model);
+    if (!success) {
+        LERROR(keyVectorField << " does not name a model");
+        return {};
+    }
 
-	std::string fileName;
-	success = _vectorFieldInfo.getValue(keyVectorFieldFile, fileName);
-	if (!success) {
-		LERROR(keyVectorField << " does not name a file");
-		return {};
-	}
-	fileName = absPath(fileName);
+    std::string fileName;
+    success = _vectorFieldInfo.getValue(keyVectorFieldFile, fileName);
+    if (!success) {
+        LERROR(keyVectorField << " does not name a file");
+        return {};
+    }
+    fileName = absPath(fileName);
 
-	//KameleonWrapper::Model modelType;
-	if (model != vectorFieldKameleonModelBATSRUS) {
+    //KameleonWrapper::Model modelType;
+    if (model != vectorFieldKameleonModelBATSRUS) {
         //modelType = KameleonWrapper::Model::BATSRUS;
-	//else {
-		LERROR(keyVectorField << "." << keyVectorFieldVolumeModel << " model '" << 
-			model << "' not supported");
-		return {};
-	}
+    //else {
+        LERROR(keyVectorField << "." << keyVectorFieldVolumeModel << " model '" << 
+            model << "' not supported");
+        return {};
+    }
 
-	std::string v1 = keyVectorFieldVolumeVariable + ".1";
-	std::string v2 = keyVectorFieldVolumeVariable + ".2";
-	std::string v3 = keyVectorFieldVolumeVariable + ".3";
+    std::string v1 = keyVectorFieldVolumeVariable + ".1";
+    std::string v2 = keyVectorFieldVolumeVariable + ".2";
+    std::string v3 = keyVectorFieldVolumeVariable + ".3";
 
-	bool threeVariables =
-		_vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
-		_vectorFieldInfo.hasKeyAndValue<std::string>(v2) &&
-		_vectorFieldInfo.hasKeyAndValue<std::string>(v3);
+    bool threeVariables =
+        _vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
+        _vectorFieldInfo.hasKeyAndValue<std::string>(v2) &&
+        _vectorFieldInfo.hasKeyAndValue<std::string>(v3);
 
-	bool lorentzForce =
-	  _vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
-	  (_vectorFieldInfo.value<std::string>(v1) == vectorFieldKameleonVariableLorentz);
+    bool lorentzForce =
+      _vectorFieldInfo.hasKeyAndValue<std::string>(v1) &&
+      (_vectorFieldInfo.value<std::string>(v1) == vectorFieldKameleonVariableLorentz);
 
-	if (!threeVariables && !lorentzForce) {
-		LERROR(keyVectorField << " does not name variables");
-		return {};
-	}
+    if (!threeVariables && !lorentzForce) {
+        LERROR(keyVectorField << " does not name variables");
+        return {};
+    }
 
-	if (threeVariables) {
-		std::string xVariable, yVariable, zVariable;
-		_vectorFieldInfo.getValue(v1, xVariable);
-		_vectorFieldInfo.getValue(v2, yVariable);
-		_vectorFieldInfo.getValue(v3, zVariable);
+    if (threeVariables) {
+        std::string xVariable, yVariable, zVariable;
+        _vectorFieldInfo.getValue(v1, xVariable);
+        _vectorFieldInfo.getValue(v2, yVariable);
+        _vectorFieldInfo.getValue(v3, zVariable);
 
-		KameleonWrapper kw(fileName);
-		return kw.getClassifiedFieldLines(xVariable, yVariable, zVariable, _seedPoints, _stepSize);
-	}
-	
-	if (lorentzForce) {
-		KameleonWrapper kw(fileName);
-		return kw.getLorentzTrajectories(_seedPoints, _fieldlineColor, _stepSize);
-	}
-	
-	ghoul_assert(false, "Should not reach this");
-	return {};
+        KameleonWrapper kw(fileName);
+        return kw.getClassifiedFieldLines(xVariable, yVariable, zVariable, _seedPoints, _stepSize);
+    }
+    
+    if (lorentzForce) {
+        KameleonWrapper kw(fileName);
+        return kw.getLorentzTrajectories(_seedPoints, _fieldlineColor, _stepSize);
+    }
+    
+    ghoul_assert(false, "Should not reach this");
+    return {};
 }
 
 } // namespace openspace
diff --git a/modules/fieldlines/rendering/renderablefieldlines.h b/modules/fieldlines/rendering/renderablefieldlines.h
index f78df3d647..14b9162a07 100644
--- a/modules/fieldlines/rendering/renderablefieldlines.h
+++ b/modules/fieldlines/rendering/renderablefieldlines.h
@@ -37,60 +37,60 @@
 
 namespace ghoul {
 namespace opengl {
-	class ProgramObject;
+    class ProgramObject;
 }
 }
 
 namespace openspace {
-	struct LinePoint;
+    struct LinePoint;
 
 class RenderableFieldlines : public Renderable {
 public:
-	RenderableFieldlines(const ghoul::Dictionary& dictionary);
+    RenderableFieldlines(const ghoul::Dictionary& dictionary);
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
-	typedef std::vector<LinePoint> Line;
+    typedef std::vector<LinePoint> Line;
 
-	void initializeDefaultPropertyValues();
-	//std::vector<std::vector<LinePoint> > getFieldlinesData(std::string filename, ghoul::Dictionary hintsDictionary);
-	std::vector<Line> getFieldlinesData();
-	void loadSeedPoints();
-	void loadSeedPointsFromFile();
-	void loadSeedPointsFromTable();
+    void initializeDefaultPropertyValues();
+    //std::vector<std::vector<LinePoint> > getFieldlinesData(std::string filename, ghoul::Dictionary hintsDictionary);
+    std::vector<Line> getFieldlinesData();
+    void loadSeedPoints();
+    void loadSeedPointsFromFile();
+    void loadSeedPointsFromTable();
 
-	std::vector<Line> generateFieldlines();
-	std::vector<Line> generateFieldlinesVolumeKameleon();
+    std::vector<Line> generateFieldlines();
+    std::vector<Line> generateFieldlinesVolumeKameleon();
 
-	properties::FloatProperty _stepSize;
-	properties::BoolProperty _classification;
-	properties::Vec4Property _fieldlineColor;
-	properties::OptionProperty _seedPointSource;
-	properties::StringProperty _seedPointSourceFile;
+    properties::FloatProperty _stepSize;
+    properties::BoolProperty _classification;
+    properties::Vec4Property _fieldlineColor;
+    properties::OptionProperty _seedPointSource;
+    properties::StringProperty _seedPointSourceFile;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
-	ghoul::Dictionary _vectorFieldInfo;
-	ghoul::Dictionary _fieldlineInfo;
-	ghoul::Dictionary _seedPointsInfo;
+    ghoul::Dictionary _vectorFieldInfo;
+    ghoul::Dictionary _fieldlineInfo;
+    ghoul::Dictionary _seedPointsInfo;
 
-	bool _seedPointsAreDirty;
-	bool _fieldLinesAreDirty;
+    bool _seedPointsAreDirty;
+    bool _fieldLinesAreDirty;
 
-	std::vector<glm::vec3> _seedPoints;
+    std::vector<glm::vec3> _seedPoints;
 
-	GLuint _fieldlineVAO;
-	GLuint _vertexPositionBuffer;
+    GLuint _fieldlineVAO;
+    GLuint _vertexPositionBuffer;
 
-	std::vector<GLint> _lineStart;
-	std::vector<GLsizei> _lineCount;
+    std::vector<GLint> _lineStart;
+    std::vector<GLsizei> _lineCount;
 };
 
 } // namespace openspace
diff --git a/modules/fieldlines/shaders/fieldline_fs.glsl b/modules/fieldlines/shaders/fieldline_fs.glsl
index 3a20ac1524..7f8e218738 100644
--- a/modules/fieldlines/shaders/fieldline_fs.glsl
+++ b/modules/fieldlines/shaders/fieldline_fs.glsl
@@ -36,14 +36,14 @@ uniform vec4 fieldLineColor;
 #include "PowerScaling/powerScaling_fs.hglsl"
 
 void main() {
-	float alpha = 1-length(gs_normal)*length(gs_normal);
-	vec4 fragColor;
-	if (classification)
-		fragColor = vec4(gs_color.rgb, alpha);
-	else
-		fragColor = vec4(fieldLineColor.rgb, fieldLineColor.a * alpha);
+    float alpha = 1-length(gs_normal)*length(gs_normal);
+    vec4 fragColor;
+    if (classification)
+        fragColor = vec4(gs_color.rgb, alpha);
+    else
+        fragColor = vec4(fieldLineColor.rgb, fieldLineColor.a * alpha);
 
-	float depth = pscDepth(gs_position);
-	ABufferStruct_t frag = createGeometryFragment(fragColor, gs_position, depth);
-	addToBuffer(frag);
+    float depth = pscDepth(gs_position);
+    ABufferStruct_t frag = createGeometryFragment(fragColor, gs_position, depth);
+    addToBuffer(frag);
 }
\ No newline at end of file
diff --git a/modules/fieldlines/shaders/fieldline_vs.glsl b/modules/fieldlines/shaders/fieldline_vs.glsl
index d08dc19d08..9fcdcb5bcb 100644
--- a/modules/fieldlines/shaders/fieldline_vs.glsl
+++ b/modules/fieldlines/shaders/fieldline_vs.glsl
@@ -34,7 +34,7 @@ out vec4 vs_color;
 
 #include "PowerScaling/powerScaling_vs.hglsl"
 
-void main() {		
-	vs_color = in_color;
-	gl_Position = vec4(in_position, 0);
+void main() {        
+    vs_color = in_color;
+    gl_Position = vec4(in_position, 0);
 }
\ No newline at end of file
diff --git a/modules/kameleon/include/kameleonwrapper.h b/modules/kameleon/include/kameleonwrapper.h
index f000507196..1f91592bb8 100644
--- a/modules/kameleon/include/kameleonwrapper.h
+++ b/modules/kameleon/include/kameleonwrapper.h
@@ -40,129 +40,129 @@ namespace ccmc {
 namespace openspace {
 
 struct LinePoint {
-	glm::vec3 position;
-	glm::vec4 color;
+    glm::vec3 position;
+    glm::vec4 color;
 
-	LinePoint(glm::vec3 pos, glm::vec4 col) {
-		position = pos;
-		color = col;
-	}
+    LinePoint(glm::vec3 pos, glm::vec4 col) {
+        position = pos;
+        color = col;
+    }
 };
 
 class KameleonWrapper {
 public:
 
-	enum class Model {
+    enum class Model {
         OpenGGCM,
-        BATSRUS,		// Magnetosphere
-        ENLIL,			// Heliosphere
+        BATSRUS,        // Magnetosphere
+        ENLIL,            // Heliosphere
         MAS,
         Adapt3D,
         SWMF,
         LFM,
         Unknown
-	};
+    };
 
-	enum class TraceDirection {
-		FORWARD = 1,
-		BACK 	= -1
-	};
+    enum class TraceDirection {
+        FORWARD = 1,
+        BACK     = -1
+    };
 
-	enum class FieldlineEnd {
-		NORTH,
-		SOUTH,
-		FAROUT
-	};
+    enum class FieldlineEnd {
+        NORTH,
+        SOUTH,
+        FAROUT
+    };
     
     enum class GridType {
         Cartesian,
         Spherical,
         Unknown
-	};
+    };
 
-	typedef std::vector<std::vector<LinePoint> > Fieldlines;
+    typedef std::vector<std::vector<LinePoint> > Fieldlines;
 
-	KameleonWrapper();
-	KameleonWrapper(const std::string& filename);
-	~KameleonWrapper();
+    KameleonWrapper();
+    KameleonWrapper(const std::string& filename);
+    ~KameleonWrapper();
 
-	bool open(const std::string& filename);
-	void close();
+    bool open(const std::string& filename);
+    void close();
 
-	float* getUniformSampledValues(
-		const std::string& var, 
-		const glm::size3_t& outDimensions);
+    float* getUniformSampledValues(
+        const std::string& var, 
+        const glm::size3_t& outDimensions);
 
-	float* getUniformSampledVectorValues(
-		const std::string& xVar, 
-		const std::string& yVar,
-		const std::string& zVar, 
-		const glm::size3_t& outDimensions);
+    float* getUniformSampledVectorValues(
+        const std::string& xVar, 
+        const std::string& yVar,
+        const std::string& zVar, 
+        const glm::size3_t& outDimensions);
 
-	Fieldlines getClassifiedFieldLines(
-		const std::string& xVar,
-		const std::string& yVar, 
-		const std::string& zVar,
-		const std::vector<glm::vec3>& seedPoints, 
-		float stepSize);
+    Fieldlines getClassifiedFieldLines(
+        const std::string& xVar,
+        const std::string& yVar, 
+        const std::string& zVar,
+        const std::vector<glm::vec3>& seedPoints, 
+        float stepSize);
 
-	Fieldlines getFieldLines(
-		const std::string& xVar,
-		const std::string& yVar, 
-		const std::string& zVar,
-		const std::vector<glm::vec3>& seedPoints, 
-		float stepSize, 
-		const glm::vec4& color);
+    Fieldlines getFieldLines(
+        const std::string& xVar,
+        const std::string& yVar, 
+        const std::string& zVar,
+        const std::vector<glm::vec3>& seedPoints, 
+        float stepSize, 
+        const glm::vec4& color);
 
-	Fieldlines getLorentzTrajectories(
-		const std::vector<glm::vec3>& seedPoints,
-		const glm::vec4& color, 
-		float stepsize);
+    Fieldlines getLorentzTrajectories(
+        const std::vector<glm::vec3>& seedPoints,
+        const glm::vec4& color, 
+        float stepsize);
 
-	glm::vec3 getModelBarycenterOffset();
-	glm::vec3 getModelScale();
-	glm::vec3 getGridMax();
-	glm::vec3 getGridMin();
-	std::string getVariableUnit(const std::string& variable);
+    glm::vec3 getModelBarycenterOffset();
+    glm::vec3 getModelScale();
+    glm::vec3 getGridMax();
+    glm::vec3 getGridMin();
+    std::string getVariableUnit(const std::string& variable);
 
-	std::tuple < std::string, std::string, std::string > getGridUnits();
+    std::tuple < std::string, std::string, std::string > getGridUnits();
 
-	Model model();
-	GridType gridType();
+    Model model();
+    GridType gridType();
 
 private:
-	typedef std::vector<glm::vec3> TraceLine;
-	TraceLine traceCartesianFieldline(
-		const std::string& xVar,
-		const std::string& yVar,
-		const std::string& zVar, 
-		const glm::vec3& seedPoint,
-		float stepSize, 
-		TraceDirection direction, 
-		FieldlineEnd& end);
+    typedef std::vector<glm::vec3> TraceLine;
+    TraceLine traceCartesianFieldline(
+        const std::string& xVar,
+        const std::string& yVar,
+        const std::string& zVar, 
+        const glm::vec3& seedPoint,
+        float stepSize, 
+        TraceDirection direction, 
+        FieldlineEnd& end);
 
-	TraceLine traceLorentzTrajectory(
-		const glm::vec3& seedPoint,
-		float stepsize, 
-		float eCharge);
+    TraceLine traceLorentzTrajectory(
+        const glm::vec3& seedPoint,
+        float stepsize, 
+        float eCharge);
     
     void getGridVariables(std::string& x, std::string& y, std::string& z);
     GridType getGridType(
-		const std::string& x, 
-		const std::string& y, 
-		const std::string& z);
+        const std::string& x, 
+        const std::string& y, 
+        const std::string& z);
     Model getModelType();
-	glm::vec4 classifyFieldline(FieldlineEnd fEnd, FieldlineEnd bEnd);
+    glm::vec4 classifyFieldline(FieldlineEnd fEnd, FieldlineEnd bEnd);
 
     ccmc::Kameleon* _kameleon;
-	ccmc::Model* _model;
+    ccmc::Model* _model;
     Model _type;
-	ccmc::Interpolator* _interpolator;
+    ccmc::Interpolator* _interpolator;
 
-	// Model parameters
-	float _xMin, _xMax, _yMin, _yMax, _zMin, _zMax;
-	float _xValidMin, _xValidMax, _yValidMin, _yValidMax, _zValidMin, _zValidMax;
-	std::string _xCoordVar, _yCoordVar, _zCoordVar;
+    // Model parameters
+    float _xMin, _xMax, _yMin, _yMax, _zMin, _zMax;
+    float _xValidMin, _xValidMax, _yValidMin, _yValidMax, _zValidMin, _zValidMax;
+    std::string _xCoordVar, _yCoordVar, _zCoordVar;
     GridType _gridType;
 };
 
diff --git a/modules/kameleon/src/kameleonwrapper.cpp b/modules/kameleon/src/kameleonwrapper.cpp
index 4d88a1895d..00b53f5cf0 100644
--- a/modules/kameleon/src/kameleonwrapper.cpp
+++ b/modules/kameleon/src/kameleonwrapper.cpp
@@ -49,149 +49,149 @@ std::string _loggerCat = "KameleonWrapper";
 const float RE_TO_METER = 6371000;
 
 KameleonWrapper::KameleonWrapper()
-	: _kameleon(nullptr)
-	, _model(nullptr)
-	, _type(Model::Unknown)
-	, _interpolator(nullptr)
-	, _xMin(0.f)
-	, _xMax(0.f)
-	, _yMin(0.f)
-	, _yMax(0.f)
-	, _zMin(0.f)
-	, _zMax(0.f)
-	, _xValidMin(0.f)
-	, _xValidMax(0.f)
-	, _yValidMin(0.f)
-	, _yValidMax(0.f)
-	, _zValidMin(0.f)
-	, _zValidMax(0.f)
-	, _xCoordVar("")
-	, _yCoordVar("")
-	, _zCoordVar("")
-	, _gridType(GridType::Unknown)
+    : _kameleon(nullptr)
+    , _model(nullptr)
+    , _type(Model::Unknown)
+    , _interpolator(nullptr)
+    , _xMin(0.f)
+    , _xMax(0.f)
+    , _yMin(0.f)
+    , _yMax(0.f)
+    , _zMin(0.f)
+    , _zMax(0.f)
+    , _xValidMin(0.f)
+    , _xValidMax(0.f)
+    , _yValidMin(0.f)
+    , _yValidMax(0.f)
+    , _zValidMin(0.f)
+    , _zValidMax(0.f)
+    , _xCoordVar("")
+    , _yCoordVar("")
+    , _zCoordVar("")
+    , _gridType(GridType::Unknown)
 {}
 
 KameleonWrapper::KameleonWrapper(const std::string& filename)
-	: _kameleon(nullptr)
-	, _model(nullptr)
+    : _kameleon(nullptr)
+    , _model(nullptr)
     , _type(Model::Unknown)
     , _interpolator(nullptr)
-	, _xMin(0.f)
-	, _xMax(0.f)
-	, _yMin(0.f)
-	, _yMax(0.f)
-	, _zMin(0.f)
-	, _zMax(0.f)
-	, _xValidMin(0.f)
-	, _xValidMax(0.f)
-	, _yValidMin(0.f)
-	, _yValidMax(0.f)
-	, _zValidMin(0.f)
-	, _zValidMax(0.f)
-	, _xCoordVar("")
-	, _yCoordVar("")
-	, _zCoordVar("")
+    , _xMin(0.f)
+    , _xMax(0.f)
+    , _yMin(0.f)
+    , _yMax(0.f)
+    , _zMin(0.f)
+    , _zMax(0.f)
+    , _xValidMin(0.f)
+    , _xValidMax(0.f)
+    , _yValidMin(0.f)
+    , _yValidMax(0.f)
+    , _zValidMin(0.f)
+    , _zValidMax(0.f)
+    , _xCoordVar("")
+    , _yCoordVar("")
+    , _zCoordVar("")
     , _gridType(GridType::Unknown)
 {
-	open(filename);
+    open(filename);
 }
 
 KameleonWrapper::~KameleonWrapper() {
-	close();
+    close();
 }
 
 bool KameleonWrapper::open(const std::string& filename) {
-	close();
+    close();
 
-	if (!FileSys.fileExists(filename))
-		return false;
+    if (!FileSys.fileExists(filename))
+        return false;
 
-	_kameleon = new ccmc::Kameleon;
-	long status = _kameleon->open(filename);
-	if (status == ccmc::FileReader::OK) {
-		_model = _kameleon->model;
-		_interpolator = _model->createNewInterpolator();
+    _kameleon = new ccmc::Kameleon;
+    long status = _kameleon->open(filename);
+    if (status == ccmc::FileReader::OK) {
+        _model = _kameleon->model;
+        _interpolator = _model->createNewInterpolator();
 
-		getGridVariables(_xCoordVar, _yCoordVar, _zCoordVar);
+        getGridVariables(_xCoordVar, _yCoordVar, _zCoordVar);
 
-		_gridType = getGridType(_xCoordVar, _yCoordVar, _zCoordVar);
-		_type = getModelType();
+        _gridType = getGridType(_xCoordVar, _yCoordVar, _zCoordVar);
+        _type = getModelType();
 
-		LDEBUG("x:" << _xCoordVar);
-		LDEBUG("y:" << _yCoordVar);
-		LDEBUG("z:" << _zCoordVar);
+        LDEBUG("x:" << _xCoordVar);
+        LDEBUG("y:" << _yCoordVar);
+        LDEBUG("z:" << _zCoordVar);
 
-		_xMin = _model->getVariableAttribute(_xCoordVar, "actual_min").getAttributeFloat();
-		_xMax = _model->getVariableAttribute(_xCoordVar, "actual_max").getAttributeFloat();
-		_yMin = _model->getVariableAttribute(_yCoordVar, "actual_min").getAttributeFloat();
-		_yMax = _model->getVariableAttribute(_yCoordVar, "actual_max").getAttributeFloat();
-		_zMin = _model->getVariableAttribute(_zCoordVar, "actual_min").getAttributeFloat();
-		_zMax = _model->getVariableAttribute(_zCoordVar, "actual_max").getAttributeFloat();
+        _xMin = _model->getVariableAttribute(_xCoordVar, "actual_min").getAttributeFloat();
+        _xMax = _model->getVariableAttribute(_xCoordVar, "actual_max").getAttributeFloat();
+        _yMin = _model->getVariableAttribute(_yCoordVar, "actual_min").getAttributeFloat();
+        _yMax = _model->getVariableAttribute(_yCoordVar, "actual_max").getAttributeFloat();
+        _zMin = _model->getVariableAttribute(_zCoordVar, "actual_min").getAttributeFloat();
+        _zMax = _model->getVariableAttribute(_zCoordVar, "actual_max").getAttributeFloat();
 
-		/*	_xMin = -200.0f;
-		_xMax = 200.0f;
-		_yMin = -200.0f;
-		_yMax = 200.0f;
-		_zMin = -200.0f;
-		_zMax = 200.0f;*/
+        /*    _xMin = -200.0f;
+        _xMax = 200.0f;
+        _yMin = -200.0f;
+        _yMax = 200.0f;
+        _zMin = -200.0f;
+        _zMax = 200.0f;*/
 
 
-		_xValidMin = _model->getVariableAttribute(_xCoordVar, "valid_min").getAttributeFloat();
-		_xValidMax = _model->getVariableAttribute(_xCoordVar, "valid_max").getAttributeFloat();
-		_yValidMin = _model->getVariableAttribute(_yCoordVar, "valid_min").getAttributeFloat();
-		_yValidMax = _model->getVariableAttribute(_yCoordVar, "valid_max").getAttributeFloat();
-		_zValidMin = _model->getVariableAttribute(_zCoordVar, "valid_min").getAttributeFloat();
-		_zValidMax = _model->getVariableAttribute(_zCoordVar, "valid_max").getAttributeFloat();
-		LDEBUG("_xMin: " << _xMin);
-		LDEBUG("_xMax: " << _xMax);
-		LDEBUG("_yMin: " << _yMin);
-		LDEBUG("_yMax: " << _yMax);
-		LDEBUG("_zMin: " << _zMin);
-		LDEBUG("_zMax: " << _zMax);
-		LDEBUG("_xValidMin: " << _xValidMin);
-		LDEBUG("_xValidMax: " << _xValidMax);
-		LDEBUG("_yValidMin: " << _yValidMin);
-		LDEBUG("_yValidMax: " << _yValidMax);
-		LDEBUG("_zValidMin: " << _zValidMin);
-		LDEBUG("_zValidMax: " << _zValidMax);
-		return true;
-	}
-	return false;
+        _xValidMin = _model->getVariableAttribute(_xCoordVar, "valid_min").getAttributeFloat();
+        _xValidMax = _model->getVariableAttribute(_xCoordVar, "valid_max").getAttributeFloat();
+        _yValidMin = _model->getVariableAttribute(_yCoordVar, "valid_min").getAttributeFloat();
+        _yValidMax = _model->getVariableAttribute(_yCoordVar, "valid_max").getAttributeFloat();
+        _zValidMin = _model->getVariableAttribute(_zCoordVar, "valid_min").getAttributeFloat();
+        _zValidMax = _model->getVariableAttribute(_zCoordVar, "valid_max").getAttributeFloat();
+        LDEBUG("_xMin: " << _xMin);
+        LDEBUG("_xMax: " << _xMax);
+        LDEBUG("_yMin: " << _yMin);
+        LDEBUG("_yMax: " << _yMax);
+        LDEBUG("_zMin: " << _zMin);
+        LDEBUG("_zMax: " << _zMax);
+        LDEBUG("_xValidMin: " << _xValidMin);
+        LDEBUG("_xValidMax: " << _xValidMax);
+        LDEBUG("_yValidMin: " << _yValidMin);
+        LDEBUG("_yValidMax: " << _yValidMax);
+        LDEBUG("_zValidMin: " << _zValidMin);
+        LDEBUG("_zValidMax: " << _zValidMax);
+        return true;
+    }
+    return false;
 }
 
 void KameleonWrapper::close() {
-	if (_kameleon)
-		_kameleon->close();
-	if (_interpolator)
-		delete _interpolator;
-	if (_kameleon)
-		delete _kameleon;
+    if (_kameleon)
+        _kameleon->close();
+    if (_interpolator)
+        delete _interpolator;
+    if (_kameleon)
+        delete _kameleon;
 
-	_kameleon = nullptr;
-	_interpolator = nullptr;
-	_model = nullptr;
-	_type = Model::Unknown;
-	_gridType = GridType::Unknown;
+    _kameleon = nullptr;
+    _interpolator = nullptr;
+    _model = nullptr;
+    _type = Model::Unknown;
+    _gridType = GridType::Unknown;
 }
 
 float* KameleonWrapper::getUniformSampledValues(
-	const std::string& var, 
-	const glm::size3_t& outDimensions) 
+    const std::string& var, 
+    const glm::size3_t& outDimensions) 
 {
-	assert(_model && _interpolator);
-	assert(outDimensions.x > 0 && outDimensions.y > 0 && outDimensions.z > 0);
+    assert(_model && _interpolator);
+    assert(outDimensions.x > 0 && outDimensions.y > 0 && outDimensions.z > 0);
     LINFO("Loading variable " << var << " from CDF data with a uniform sampling");
 
-	unsigned int size = static_cast<unsigned int>(outDimensions.x*outDimensions.y*outDimensions.z);
-	float* data = new float[size];
-	double* doubleData = new double[size];
+    unsigned int size = static_cast<unsigned int>(outDimensions.x*outDimensions.y*outDimensions.z);
+    float* data = new float[size];
+    double* doubleData = new double[size];
 
-	double varMin = _model->getVariableAttribute(var, "actual_min").getAttributeFloat();
-	double varMax = _model->getVariableAttribute(var, "actual_max").getAttributeFloat();
-	
-	double stepX = (_xMax-_xMin)/(static_cast<double>(outDimensions.x));
-	double stepY = (_yMax-_yMin)/(static_cast<double>(outDimensions.y));
-	double stepZ = (_zMax-_zMin)/(static_cast<double>(outDimensions.z));
+    double varMin = _model->getVariableAttribute(var, "actual_min").getAttributeFloat();
+    double varMax = _model->getVariableAttribute(var, "actual_max").getAttributeFloat();
+    
+    double stepX = (_xMax-_xMin)/(static_cast<double>(outDimensions.x));
+    double stepY = (_yMax-_yMin)/(static_cast<double>(outDimensions.y));
+    double stepZ = (_zMax-_zMin)/(static_cast<double>(outDimensions.z));
     
     LDEBUG(var << "Min: " << varMin);
     LDEBUG(var << "Max: " << varMax);
@@ -201,21 +201,21 @@ float* KameleonWrapper::getUniformSampledValues(
     const float truncLim = 0.9f;
     std::vector<int> histogram (bins,0);
     auto mapToHistogram = [varMin, varMax, bins](double val) {
-    	double zeroToOne = (val-varMin)/(varMax-varMin);
-    	zeroToOne *= static_cast<double>(bins);
-		int izerotoone = static_cast<int>(zeroToOne);
-		
-		return glm::clamp(izerotoone, 0, bins-1);
+        double zeroToOne = (val-varMin)/(varMax-varMin);
+        zeroToOne *= static_cast<double>(bins);
+        int izerotoone = static_cast<int>(zeroToOne);
+        
+        return glm::clamp(izerotoone, 0, bins-1);
     };
     
-	//ProgressBar pb(static_cast<int>(outDimensions.x));
+    //ProgressBar pb(static_cast<int>(outDimensions.x));
     for (int x = 0; x < outDimensions.x; ++x) {
-		//pb.print(x);
+        //pb.print(x);
         
-		for (int y = 0; y < outDimensions.y; ++y) {
-			for (int z = 0; z < outDimensions.z; ++z) {
+        for (int y = 0; y < outDimensions.y; ++y) {
+            for (int z = 0; z < outDimensions.z; ++z) {
                 
-				unsigned int index = static_cast<unsigned int>(x + y*outDimensions.x + z*outDimensions.x*outDimensions.y);
+                unsigned int index = static_cast<unsigned int>(x + y*outDimensions.x + z*outDimensions.x*outDimensions.y);
                 
                 if (_gridType == GridType::Spherical) {
                     // Put r in the [0..sqrt(3)] range
@@ -254,10 +254,10 @@ float* KameleonWrapper::getUniformSampledValues(
                         phiPh = phiPh*180.f/M_PI;
                         // Sample
                         value = _interpolator->interpolate(
-							var, 
-							static_cast<float>(rPh), 
-							static_cast<float>(thetaPh), 
-							static_cast<float>(phiPh));
+                            var, 
+                            static_cast<float>(rPh), 
+                            static_cast<float>(thetaPh), 
+                            static_cast<float>(phiPh));
                         // value = _interpolator->interpolate(var, rPh, phiPh, thetaPh);
                     }
                     
@@ -269,519 +269,519 @@ float* KameleonWrapper::getUniformSampledValues(
                     double xPos = _xMin + stepX*x;
                     double yPos = _yMin + stepY*y;
                     double zPos = _zMin + stepZ*z;
-					/*
-					if (xPos < _xValidMin || xPos > _xValidMax ||
-						yPos < _yValidMin || yPos > _yValidMax ||
-						zPos < _zValidMin || zPos > _zValidMax) {
-						doubleData[index] = varMin;
-						continue;
-					}
-					*/
+                    /*
+                    if (xPos < _xValidMin || xPos > _xValidMax ||
+                        yPos < _yValidMin || yPos > _yValidMax ||
+                        zPos < _zValidMin || zPos > _zValidMax) {
+                        doubleData[index] = varMin;
+                        continue;
+                    }
+                    */
                     
                     // get interpolated data value for (xPos, yPos, zPos)
                     // swap yPos and zPos because model has Z as up
-					double value = _interpolator->interpolate(
-						var,
-						static_cast<float>(xPos),
-						static_cast<float>(zPos),
-						static_cast<float>(yPos));
+                    double value = _interpolator->interpolate(
+                        var,
+                        static_cast<float>(xPos),
+                        static_cast<float>(zPos),
+                        static_cast<float>(yPos));
                     doubleData[index] = value;
                     histogram[mapToHistogram(value)]++;
                 }
-			}
-		}
-	}
+            }
+        }
+    }
     //std::cout << std::endl;
     //LINFO("Done!");
 
      //for (int i = 0; i <  outDimensions.x *  outDimensions.y *  outDimensions.z; ++i)
      //{
-     //	std::cout << std::setfill(' ') << std::setw(15) << doubleData[i] << ", ";
-     //	if(i % 10 == 0)
-     //		std::cout << std::endl;
+     //    std::cout << std::setfill(' ') << std::setw(15) << doubleData[i] << ", ";
+     //    if(i % 10 == 0)
+     //        std::cout << std::endl;
      //}
      //    
     // for(int i = 0; i < bins-1; ++i) {
-    // 	// sum += histogram[i];
-    // 	// if(sum + histogram[i+1] > sumuntil) {
-    // 	// 	stop = i;
-    // 	// 	LDEBUG("====================");
-    // 	// 	break;
-    // 	// }
-    // 	LDEBUG("histogram[" << i << "]: " << histogram[i]);
+    //     // sum += histogram[i];
+    //     // if(sum + histogram[i+1] > sumuntil) {
+    //     //     stop = i;
+    //     //     LDEBUG("====================");
+    //     //     break;
+    //     // }
+    //     LDEBUG("histogram[" << i << "]: " << histogram[i]);
     // }
 
     int sum = 0;
     int stop = 0;
     const int sumuntil = static_cast<int>(static_cast<float>(size) * truncLim);
     for(int i = 0; i < bins; ++i) {
-    	sum += histogram[i];
-    	if(sum > sumuntil) {
-    		stop = i;
-    		// LDEBUG("====================");
-    		break;
-    	}
-    	LDEBUG("histogram[" << i << "]: " << histogram[i]);
+        sum += histogram[i];
+        if(sum > sumuntil) {
+            stop = i;
+            // LDEBUG("====================");
+            break;
+        }
+        LDEBUG("histogram[" << i << "]: " << histogram[i]);
     }
 
     double dist = varMax - varMin;
     dist = (dist / static_cast<double>(bins)) * static_cast<double>(stop);
 
-	varMax = varMin + dist;
+    varMax = varMin + dist;
     //LDEBUG(var << "Min: " << varMin);
     //LDEBUG(var << "Max: " << varMax);
     for(size_t i = 0; i < size; ++i) {
-    	double normalizedVal = (doubleData[i]-varMin)/(varMax-varMin);
+        double normalizedVal = (doubleData[i]-varMin)/(varMax-varMin);
 
-    	data[i] = static_cast<float>(glm::clamp(normalizedVal, 0.0, 1.0));
-    	if(data[i] < 0.0) {
-    		LERROR("Datapoint " << i << " less than 0");
-    	}
-    	if(data[i] > 1.0) {
-    		LERROR("Datapoint " << i << " more than 1");
-    	}
+        data[i] = static_cast<float>(glm::clamp(normalizedVal, 0.0, 1.0));
+        if(data[i] < 0.0) {
+            LERROR("Datapoint " << i << " less than 0");
+        }
+        if(data[i] > 1.0) {
+            LERROR("Datapoint " << i << " more than 1");
+        }
     }
 
     // for(int i = 0; i < size; ++i) {
-    // 	double normalizedVal = (doubleData[i]-varMin)/(varMax-varMin);
-    // 	// data[i] = static_cast<float>(glm::clamp(normalizedVal, 0.0, 1.0));
-    // 	data[i] = static_cast<float>(normalizedVal);
+    //     double normalizedVal = (doubleData[i]-varMin)/(varMax-varMin);
+    //     // data[i] = static_cast<float>(glm::clamp(normalizedVal, 0.0, 1.0));
+    //     data[i] = static_cast<float>(normalizedVal);
     // }
 
     delete[] doubleData;
-	return data;
+    return data;
 }
 
 float* KameleonWrapper::getUniformSampledVectorValues(
-	const std::string& xVar,
-	const std::string& yVar, 
-	const std::string& zVar, 
-	const glm::size3_t& outDimensions) 
+    const std::string& xVar,
+    const std::string& yVar, 
+    const std::string& zVar, 
+    const glm::size3_t& outDimensions) 
 {
-	assert(_model && _interpolator);
-	assert(outDimensions.x > 0 && outDimensions.y > 0 && outDimensions.z > 0);
-	LINFO("Loading variables " << xVar << " " << yVar << " " << zVar << " from CDF data with a uniform sampling");
+    assert(_model && _interpolator);
+    assert(outDimensions.x > 0 && outDimensions.y > 0 && outDimensions.z > 0);
+    LINFO("Loading variables " << xVar << " " << yVar << " " << zVar << " from CDF data with a uniform sampling");
 
-	int channels = 4;
-	unsigned int size = static_cast<unsigned int>(channels*outDimensions.x*outDimensions.y*outDimensions.z);
-	float* data = new float[size];
+    int channels = 4;
+    unsigned int size = static_cast<unsigned int>(channels*outDimensions.x*outDimensions.y*outDimensions.z);
+    float* data = new float[size];
 
-	float varXMin =  _model->getVariableAttribute(xVar, "actual_min").getAttributeFloat();
-	float varXMax =  _model->getVariableAttribute(xVar, "actual_max").getAttributeFloat();
-	float varYMin =  _model->getVariableAttribute(yVar, "actual_min").getAttributeFloat();
-	float varYMax =  _model->getVariableAttribute(yVar, "actual_max").getAttributeFloat();
-	float varZMin =  _model->getVariableAttribute(zVar, "actual_min").getAttributeFloat();
-	float varZMax =  _model->getVariableAttribute(zVar, "actual_max").getAttributeFloat();
+    float varXMin =  _model->getVariableAttribute(xVar, "actual_min").getAttributeFloat();
+    float varXMax =  _model->getVariableAttribute(xVar, "actual_max").getAttributeFloat();
+    float varYMin =  _model->getVariableAttribute(yVar, "actual_min").getAttributeFloat();
+    float varYMax =  _model->getVariableAttribute(yVar, "actual_max").getAttributeFloat();
+    float varZMin =  _model->getVariableAttribute(zVar, "actual_min").getAttributeFloat();
+    float varZMax =  _model->getVariableAttribute(zVar, "actual_max").getAttributeFloat();
 
-	float stepX = (_xMax-_xMin)/(static_cast<float>(outDimensions.x));
-	float stepY = (_yMax-_yMin)/(static_cast<float>(outDimensions.y));
-	float stepZ = (_zMax-_zMin)/(static_cast<float>(outDimensions.z));
+    float stepX = (_xMax-_xMin)/(static_cast<float>(outDimensions.x));
+    float stepY = (_yMax-_yMin)/(static_cast<float>(outDimensions.y));
+    float stepZ = (_zMax-_zMin)/(static_cast<float>(outDimensions.z));
 
-	//LDEBUG(xVar << "Min: " << varXMin);
-	//LDEBUG(xVar << "Max: " << varXMax);
-	//LDEBUG(yVar << "Min: " << varYMin);
-	//LDEBUG(yVar << "Max: " << varYMax);
-	//LDEBUG(zVar << "Min: " << varZMin);
-	//LDEBUG(zVar << "Max: " << varZMax);
+    //LDEBUG(xVar << "Min: " << varXMin);
+    //LDEBUG(xVar << "Max: " << varXMax);
+    //LDEBUG(yVar << "Min: " << varYMin);
+    //LDEBUG(yVar << "Max: " << varYMax);
+    //LDEBUG(zVar << "Min: " << varZMin);
+    //LDEBUG(zVar << "Max: " << varZMax);
 
-	//ProgressBar pb(static_cast<int>(outDimensions.x));
-	for (int x = 0; x < outDimensions.x; ++x) {
-		//pb.print(x);
+    //ProgressBar pb(static_cast<int>(outDimensions.x));
+    for (int x = 0; x < outDimensions.x; ++x) {
+        //pb.print(x);
 
-		for (int y = 0; y < outDimensions.y; ++y) {
-			for (int z = 0; z < outDimensions.z; ++z) {
+        for (int y = 0; y < outDimensions.y; ++y) {
+            for (int z = 0; z < outDimensions.z; ++z) {
 
-				unsigned int index = static_cast<unsigned int>(x*channels + y*channels*outDimensions.x + z*channels*outDimensions.x*outDimensions.y);
+                unsigned int index = static_cast<unsigned int>(x*channels + y*channels*outDimensions.x + z*channels*outDimensions.x*outDimensions.y);
 
-				if(_gridType == GridType::Cartesian) {
-					float xPos = _xMin + stepX*x;
-					float yPos = _yMin + stepY*y;
-					float zPos = _zMin + stepZ*z;
+                if(_gridType == GridType::Cartesian) {
+                    float xPos = _xMin + stepX*x;
+                    float yPos = _yMin + stepY*y;
+                    float zPos = _zMin + stepZ*z;
 
-					// get interpolated data value for (xPos, yPos, zPos)
-					float xValue = _interpolator->interpolate(xVar, xPos, yPos, zPos);
-					float yValue = _interpolator->interpolate(yVar, xPos, yPos, zPos);
-					float zValue = _interpolator->interpolate(zVar, xPos, yPos, zPos);
+                    // get interpolated data value for (xPos, yPos, zPos)
+                    float xValue = _interpolator->interpolate(xVar, xPos, yPos, zPos);
+                    float yValue = _interpolator->interpolate(yVar, xPos, yPos, zPos);
+                    float zValue = _interpolator->interpolate(zVar, xPos, yPos, zPos);
 
-					// scale to [0,1]
-					data[index] 	= (xValue-varXMin)/(varXMax-varXMin); // R
-					data[index + 1] = (yValue-varYMin)/(varYMax-varYMin); // G
-					data[index + 2] = (zValue-varZMin)/(varZMax-varZMin); // B
-					data[index + 3] = 1.0; // GL_RGB refuses to work. Workaround by doing a GL_RGBA with hardcoded alpha
-				} else {
-					LERROR("Only cartesian grid supported for getUniformSampledVectorValues (for now)");
-					return data;
-				}
-			}
-		}
-	}
+                    // scale to [0,1]
+                    data[index]     = (xValue-varXMin)/(varXMax-varXMin); // R
+                    data[index + 1] = (yValue-varYMin)/(varYMax-varYMin); // G
+                    data[index + 2] = (zValue-varZMin)/(varZMax-varZMin); // B
+                    data[index + 3] = 1.0; // GL_RGB refuses to work. Workaround by doing a GL_RGBA with hardcoded alpha
+                } else {
+                    LERROR("Only cartesian grid supported for getUniformSampledVectorValues (for now)");
+                    return data;
+                }
+            }
+        }
+    }
 
-	return data;
+    return data;
 }
 
 KameleonWrapper::Fieldlines KameleonWrapper::getClassifiedFieldLines(
-	const std::string& xVar, 
-	const std::string& yVar,
-	const std::string& zVar,
-	const std::vector<glm::vec3>& seedPoints,
-	float stepSize ) 
+    const std::string& xVar, 
+    const std::string& yVar,
+    const std::string& zVar,
+    const std::vector<glm::vec3>& seedPoints,
+    float stepSize ) 
 {
-	assert(_model && _interpolator);
-	LINFO("Creating " << seedPoints.size() << " fieldlines from variables " << xVar << " " << yVar << " " << zVar);
+    assert(_model && _interpolator);
+    LINFO("Creating " << seedPoints.size() << " fieldlines from variables " << xVar << " " << yVar << " " << zVar);
 
-	std::vector<glm::vec3> fLine, bLine;
-	std::vector<std::vector<LinePoint> > fieldLines;
-	glm::vec4 color;
-	FieldlineEnd forwardEnd, backEnd;
+    std::vector<glm::vec3> fLine, bLine;
+    std::vector<std::vector<LinePoint> > fieldLines;
+    glm::vec4 color;
+    FieldlineEnd forwardEnd, backEnd;
 
-	if (_type == Model::BATSRUS) {
-		for (glm::vec3 seedPoint : seedPoints) {
-			fLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::FORWARD, forwardEnd);
-			bLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::BACK, backEnd);
+    if (_type == Model::BATSRUS) {
+        for (glm::vec3 seedPoint : seedPoints) {
+            fLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::FORWARD, forwardEnd);
+            bLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::BACK, backEnd);
 
-			bLine.erase(bLine.begin());
-			bLine.insert(bLine.begin(), fLine.rbegin(), fLine.rend());
+            bLine.erase(bLine.begin());
+            bLine.insert(bLine.begin(), fLine.rbegin(), fLine.rend());
 
-			// classify
-			color = classifyFieldline(forwardEnd, backEnd);
+            // classify
+            color = classifyFieldline(forwardEnd, backEnd);
 
-			// write colors and convert positions to meter
-			std::vector<LinePoint> line;
-			for (glm::vec3 position : bLine) {
-				line.push_back(LinePoint(RE_TO_METER*position, color));
-			}
+            // write colors and convert positions to meter
+            std::vector<LinePoint> line;
+            for (glm::vec3 position : bLine) {
+                line.push_back(LinePoint(RE_TO_METER*position, color));
+            }
 
-			fieldLines.push_back(line);
-		}
-	} else {
-		LERROR("Fieldlines are only supported for BATSRUS model");
-	}
+            fieldLines.push_back(line);
+        }
+    } else {
+        LERROR("Fieldlines are only supported for BATSRUS model");
+    }
 
-	return fieldLines;
+    return fieldLines;
 }
 
 KameleonWrapper::Fieldlines KameleonWrapper::getFieldLines(
-	const std::string& xVar, 
-	const std::string& yVar,
-	const std::string& zVar, 
-	const std::vector<glm::vec3>& seedPoints,
-	float stepSize, 
-	const glm::vec4& color ) 
+    const std::string& xVar, 
+    const std::string& yVar,
+    const std::string& zVar, 
+    const std::vector<glm::vec3>& seedPoints,
+    float stepSize, 
+    const glm::vec4& color ) 
 {
-	assert(_model && _interpolator);
-	LINFO("Creating " << seedPoints.size() << " fieldlines from variables " << xVar << " " << yVar << " " << zVar);
+    assert(_model && _interpolator);
+    LINFO("Creating " << seedPoints.size() << " fieldlines from variables " << xVar << " " << yVar << " " << zVar);
 
-	std::vector<glm::vec3> fLine, bLine;
-	Fieldlines fieldLines;
-	FieldlineEnd forwardEnd, backEnd;
+    std::vector<glm::vec3> fLine, bLine;
+    Fieldlines fieldLines;
+    FieldlineEnd forwardEnd, backEnd;
 
-	if (_type == Model::BATSRUS) {
-		for (glm::vec3 seedPoint : seedPoints) {
-			fLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::FORWARD, forwardEnd);
-			bLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::BACK, backEnd);
+    if (_type == Model::BATSRUS) {
+        for (glm::vec3 seedPoint : seedPoints) {
+            fLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::FORWARD, forwardEnd);
+            bLine = traceCartesianFieldline(xVar, yVar, zVar, seedPoint, stepSize, TraceDirection::BACK, backEnd);
 
-			bLine.erase(bLine.begin());
-			bLine.insert(bLine.begin(), fLine.rbegin(), fLine.rend());			
+            bLine.erase(bLine.begin());
+            bLine.insert(bLine.begin(), fLine.rbegin(), fLine.rend());            
 
-			// write colors and convert positions to meter
-			std::vector<LinePoint> line;
-			for (glm::vec3 position : bLine) {
-				line.push_back(LinePoint(RE_TO_METER*position, color));
-			}
+            // write colors and convert positions to meter
+            std::vector<LinePoint> line;
+            for (glm::vec3 position : bLine) {
+                line.push_back(LinePoint(RE_TO_METER*position, color));
+            }
 
-			fieldLines.push_back(line);
-		}
-	} else {
-		LERROR("Fieldlines are only supported for BATSRUS model");
-	}
+            fieldLines.push_back(line);
+        }
+    } else {
+        LERROR("Fieldlines are only supported for BATSRUS model");
+    }
 
-	return fieldLines;
+    return fieldLines;
 }
 
 KameleonWrapper::Fieldlines KameleonWrapper::getLorentzTrajectories(
-	const std::vector<glm::vec3>& seedPoints, 
-	const glm::vec4& color, 
-	float stepsize) 
+    const std::vector<glm::vec3>& seedPoints, 
+    const glm::vec4& color, 
+    float stepsize) 
 {
-	LINFO("Creating " << seedPoints.size() << " Lorentz force trajectories");
+    LINFO("Creating " << seedPoints.size() << " Lorentz force trajectories");
 
-	Fieldlines trajectories;
-	std::vector<glm::vec3> plusTraj, minusTraj;
+    Fieldlines trajectories;
+    std::vector<glm::vec3> plusTraj, minusTraj;
 
-	for (auto seedPoint : seedPoints) {
-		plusTraj = traceLorentzTrajectory(seedPoint, stepsize, 1.0);
-		minusTraj = traceLorentzTrajectory(seedPoint, stepsize, -1.0);
+    for (auto seedPoint : seedPoints) {
+        plusTraj = traceLorentzTrajectory(seedPoint, stepsize, 1.0);
+        minusTraj = traceLorentzTrajectory(seedPoint, stepsize, -1.0);
 
-		//minusTraj.erase(minusTraj.begin());
-		size_t plusNum = plusTraj.size();
-		minusTraj.insert(minusTraj.begin(), plusTraj.rbegin(), plusTraj.rend());
+        //minusTraj.erase(minusTraj.begin());
+        size_t plusNum = plusTraj.size();
+        minusTraj.insert(minusTraj.begin(), plusTraj.rbegin(), plusTraj.rend());
 
-		// write colors and convert positions to meter
-		std::vector<LinePoint> trajectory;
-		for (glm::vec3 position : minusTraj) {			
-			if (trajectory.size() < plusNum) // set positive trajectory to pink
-				trajectory.push_back(LinePoint(RE_TO_METER*position, glm::vec4(1, 0, 1, 1)));
-			else // set negative trajectory to cyan
-				trajectory.push_back(LinePoint(RE_TO_METER*position, glm::vec4(0, 1, 1, 1)));
-		}
-		trajectories.push_back(trajectory);
-	}
+        // write colors and convert positions to meter
+        std::vector<LinePoint> trajectory;
+        for (glm::vec3 position : minusTraj) {            
+            if (trajectory.size() < plusNum) // set positive trajectory to pink
+                trajectory.push_back(LinePoint(RE_TO_METER*position, glm::vec4(1, 0, 1, 1)));
+            else // set negative trajectory to cyan
+                trajectory.push_back(LinePoint(RE_TO_METER*position, glm::vec4(0, 1, 1, 1)));
+        }
+        trajectories.push_back(trajectory);
+    }
 
-	return trajectories;
+    return trajectories;
 }
 
 glm::vec3 KameleonWrapper::getModelBarycenterOffset() {
-	// ENLIL is centered, no need for offset
-	if (_type == Model::ENLIL)
-		return glm::vec3(0,0,0);
+    // ENLIL is centered, no need for offset
+    if (_type == Model::ENLIL)
+        return glm::vec3(0,0,0);
 
-	glm::vec3 offset;
-	offset.x = _xMin+(std::abs(_xMin)+std::abs(_xMax))/2.0f;
-	offset.y = _yMin+(std::abs(_yMin)+std::abs(_yMax))/2.0f;
-	offset.z = _zMin+(std::abs(_zMin)+std::abs(_zMax))/2.0f;
-	return offset;
+    glm::vec3 offset;
+    offset.x = _xMin+(std::abs(_xMin)+std::abs(_xMax))/2.0f;
+    offset.y = _yMin+(std::abs(_yMin)+std::abs(_yMax))/2.0f;
+    offset.z = _zMin+(std::abs(_zMin)+std::abs(_zMax))/2.0f;
+    return offset;
 }
 
 glm::vec3 KameleonWrapper::getModelScale() {
-	if (_type == Model::ENLIL)
-		return glm::vec3(1.0f, 1.0f, 1.0f);
+    if (_type == Model::ENLIL)
+        return glm::vec3(1.0f, 1.0f, 1.0f);
 
-	glm::vec3 scale;
-	scale.x = _xMax - _xMin;
-	scale.y = _yMax - _yMin;
-	scale.z = _zMax - _zMin;
-	return scale;
+    glm::vec3 scale;
+    scale.x = _xMax - _xMin;
+    scale.y = _yMax - _yMin;
+    scale.z = _zMax - _zMin;
+    return scale;
 }
 
 glm::vec3 KameleonWrapper::getGridMax() {
-	return glm::vec3(_xMax, _yMax, _zMax);
+    return glm::vec3(_xMax, _yMax, _zMax);
 }
 
 glm::vec3 KameleonWrapper::getGridMin() {
-	return glm::vec3(_xMin, _yMin, _zMin);
+    return glm::vec3(_xMin, _yMin, _zMin);
 }
 
 std::string KameleonWrapper::getVariableUnit(const std::string& variable) {
-	return _model->getVariableAttribute(variable, "units").getAttributeString();
+    return _model->getVariableAttribute(variable, "units").getAttributeString();
 }
 
 std::tuple < std::string, std::string, std::string >
 KameleonWrapper::getGridUnits() {
-	return std::make_tuple(
-		getVariableUnit(_xCoordVar),
-		getVariableUnit(_yCoordVar),
-		getVariableUnit(_zCoordVar)
-	);
+    return std::make_tuple(
+        getVariableUnit(_xCoordVar),
+        getVariableUnit(_yCoordVar),
+        getVariableUnit(_zCoordVar)
+    );
 }
 
 KameleonWrapper::Model  KameleonWrapper::model() {
-	return _type;
+    return _type;
 }
 
 KameleonWrapper::GridType  KameleonWrapper::gridType() {
-	return _gridType;
+    return _gridType;
 }
 
 KameleonWrapper::TraceLine KameleonWrapper::traceCartesianFieldline(
-	const std::string& xVar,
-	const std::string& yVar,
-	const std::string& zVar, 
-	const glm::vec3& seedPoint,
-	float stepSize, 
-	TraceDirection direction, 
-	FieldlineEnd& end) 
+    const std::string& xVar,
+    const std::string& yVar,
+    const std::string& zVar, 
+    const glm::vec3& seedPoint,
+    float stepSize, 
+    TraceDirection direction, 
+    FieldlineEnd& end) 
 {
 
-	glm::vec3 color, pos, k1, k2, k3, k4;
-	TraceLine line;
-	float stepX, stepY, stepZ;
-	int numSteps = 0, maxSteps = 5000;
-	pos = seedPoint;
+    glm::vec3 color, pos, k1, k2, k3, k4;
+    TraceLine line;
+    float stepX, stepY, stepZ;
+    int numSteps = 0, maxSteps = 5000;
+    pos = seedPoint;
 
-	_model->loadVariable(xVar);
-	_model->loadVariable(yVar);
-	_model->loadVariable(zVar);
+    _model->loadVariable(xVar);
+    _model->loadVariable(yVar);
+    _model->loadVariable(zVar);
 
-	long int xID = _model->getVariableID(xVar);
-	long int yID = _model->getVariableID(yVar);
-	long int zID = _model->getVariableID(zVar);
+    long int xID = _model->getVariableID(xVar);
+    long int yID = _model->getVariableID(yVar);
+    long int zID = _model->getVariableID(zVar);
 
-	// While we are inside the models boundries and not inside earth
-	while ((pos.x < _xMax && pos.x > _xMin && pos.y < _yMax && pos.y > _yMin &&
-			pos.z < _zMax && pos.z > _zMin) && !(pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0)) {
+    // While we are inside the models boundries and not inside earth
+    while ((pos.x < _xMax && pos.x > _xMin && pos.y < _yMax && pos.y > _yMin &&
+            pos.z < _zMax && pos.z > _zMin) && !(pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0)) {
 
-		// Save position. Model has +Z as up
-		line.push_back(glm::vec3(pos.x, pos.z, pos.y));
+        // Save position. Model has +Z as up
+        line.push_back(glm::vec3(pos.x, pos.z, pos.y));
 
-		// Calculate new position with Runge-Kutta 4th order
-		k1.x = _interpolator->interpolate(xID, pos.x, pos.y, pos.z, stepX, stepY, stepZ);
-		k1.y = _interpolator->interpolate(yID, pos.x, pos.y, pos.z);
-		k1.z = _interpolator->interpolate(zID, pos.x, pos.y, pos.z);
-		k1 = (float)direction*glm::normalize(k1);
-		stepX=stepX*stepSize, stepY=stepY*stepSize, stepZ=stepZ*stepSize;
-		k2.x = _interpolator->interpolate(xID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
-		k2.y = _interpolator->interpolate(yID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
-		k2.z = _interpolator->interpolate(zID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
-		k2 = (float)direction*glm::normalize(k2);
-		k3.x = _interpolator->interpolate(xID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
-		k3.y = _interpolator->interpolate(yID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
-		k3.z = _interpolator->interpolate(zID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
-		k3 = (float)direction*glm::normalize(k3);
-		k4.x = _interpolator->interpolate(xID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
-		k4.y = _interpolator->interpolate(yID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
-		k4.z = _interpolator->interpolate(zID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
-		k4 = (float)direction*glm::normalize(k4);
-		pos.x = pos.x + (stepX/6.0f)*(k1.x + 2.0f*k2.x + 2.0f*k3.x + k4.x);
-		pos.y = pos.y + (stepY/6.0f)*(k1.y + 2.0f*k2.y + 2.0f*k3.y + k4.y);
-		pos.z = pos.z + (stepZ/6.0f)*(k1.z + 2.0f*k2.z + 2.0f*k3.z + k4.z);
+        // Calculate new position with Runge-Kutta 4th order
+        k1.x = _interpolator->interpolate(xID, pos.x, pos.y, pos.z, stepX, stepY, stepZ);
+        k1.y = _interpolator->interpolate(yID, pos.x, pos.y, pos.z);
+        k1.z = _interpolator->interpolate(zID, pos.x, pos.y, pos.z);
+        k1 = (float)direction*glm::normalize(k1);
+        stepX=stepX*stepSize, stepY=stepY*stepSize, stepZ=stepZ*stepSize;
+        k2.x = _interpolator->interpolate(xID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
+        k2.y = _interpolator->interpolate(yID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
+        k2.z = _interpolator->interpolate(zID, pos.x+(stepX/2.0f)*k1.x, pos.y+(stepY/2.0f)*k1.y, pos.z+(stepZ/2.0f)*k1.z);
+        k2 = (float)direction*glm::normalize(k2);
+        k3.x = _interpolator->interpolate(xID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
+        k3.y = _interpolator->interpolate(yID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
+        k3.z = _interpolator->interpolate(zID, pos.x+(stepX/2.0f)*k2.x, pos.y+(stepY/2.0f)*k2.y, pos.z+(stepZ/2.0f)*k2.z);
+        k3 = (float)direction*glm::normalize(k3);
+        k4.x = _interpolator->interpolate(xID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
+        k4.y = _interpolator->interpolate(yID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
+        k4.z = _interpolator->interpolate(zID, pos.x+stepX*k3.x, pos.y+stepY*k3.y, pos.z+stepZ*k3.z);
+        k4 = (float)direction*glm::normalize(k4);
+        pos.x = pos.x + (stepX/6.0f)*(k1.x + 2.0f*k2.x + 2.0f*k3.x + k4.x);
+        pos.y = pos.y + (stepY/6.0f)*(k1.y + 2.0f*k2.y + 2.0f*k3.y + k4.y);
+        pos.z = pos.z + (stepZ/6.0f)*(k1.z + 2.0f*k2.z + 2.0f*k3.z + k4.z);
 
-		++numSteps;
-		if (numSteps > maxSteps) {
-			LDEBUG("Max number of steps taken (" << maxSteps <<")");
-			break;
-		}
-	}
-	// Save last position. Model has +Z as up
-	line.push_back(glm::vec3(pos.x, pos.z, pos.y));
+        ++numSteps;
+        if (numSteps > maxSteps) {
+            LDEBUG("Max number of steps taken (" << maxSteps <<")");
+            break;
+        }
+    }
+    // Save last position. Model has +Z as up
+    line.push_back(glm::vec3(pos.x, pos.z, pos.y));
 
-	if (pos.z > 0.0 && (pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0))
-		end = FieldlineEnd::NORTH;
-	else if (pos.z < 0.0 && (pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0))
-		end = FieldlineEnd::SOUTH;
-	else
-		end = FieldlineEnd::FAROUT;
+    if (pos.z > 0.0 && (pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0))
+        end = FieldlineEnd::NORTH;
+    else if (pos.z < 0.0 && (pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0))
+        end = FieldlineEnd::SOUTH;
+    else
+        end = FieldlineEnd::FAROUT;
 
-	return line;
+    return line;
 }
 
 KameleonWrapper::TraceLine KameleonWrapper::traceLorentzTrajectory(
-	const glm::vec3& seedPoint,
-	float stepsize, 
-	float eCharge) 
+    const glm::vec3& seedPoint,
+    float stepsize, 
+    float eCharge) 
 {
-	glm::vec3 B, E, v0, k1, k2, k3, k4, sPos, tmpV;
-	float stepX = stepsize, stepY = stepsize, stepZ = stepsize;
+    glm::vec3 B, E, v0, k1, k2, k3, k4, sPos, tmpV;
+    float stepX = stepsize, stepY = stepsize, stepZ = stepsize;
 
-	long int bxID = _model->getVariableID("bx");
-	long int byID = _model->getVariableID("by");
-	long int bzID = _model->getVariableID("bz");
-	long int jxID = _model->getVariableID("jx");
-	long int jyID = _model->getVariableID("jy");
-	long int jzID = _model->getVariableID("jz");
+    long int bxID = _model->getVariableID("bx");
+    long int byID = _model->getVariableID("by");
+    long int bzID = _model->getVariableID("bz");
+    long int jxID = _model->getVariableID("jx");
+    long int jyID = _model->getVariableID("jy");
+    long int jzID = _model->getVariableID("jz");
 
-	TraceLine trajectory;
-	glm::vec3 pos = seedPoint;
-	int numSteps = 0, maxSteps = 5000;
-	v0.x = _interpolator->interpolate("ux", pos.x, pos.y, pos.z);
-	v0.y = _interpolator->interpolate("uy", pos.x, pos.y, pos.z);
-	v0.z = _interpolator->interpolate("uz", pos.x, pos.y, pos.z);
-	v0 = glm::normalize(v0);
+    TraceLine trajectory;
+    glm::vec3 pos = seedPoint;
+    int numSteps = 0, maxSteps = 5000;
+    v0.x = _interpolator->interpolate("ux", pos.x, pos.y, pos.z);
+    v0.y = _interpolator->interpolate("uy", pos.x, pos.y, pos.z);
+    v0.z = _interpolator->interpolate("uz", pos.x, pos.y, pos.z);
+    v0 = glm::normalize(v0);
 
-	// While we are inside the models boundries and not inside earth
-	while ((pos.x < _xMax && pos.x > _xMin && pos.y < _yMax && pos.y > _yMin &&
-			pos.z < _zMax && pos.z > _zMin) && !(pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0)) {
+    // While we are inside the models boundries and not inside earth
+    while ((pos.x < _xMax && pos.x > _xMin && pos.y < _yMax && pos.y > _yMin &&
+            pos.z < _zMax && pos.z > _zMin) && !(pos.x*pos.x + pos.y*pos.y + pos.z*pos.z < 1.0)) {
 
-		// Save position. Model has +Z as up
-		trajectory.push_back(glm::vec3(pos.x, pos.z, pos.y));
+        // Save position. Model has +Z as up
+        trajectory.push_back(glm::vec3(pos.x, pos.z, pos.y));
 
-		// Calculate new position with Lorentz force quation and Runge-Kutta 4th order
-		B.x = _interpolator->interpolate(bxID, pos.x, pos.y, pos.z);
-		B.y = _interpolator->interpolate(byID, pos.x, pos.y, pos.z);
-		B.z = _interpolator->interpolate(bzID, pos.x, pos.y, pos.z);
-		E.x = _interpolator->interpolate(jxID, pos.x, pos.y, pos.z);
-		E.y = _interpolator->interpolate(jyID, pos.x, pos.y, pos.z);
-		E.z = _interpolator->interpolate(jzID, pos.x, pos.y, pos.z);
-		k1 = eCharge*(E + glm::cross(v0, B));
-		k1 = glm::normalize(k1);
+        // Calculate new position with Lorentz force quation and Runge-Kutta 4th order
+        B.x = _interpolator->interpolate(bxID, pos.x, pos.y, pos.z);
+        B.y = _interpolator->interpolate(byID, pos.x, pos.y, pos.z);
+        B.z = _interpolator->interpolate(bzID, pos.x, pos.y, pos.z);
+        E.x = _interpolator->interpolate(jxID, pos.x, pos.y, pos.z);
+        E.y = _interpolator->interpolate(jyID, pos.x, pos.y, pos.z);
+        E.z = _interpolator->interpolate(jzID, pos.x, pos.y, pos.z);
+        k1 = eCharge*(E + glm::cross(v0, B));
+        k1 = glm::normalize(k1);
 
-		sPos = glm::vec3(	pos.x+(stepX/2.0)*v0.x+(stepX*stepX/8.0)*k1.x,
-							pos.y+(stepY/2.0)*v0.y+(stepY*stepY/8.0)*k1.y,
-							pos.z+(stepZ/2.0)*v0.z+(stepZ*stepZ/8.0)*k1.z);
-		B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
-		B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
-		B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
-		E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
-		E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
-		E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
-		tmpV = v0+(stepX/2.0f)*k1;
-		k2 = eCharge*(E + glm::cross(tmpV, B));
-		k2 = glm::normalize(k2);
+        sPos = glm::vec3(    pos.x+(stepX/2.0)*v0.x+(stepX*stepX/8.0)*k1.x,
+                            pos.y+(stepY/2.0)*v0.y+(stepY*stepY/8.0)*k1.y,
+                            pos.z+(stepZ/2.0)*v0.z+(stepZ*stepZ/8.0)*k1.z);
+        B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
+        B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
+        B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
+        E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
+        E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
+        E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
+        tmpV = v0+(stepX/2.0f)*k1;
+        k2 = eCharge*(E + glm::cross(tmpV, B));
+        k2 = glm::normalize(k2);
 
-		B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
-		B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
-		B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
-		E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
-		E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
-		E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
-		tmpV = v0+(stepX/2.0f)*k2;
-		k3 = eCharge*(E + glm::cross(tmpV, B));
-		k3 = glm::normalize(k3);
+        B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
+        B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
+        B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
+        E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
+        E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
+        E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
+        tmpV = v0+(stepX/2.0f)*k2;
+        k3 = eCharge*(E + glm::cross(tmpV, B));
+        k3 = glm::normalize(k3);
 
-		sPos = glm::vec3(	pos.x+stepX*v0.x+(stepX*stepX/2.0)*k1.x,
-							pos.y+stepY*v0.y+(stepY*stepY/2.0)*k1.y,
-							pos.z+stepZ*v0.z+(stepZ*stepZ/2.0)*k1.z);
-		B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
-		B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
-		B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
-		E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
-		E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
-		E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
-		tmpV = v0+stepX*k3;
-		k4 = eCharge*(E + glm::cross(tmpV, B));
-		k4 = glm::normalize(k4);
+        sPos = glm::vec3(    pos.x+stepX*v0.x+(stepX*stepX/2.0)*k1.x,
+                            pos.y+stepY*v0.y+(stepY*stepY/2.0)*k1.y,
+                            pos.z+stepZ*v0.z+(stepZ*stepZ/2.0)*k1.z);
+        B.x = _interpolator->interpolate(bxID, sPos.x, sPos.y, sPos.z);
+        B.y = _interpolator->interpolate(byID, sPos.x, sPos.y, sPos.z);
+        B.z = _interpolator->interpolate(bzID, sPos.x, sPos.y, sPos.z);
+        E.x = _interpolator->interpolate(jxID, sPos.x, sPos.y, sPos.z);
+        E.y = _interpolator->interpolate(jyID, sPos.x, sPos.y, sPos.z);
+        E.z = _interpolator->interpolate(jzID, sPos.x, sPos.y, sPos.z);
+        tmpV = v0+stepX*k3;
+        k4 = eCharge*(E + glm::cross(tmpV, B));
+        k4 = glm::normalize(k4);
 
-		pos.x = pos.x + stepX*v0.x + (stepX*stepX/6.0f)*(k1.x + k2.x + k3.x);
-		pos.y = pos.y + stepY*v0.y + (stepY*stepY/6.0f)*(k1.y + k2.y + k3.y);
-		pos.z = pos.z + stepZ*v0.z + (stepZ*stepZ/6.0f)*(k1.z + k2.z + k3.z);
+        pos.x = pos.x + stepX*v0.x + (stepX*stepX/6.0f)*(k1.x + k2.x + k3.x);
+        pos.y = pos.y + stepY*v0.y + (stepY*stepY/6.0f)*(k1.y + k2.y + k3.y);
+        pos.z = pos.z + stepZ*v0.z + (stepZ*stepZ/6.0f)*(k1.z + k2.z + k3.z);
 
-		v0.x = v0.x + (stepX/6.0f)*(k1.x + 2.0f*k2.x + 2.0f*k3.x + k4.z);
-		v0.y = v0.y + (stepY/6.0f)*(k1.y + 2.0f*k2.y + 2.0f*k3.y + k4.y);
-		v0.z = v0.z + (stepZ/6.0f)*(k1.z + 2.0f*k2.z + 2.0f*k3.z + k4.z);
+        v0.x = v0.x + (stepX/6.0f)*(k1.x + 2.0f*k2.x + 2.0f*k3.x + k4.z);
+        v0.y = v0.y + (stepY/6.0f)*(k1.y + 2.0f*k2.y + 2.0f*k3.y + k4.y);
+        v0.z = v0.z + (stepZ/6.0f)*(k1.z + 2.0f*k2.z + 2.0f*k3.z + k4.z);
 
-		++numSteps;
-		if (numSteps > maxSteps) {
-			LDEBUG("Max number of steps taken (" << maxSteps <<")");
-			break;
-		}
-	}
-	// Save last position. Model has +Z as up
-	trajectory.push_back(glm::vec3(pos.x, pos.z, pos.y));
-	return trajectory;
+        ++numSteps;
+        if (numSteps > maxSteps) {
+            LDEBUG("Max number of steps taken (" << maxSteps <<")");
+            break;
+        }
+    }
+    // Save last position. Model has +Z as up
+    trajectory.push_back(glm::vec3(pos.x, pos.z, pos.y));
+    return trajectory;
 }
 
 void KameleonWrapper::getGridVariables(std::string& x, std::string& y, std::string& z) {
-	// get the grid system string
-	std::string gridSystem = _model->getGlobalAttribute("grid_system_1").getAttributeString();
+    // get the grid system string
+    std::string gridSystem = _model->getGlobalAttribute("grid_system_1").getAttributeString();
 
-	// remove leading and trailing brackets
-	gridSystem = gridSystem.substr(1,gridSystem.length()-2);
+    // remove leading and trailing brackets
+    gridSystem = gridSystem.substr(1,gridSystem.length()-2);
 
-	// remove all whitespaces
-	gridSystem.erase(remove_if(gridSystem.begin(), gridSystem.end(), isspace), gridSystem.end());
+    // remove all whitespaces
+    gridSystem.erase(remove_if(gridSystem.begin(), gridSystem.end(), isspace), gridSystem.end());
 
-	// replace all comma signs with whitespaces
-	std::replace( gridSystem.begin(), gridSystem.end(), ',', ' ');
+    // replace all comma signs with whitespaces
+    std::replace( gridSystem.begin(), gridSystem.end(), ',', ' ');
 
-	// tokenize
-	std::istringstream iss(gridSystem);
-	std::vector<std::string> tokens{std::istream_iterator<std::string>{iss},std::istream_iterator<std::string>{}};
+    // tokenize
+    std::istringstream iss(gridSystem);
+    std::vector<std::string> tokens{std::istream_iterator<std::string>{iss},std::istream_iterator<std::string>{}};
 
-	// validate
-	if (tokens.size() != 3) LERROR("Something went wrong");
+    // validate
+    if (tokens.size() != 3) LERROR("Something went wrong");
 
-	x = tokens.at(0);
-	y = tokens.at(1);
-	z = tokens.at(2);
+    x = tokens.at(0);
+    y = tokens.at(1);
+    z = tokens.at(2);
 
-	std::transform(x.begin(), x.end(), x.begin(), ::tolower);
-	std::transform(y.begin(), y.end(), y.begin(), ::tolower);
-	std::transform(z.begin(), z.end(), z.begin(), ::tolower);
+    std::transform(x.begin(), x.end(), x.begin(), ::tolower);
+    std::transform(y.begin(), y.end(), y.begin(), ::tolower);
+    std::transform(z.begin(), z.end(), z.begin(), ::tolower);
 }
 
 KameleonWrapper::GridType KameleonWrapper::getGridType(
-	const std::string& x, 
-	const std::string& y, 
-	const std::string& z) 
+    const std::string& x, 
+    const std::string& y, 
+    const std::string& z) 
 {
     if(x == "x" && y == "y" && z == "z")
         return GridType::Cartesian;
@@ -821,24 +821,24 @@ KameleonWrapper::Model KameleonWrapper::getModelType() {
 }
 
 glm::vec4 KameleonWrapper::classifyFieldline(FieldlineEnd fEnd, FieldlineEnd bEnd) {
-	glm::vec4 color;
-	if (		(fEnd == FieldlineEnd::NORTH || fEnd == FieldlineEnd::SOUTH)
-			&& 	(bEnd == FieldlineEnd::NORTH || bEnd == FieldlineEnd::SOUTH)) {
-		// closed
-		color = glm::vec4(1.0, 0.0, 0.0, 1.0);
-	} else if ((fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::NORTH)
-			|| (bEnd == FieldlineEnd::FAROUT && fEnd == FieldlineEnd::NORTH)) {
-		// north
-		color = glm::vec4(1.0, 1.0, 0.0, 1.0);
-	} else if ((fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::SOUTH)
-			|| (bEnd == FieldlineEnd::FAROUT && fEnd == FieldlineEnd::SOUTH)) {
-		// south
-		color = glm::vec4(0.0, 1.0, 0.0, 1.0);
-	} else if (fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::FAROUT) {
-		// solar wind
-		color = glm::vec4(0.0, 0.0, 1.0, 1.0);
-	}
-	return color;
+    glm::vec4 color;
+    if (        (fEnd == FieldlineEnd::NORTH || fEnd == FieldlineEnd::SOUTH)
+            &&     (bEnd == FieldlineEnd::NORTH || bEnd == FieldlineEnd::SOUTH)) {
+        // closed
+        color = glm::vec4(1.0, 0.0, 0.0, 1.0);
+    } else if ((fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::NORTH)
+            || (bEnd == FieldlineEnd::FAROUT && fEnd == FieldlineEnd::NORTH)) {
+        // north
+        color = glm::vec4(1.0, 1.0, 0.0, 1.0);
+    } else if ((fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::SOUTH)
+            || (bEnd == FieldlineEnd::FAROUT && fEnd == FieldlineEnd::SOUTH)) {
+        // south
+        color = glm::vec4(0.0, 1.0, 0.0, 1.0);
+    } else if (fEnd == FieldlineEnd::FAROUT && bEnd == FieldlineEnd::FAROUT) {
+        // solar wind
+        color = glm::vec4(0.0, 0.0, 1.0, 1.0);
+    }
+    return color;
 }
 
 } // namespace openspace
diff --git a/modules/multiresvolume/rendering/brickmanager.cpp b/modules/multiresvolume/rendering/brickmanager.cpp
index 39f612eeb5..229e97f62e 100644
--- a/modules/multiresvolume/rendering/brickmanager.cpp
+++ b/modules/multiresvolume/rendering/brickmanager.cpp
@@ -32,29 +32,29 @@
 #include <fstream>
 
 namespace {
-	const std::string _loggerCat = "BrickManager";
+    const std::string _loggerCat = "BrickManager";
 }
 
 namespace openspace {
 
 BrickManager::BrickManager(TSP* tsp) 
-	: _tsp(tsp)
-	, numBricks_(0)
-	, brickDim_(0)
-	, paddedBrickDim_(0)
-	, atlasDim_(0)
-	, numBrickVals_(0)
-	, numBricksFrame_(0)
-	, numBricksTree_(0)
-	, brickSize_(0)
-	, volumeSize_(0)
-	, numValsTot_(0)
-	, xCoord_(0)
-	, yCoord_(0)
-	, zCoord_(0)
-	, textureAtlas_(nullptr)
-	, hasReadHeader_(false)
-	, atlasInitialized_(false)
+    : _tsp(tsp)
+    , numBricks_(0)
+    , brickDim_(0)
+    , paddedBrickDim_(0)
+    , atlasDim_(0)
+    , numBrickVals_(0)
+    , numBricksFrame_(0)
+    , numBricksTree_(0)
+    , brickSize_(0)
+    , volumeSize_(0)
+    , numValsTot_(0)
+    , xCoord_(0)
+    , yCoord_(0)
+    , zCoord_(0)
+    , textureAtlas_(nullptr)
+    , hasReadHeader_(false)
+    , atlasInitialized_(false)
 {}
 
 BrickManager::~BrickManager() {
@@ -63,414 +63,414 @@ BrickManager::~BrickManager() {
 
 bool BrickManager::readHeader() {
 
-	if (!_tsp->file().is_open())
-		return false;
+    if (!_tsp->file().is_open())
+        return false;
 
-	_header = _tsp->header();
+    _header = _tsp->header();
 
-	LDEBUG("Grid type: " << _header.gridType_);
-	LDEBUG("Original num timesteps: " << _header.numOrigTimesteps_);
-	LDEBUG("Num timesteps: " << _header.numTimesteps_);
-	LDEBUG("Brick dims: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
-	LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
-	LDEBUG("");
+    LDEBUG("Grid type: " << _header.gridType_);
+    LDEBUG("Original num timesteps: " << _header.numOrigTimesteps_);
+    LDEBUG("Num timesteps: " << _header.numTimesteps_);
+    LDEBUG("Brick dims: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
+    LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
+    LDEBUG("");
 
-	brickDim_ = _header.xBrickDim_;
-	numBricks_ = _header.xNumBricks_;
-	paddedBrickDim_ = brickDim_ + paddingWidth_ * 2;
-	atlasDim_ = paddedBrickDim_*numBricks_;
+    brickDim_ = _header.xBrickDim_;
+    numBricks_ = _header.xNumBricks_;
+    paddedBrickDim_ = brickDim_ + paddingWidth_ * 2;
+    atlasDim_ = paddedBrickDim_*numBricks_;
 
-	LDEBUG("Padded brick dim: " << paddedBrickDim_);
-	LDEBUG("Atlas dim: " << atlasDim_);
+    LDEBUG("Padded brick dim: " << paddedBrickDim_);
+    LDEBUG("Atlas dim: " << atlasDim_);
 
-	numBrickVals_ = paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
-	// Number of bricks per frame
-	numBricksFrame_ = numBricks_*numBricks_*numBricks_;
+    numBrickVals_ = paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
+    // Number of bricks per frame
+    numBricksFrame_ = numBricks_*numBricks_*numBricks_;
 
-	// Calculate number of bricks in tree
-	unsigned int numOTLevels = static_cast<unsigned int>(log((int)numBricks_) / log(2) + 1);
-	unsigned int numOTNodes = static_cast<unsigned int>((pow(8, numOTLevels) - 1) / 7);
-	unsigned int numBSTNodes = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
-	numBricksTree_ = numOTNodes * numBSTNodes;
-	LDEBUG("Num OT levels: " << numOTLevels);
-	LDEBUG("Num OT nodes: " << numOTNodes);
-	LDEBUG("Num BST nodes: " << numBSTNodes);
-	LDEBUG("Num bricks in tree: " << numBricksTree_);
-	LDEBUG("Num values per brick: " << numBrickVals_);
+    // Calculate number of bricks in tree
+    unsigned int numOTLevels = static_cast<unsigned int>(log((int)numBricks_) / log(2) + 1);
+    unsigned int numOTNodes = static_cast<unsigned int>((pow(8, numOTLevels) - 1) / 7);
+    unsigned int numBSTNodes = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
+    numBricksTree_ = numOTNodes * numBSTNodes;
+    LDEBUG("Num OT levels: " << numOTLevels);
+    LDEBUG("Num OT nodes: " << numOTNodes);
+    LDEBUG("Num BST nodes: " << numBSTNodes);
+    LDEBUG("Num bricks in tree: " << numBricksTree_);
+    LDEBUG("Num values per brick: " << numBrickVals_);
 
-	brickSize_ = sizeof(float)*numBrickVals_;
-	volumeSize_ = brickSize_*numBricksFrame_;
-	numValsTot_ = numBrickVals_*numBricksFrame_;
+    brickSize_ = sizeof(float)*numBrickVals_;
+    volumeSize_ = brickSize_*numBricksFrame_;
+    numValsTot_ = numBrickVals_*numBricksFrame_;
 
-	_tsp->file().seekg(0, _tsp->file().end);
-	long long fileSize = _tsp->file().tellg();
-	long long calcFileSize = static_cast<long long>(numBricksTree_)*
-		static_cast<long long>(brickSize_) + TSP::dataPosition();
+    _tsp->file().seekg(0, _tsp->file().end);
+    long long fileSize = _tsp->file().tellg();
+    long long calcFileSize = static_cast<long long>(numBricksTree_)*
+        static_cast<long long>(brickSize_) + TSP::dataPosition();
 
 
-	if (fileSize != calcFileSize) {
-		LERROR("Sizes don't match");
-		LERROR("calculated file size: " << calcFileSize);
-		LERROR("file size: " << fileSize);
-		return false;
-	}
+    if (fileSize != calcFileSize) {
+        LERROR("Sizes don't match");
+        LERROR("calculated file size: " << calcFileSize);
+        LERROR("file size: " << fileSize);
+        return false;
+    }
 
-	hasReadHeader_ = true;
+    hasReadHeader_ = true;
 
-	// Hold two brick lists
-	brickLists_.resize(2);
-	// Make sure the brick list can hold the maximum number of bricks
-	// Each entry holds tree coordinates
-	brickLists_[EVEN].resize(numBricksTree_ * 3, -1);
-	brickLists_[ODD].resize(numBricksTree_ * 3, -1);
+    // Hold two brick lists
+    brickLists_.resize(2);
+    // Make sure the brick list can hold the maximum number of bricks
+    // Each entry holds tree coordinates
+    brickLists_[EVEN].resize(numBricksTree_ * 3, -1);
+    brickLists_[ODD].resize(numBricksTree_ * 3, -1);
 
-	// Allocate space for keeping tracks of bricks in PBO
-	bricksInPBO_.resize(2);
-	bricksInPBO_[EVEN].resize(numBricksTree_, -1);
-	bricksInPBO_[ODD].resize(numBricksTree_, -1);
+    // Allocate space for keeping tracks of bricks in PBO
+    bricksInPBO_.resize(2);
+    bricksInPBO_[EVEN].resize(numBricksTree_, -1);
+    bricksInPBO_[ODD].resize(numBricksTree_, -1);
 
-	// Allocate space for keeping track of the used coordinates in atlas
-	usedCoords_.resize(2);
-	usedCoords_[EVEN].resize(numBricksFrame_, false);
-	usedCoords_[ODD].resize(numBricksFrame_, false);
+    // Allocate space for keeping track of the used coordinates in atlas
+    usedCoords_.resize(2);
+    usedCoords_[EVEN].resize(numBricksFrame_, false);
+    usedCoords_[ODD].resize(numBricksFrame_, false);
 
-	return true;
+    return true;
 }
 
 bool BrickManager::initialize() {
-	if (atlasInitialized_) {
-		LWARNING("InitAtlas() - already initialized");
-	}
+    if (atlasInitialized_) {
+        LWARNING("InitAtlas() - already initialized");
+    }
 
-	if (!hasReadHeader_) {
-		LWARNING("InitAtlas() - Has not read header, trying to read");
-		return readHeader();
-	}
+    if (!hasReadHeader_) {
+        LWARNING("InitAtlas() - Has not read header, trying to read");
+        return readHeader();
+    }
 
-	// Prepare the 3D texture
-	std::vector<unsigned int> dims;
-	dims.push_back(atlasDim_);
-	dims.push_back(atlasDim_);
-	dims.push_back(atlasDim_);
-	textureAtlas_ = new ghoul::opengl::Texture(
-		glm::size3_t(atlasDim_, atlasDim_, atlasDim_), 
-		ghoul::opengl::Texture::Format::RGBA, 
-		GL_RGBA, 
-		GL_FLOAT);
-	textureAtlas_->uploadTexture();
-	//textureAtlas_ = Texture3D::New(dims);
+    // Prepare the 3D texture
+    std::vector<unsigned int> dims;
+    dims.push_back(atlasDim_);
+    dims.push_back(atlasDim_);
+    dims.push_back(atlasDim_);
+    textureAtlas_ = new ghoul::opengl::Texture(
+        glm::size3_t(atlasDim_, atlasDim_, atlasDim_), 
+        ghoul::opengl::Texture::Format::RGBA, 
+        GL_RGBA, 
+        GL_FLOAT);
+    textureAtlas_->uploadTexture();
+    //textureAtlas_ = Texture3D::New(dims);
 
-	//if (!textureAtlas_->Init()) return false;
+    //if (!textureAtlas_->Init()) return false;
 
-	atlasInitialized_ = true;
+    atlasInitialized_ = true;
 
 
-	glGenBuffers(2, pboHandle_);
+    glGenBuffers(2, pboHandle_);
 
-	return true;
+    return true;
 }
 
 bool BrickManager::BuildBrickList(BUFFER_INDEX _bufIdx,
-	std::vector<int> &_brickRequest) {
+    std::vector<int> &_brickRequest) {
 
-	// Keep track of number bricks used and number of bricks cached
-	// (for benchmarking)
-	int numBricks = 0;
-	int numCached = 0;
+    // Keep track of number bricks used and number of bricks cached
+    // (for benchmarking)
+    int numBricks = 0;
+    int numCached = 0;
 
-	// For every non-zero entry in the request list, assign a texture atlas
-	// coordinate. For zero entries, signal "no brick" using -1.
+    // For every non-zero entry in the request list, assign a texture atlas
+    // coordinate. For zero entries, signal "no brick" using -1.
 
-	for (unsigned int i = 0; i<_brickRequest.size(); ++i) {
+    for (unsigned int i = 0; i<_brickRequest.size(); ++i) {
 
-		if (_brickRequest[i] > 0) {
+        if (_brickRequest[i] > 0) {
 
-			numBricks++;
+            numBricks++;
 
-			//INFO("Checking brick " << i);
+            //INFO("Checking brick " << i);
 
-			// If the brick is already in the atlas, keep the coordinate
-			if (bricksInPBO_[_bufIdx][i] != -1) {
+            // If the brick is already in the atlas, keep the coordinate
+            if (bricksInPBO_[_bufIdx][i] != -1) {
 
-				numCached++;
+                numCached++;
 
-				// Get the corresponding coordinates from index
-				int x, y, z;
-				CoordsFromLin(bricksInPBO_[_bufIdx][i], x, y, z);
-				brickLists_[_bufIdx][3 * i + 0] = x;
-				brickLists_[_bufIdx][3 * i + 1] = y;
-				brickLists_[_bufIdx][3 * i + 2] = z;
+                // Get the corresponding coordinates from index
+                int x, y, z;
+                CoordsFromLin(bricksInPBO_[_bufIdx][i], x, y, z);
+                brickLists_[_bufIdx][3 * i + 0] = x;
+                brickLists_[_bufIdx][3 * i + 1] = y;
+                brickLists_[_bufIdx][3 * i + 2] = z;
 
-				// Mark coordinate as used
-				usedCoords_[_bufIdx][bricksInPBO_[_bufIdx][i]] = true;
+                // Mark coordinate as used
+                usedCoords_[_bufIdx][bricksInPBO_[_bufIdx][i]] = true;
 
-			}
-			else {
+            }
+            else {
 
-				// If coord is already usedi by another brick, 
-				// skip it and try the next one
-				while (usedCoords_[_bufIdx][LinearCoord(xCoord_, yCoord_, zCoord_)]) {
-					IncCoord();
-				}
+                // If coord is already usedi by another brick, 
+                // skip it and try the next one
+                while (usedCoords_[_bufIdx][LinearCoord(xCoord_, yCoord_, zCoord_)]) {
+                    IncCoord();
+                }
 
-				brickLists_[_bufIdx][3 * i + 0] = xCoord_;
-				brickLists_[_bufIdx][3 * i + 1] = yCoord_;
-				brickLists_[_bufIdx][3 * i + 2] = zCoord_;
-				usedCoords_[_bufIdx][LinearCoord(xCoord_, yCoord_, zCoord_)] = true;
+                brickLists_[_bufIdx][3 * i + 0] = xCoord_;
+                brickLists_[_bufIdx][3 * i + 1] = yCoord_;
+                brickLists_[_bufIdx][3 * i + 2] = zCoord_;
+                usedCoords_[_bufIdx][LinearCoord(xCoord_, yCoord_, zCoord_)] = true;
 
-				IncCoord();
-			}
+                IncCoord();
+            }
 
 
-		}
-		else {
+        }
+        else {
 
-			// -1 is for "not used"
-			brickLists_[_bufIdx][3 * i + 0] = -1;
-			brickLists_[_bufIdx][3 * i + 1] = -1;
-			brickLists_[_bufIdx][3 * i + 2] = -1;
+            // -1 is for "not used"
+            brickLists_[_bufIdx][3 * i + 0] = -1;
+            brickLists_[_bufIdx][3 * i + 1] = -1;
+            brickLists_[_bufIdx][3 * i + 2] = -1;
 
-		}
+        }
 
-		// Reset brick list during iteration
-		_brickRequest[i] = 0;
+        // Reset brick list during iteration
+        _brickRequest[i] = 0;
 
-	}
+    }
 
 
-	// Brick list is build, reset coordinate list
-	for (auto it = usedCoords_[_bufIdx].begin();
-		it != usedCoords_[_bufIdx].end(); ++it) {
-		*it = false;
-	}
+    // Brick list is build, reset coordinate list
+    for (auto it = usedCoords_[_bufIdx].begin();
+        it != usedCoords_[_bufIdx].end(); ++it) {
+        *it = false;
+    }
 
-	//INFO("bricks NOT used: " << (float)(numBricksFrame_-numBricks) / (float)(numBricksFrame_));
-	//INFO("bricks cached: " << (float)numCached / (float)(numBricksFrame_));
+    //INFO("bricks NOT used: " << (float)(numBricksFrame_-numBricks) / (float)(numBricksFrame_));
+    //INFO("bricks cached: " << (float)numCached / (float)(numBricksFrame_));
 
-	return true;
+    return true;
 }
 
 bool BrickManager::FillVolume(float *_in, float *_out,
-	unsigned int _x,
-	unsigned int _y,
-	unsigned int _z) {
+    unsigned int _x,
+    unsigned int _y,
+    unsigned int _z) {
 
-	//timer_.start();
-	unsigned int xMin = _x*paddedBrickDim_;
-	unsigned int yMin = _y*paddedBrickDim_;
-	unsigned int zMin = _z*paddedBrickDim_;
-	unsigned int xMax = xMin + paddedBrickDim_;
-	unsigned int yMax = yMin + paddedBrickDim_;
-	unsigned int zMax = zMin + paddedBrickDim_;
+    //timer_.start();
+    unsigned int xMin = _x*paddedBrickDim_;
+    unsigned int yMin = _y*paddedBrickDim_;
+    unsigned int zMin = _z*paddedBrickDim_;
+    unsigned int xMax = xMin + paddedBrickDim_;
+    unsigned int yMax = yMin + paddedBrickDim_;
+    unsigned int zMax = zMin + paddedBrickDim_;
 
-	// Loop over the brick using three loops
-	unsigned int from = 0;
-	for (unsigned int zValCoord = zMin; zValCoord<zMax; ++zValCoord) {
-		for (unsigned int yValCoord = yMin; yValCoord<yMax; ++yValCoord) {
-			for (unsigned int xValCoord = xMin; xValCoord<xMax; ++xValCoord) {
+    // Loop over the brick using three loops
+    unsigned int from = 0;
+    for (unsigned int zValCoord = zMin; zValCoord<zMax; ++zValCoord) {
+        for (unsigned int yValCoord = yMin; yValCoord<yMax; ++yValCoord) {
+            for (unsigned int xValCoord = xMin; xValCoord<xMax; ++xValCoord) {
 
-				unsigned int idx =
-					xValCoord +
-					yValCoord*atlasDim_ +
-					zValCoord*atlasDim_*atlasDim_;
+                unsigned int idx =
+                    xValCoord +
+                    yValCoord*atlasDim_ +
+                    zValCoord*atlasDim_*atlasDim_;
 
-				_out[idx] = _in[from];
-				from++;
-			}
-		}
-	}
-	return true;
+                _out[idx] = _in[from];
+                from++;
+            }
+        }
+    }
+    return true;
 }
 
 void BrickManager::IncCoord() {
-	// Update atlas coordinate
-	xCoord_++;
-	if (xCoord_ == _header.xNumBricks_) {
-		xCoord_ = 0;
-		yCoord_++;
-		if (yCoord_ == _header.yNumBricks_) {
-			yCoord_ = 0;
-			zCoord_++;
-			if (zCoord_ == _header.zNumBricks_) {
-				zCoord_ = 0;
-			}
-		}
-	}
+    // Update atlas coordinate
+    xCoord_++;
+    if (xCoord_ == _header.xNumBricks_) {
+        xCoord_ = 0;
+        yCoord_++;
+        if (yCoord_ == _header.yNumBricks_) {
+            yCoord_ = 0;
+            zCoord_++;
+            if (zCoord_ == _header.zNumBricks_) {
+                zCoord_ = 0;
+            }
+        }
+    }
 }
 
 unsigned int BrickManager::LinearCoord(int _x, int _y, int _z) {
-	return _x + _y*_header.xNumBricks_ + _z*_header.xNumBricks_*_header.yNumBricks_;
+    return _x + _y*_header.xNumBricks_ + _z*_header.xNumBricks_*_header.yNumBricks_;
 }
 
 void BrickManager::CoordsFromLin(int _idx, int &_x, int &_y, int &_z) {
-	_x = _idx % _header.xNumBricks_;
-	_idx /= _header.xNumBricks_;
-	_y = _idx % _header.yNumBricks_;
-	_idx /= _header.yNumBricks_;
-	_z = _idx;
+    _x = _idx % _header.xNumBricks_;
+    _idx /= _header.xNumBricks_;
+    _y = _idx % _header.yNumBricks_;
+    _idx /= _header.yNumBricks_;
+    _z = _idx;
 }
 
 
 bool BrickManager::DiskToPBO(BUFFER_INDEX _pboIndex) {
 
-	// Map PBO
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboHandle_[_pboIndex]);
-	glBufferData(GL_PIXEL_UNPACK_BUFFER, volumeSize_, 0, GL_STREAM_DRAW);
-	float *mappedBuffer = reinterpret_cast<float*>(
-		glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
+    // Map PBO
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboHandle_[_pboIndex]);
+    glBufferData(GL_PIXEL_UNPACK_BUFFER, volumeSize_, 0, GL_STREAM_DRAW);
+    float *mappedBuffer = reinterpret_cast<float*>(
+        glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY));
 
-	if (!mappedBuffer) {
-		LERROR("Failed to map PBO");
-		return false;
-	}
+    if (!mappedBuffer) {
+        LERROR("Failed to map PBO");
+        return false;
+    }
 
-	// Loop over brick request list
-	unsigned int brickIndex = 0;
-	while (brickIndex < brickLists_[_pboIndex].size() / 3) {
+    // Loop over brick request list
+    unsigned int brickIndex = 0;
+    while (brickIndex < brickLists_[_pboIndex].size() / 3) {
 
-		// Find first active brick index in list
-		while (brickIndex<brickLists_[_pboIndex].size() / 3 &&
-			brickLists_[_pboIndex][3 * brickIndex] == -1) {
-			// If not used, remove from PBO cache list
-			bricksInPBO_[_pboIndex][brickIndex] = -1;
-			brickIndex++;
-		}
+        // Find first active brick index in list
+        while (brickIndex<brickLists_[_pboIndex].size() / 3 &&
+            brickLists_[_pboIndex][3 * brickIndex] == -1) {
+            // If not used, remove from PBO cache list
+            bricksInPBO_[_pboIndex][brickIndex] = -1;
+            brickIndex++;
+        }
 
-		// If we are at the end of the list, exit
-		if (brickIndex == brickLists_[_pboIndex].size() / 3) {
-			break;
-		}
+        // If we are at the end of the list, exit
+        if (brickIndex == brickLists_[_pboIndex].size() / 3) {
+            break;
+        }
 
-		// Find a sequence of consecutive bricks in list
-		unsigned int sequence = 0;
-		// Count number of bricks already in PBO
-		unsigned int inPBO = 0;
-		unsigned int brickIndexProbe = brickIndex;
-		while (brickIndexProbe < brickLists_[_pboIndex].size() / 3 &&
-			brickLists_[_pboIndex][3 * brickIndexProbe] != -1) {
-			sequence++;
-			if (bricksInPBO_[_pboIndex][brickIndexProbe] != -1) {
-				inPBO++;
-			}
-			brickIndexProbe++;
-		}
-		//INFO("Reading " << sequence << " bricks");
+        // Find a sequence of consecutive bricks in list
+        unsigned int sequence = 0;
+        // Count number of bricks already in PBO
+        unsigned int inPBO = 0;
+        unsigned int brickIndexProbe = brickIndex;
+        while (brickIndexProbe < brickLists_[_pboIndex].size() / 3 &&
+            brickLists_[_pboIndex][3 * brickIndexProbe] != -1) {
+            sequence++;
+            if (bricksInPBO_[_pboIndex][brickIndexProbe] != -1) {
+                inPBO++;
+            }
+            brickIndexProbe++;
+        }
+        //INFO("Reading " << sequence << " bricks");
 
-		// Read the sequence into a buffer
-		float *seqBuffer = new float[sequence*numBrickVals_];
-		size_t bufSize = sequence*numBrickVals_*sizeof(float);
-		/*
-		std::ios::pos_type offset = dataPos_ +
-		static_cast<std::ios::pos_type>(brickIndex) *
-		static_cast<std::ios::pos_type>(brickSize_);
-		*/
+        // Read the sequence into a buffer
+        float *seqBuffer = new float[sequence*numBrickVals_];
+        size_t bufSize = sequence*numBrickVals_*sizeof(float);
+        /*
+        std::ios::pos_type offset = dataPos_ +
+        static_cast<std::ios::pos_type>(brickIndex) *
+        static_cast<std::ios::pos_type>(brickSize_);
+        */
 
-		long offset = TSP::dataPosition() +
-			static_cast<long>(brickIndex)*
-			static_cast<long>(brickSize_);
+        long offset = TSP::dataPosition() +
+            static_cast<long>(brickIndex)*
+            static_cast<long>(brickSize_);
 
-		// Skip reading if all bricks in sequence is already in PBO
-		if (inPBO != sequence) {
+        // Skip reading if all bricks in sequence is already in PBO
+        if (inPBO != sequence) {
 
-			//timer_.start();
+            //timer_.start();
 
-			/*
-			std::streamoff off = static_cast<std::streamoff>(offset);
-			in_.seekg(off);
-			if (in_.tellg() == -1) {
-			ERROR("Failed to get input stream position");
-			INFO("offset: " << offset);
-			INFO("streamoff max: " << std::numeric_limits<std::streamoff>::max());
-			INFO("size_t max: " << std::numeric_limits<size_t>::max());
-			return false;
-			}
-			INFO("in.tellg(): " << in_.tellg());
-			in_.read(reinterpret_cast<char*>(seqBuffer), brickSize_*sequence);
-			*/
+            /*
+            std::streamoff off = static_cast<std::streamoff>(offset);
+            in_.seekg(off);
+            if (in_.tellg() == -1) {
+            ERROR("Failed to get input stream position");
+            INFO("offset: " << offset);
+            INFO("streamoff max: " << std::numeric_limits<std::streamoff>::max());
+            INFO("size_t max: " << std::numeric_limits<size_t>::max());
+            return false;
+            }
+            INFO("in.tellg(): " << in_.tellg());
+            in_.read(reinterpret_cast<char*>(seqBuffer), brickSize_*sequence);
+            */
 
-			_tsp->file().seekg(offset);
-			_tsp->file().read(reinterpret_cast<char*>(seqBuffer), bufSize);
+            _tsp->file().seekg(offset);
+            _tsp->file().read(reinterpret_cast<char*>(seqBuffer), bufSize);
 
 
-			//timer_.stop();
-			//double time = timer_.elapsed().wall / 1.0e9;
-			//double mb = (brickSize_*sequence) / 1048576.0;
-			//INFO("Disk read "<<mb<<" MB in "<<time<<" s, "<< mb/time<<" MB/s");
+            //timer_.stop();
+            //double time = timer_.elapsed().wall / 1.0e9;
+            //double mb = (brickSize_*sequence) / 1048576.0;
+            //INFO("Disk read "<<mb<<" MB in "<<time<<" s, "<< mb/time<<" MB/s");
 
-			// For each brick in the buffer, put it the correct buffer spot
-			for (unsigned int i = 0; i<sequence; ++i) {
+            // For each brick in the buffer, put it the correct buffer spot
+            for (unsigned int i = 0; i<sequence; ++i) {
 
 
-				// Only upload if needed
-				// Pointless if implementation only skips reading when ALL bricks in
-				// sequence are in PBO, but could be useful if other solutions that
-				// considers part of the buffer are implemented
-				if (bricksInPBO_[_pboIndex][brickIndex + i] == -1) {
+                // Only upload if needed
+                // Pointless if implementation only skips reading when ALL bricks in
+                // sequence are in PBO, but could be useful if other solutions that
+                // considers part of the buffer are implemented
+                if (bricksInPBO_[_pboIndex][brickIndex + i] == -1) {
 
-					unsigned int x = static_cast<unsigned int>(
-						brickLists_[_pboIndex][3 * (brickIndex + i) + 0]);
-					unsigned int y = static_cast<unsigned int>(
-						brickLists_[_pboIndex][3 * (brickIndex + i) + 1]);
-					unsigned int z = static_cast<unsigned int>(
-						brickLists_[_pboIndex][3 * (brickIndex + i) + 2]);
+                    unsigned int x = static_cast<unsigned int>(
+                        brickLists_[_pboIndex][3 * (brickIndex + i) + 0]);
+                    unsigned int y = static_cast<unsigned int>(
+                        brickLists_[_pboIndex][3 * (brickIndex + i) + 1]);
+                    unsigned int z = static_cast<unsigned int>(
+                        brickLists_[_pboIndex][3 * (brickIndex + i) + 2]);
 
-					// Put each brick in the correct buffer place.
-					// This needs to be done because the values are in brick order, and
-					// the volume needs to be filled with one big float array.
-					FillVolume(&seqBuffer[numBrickVals_*i], mappedBuffer, x, y, z);
-					// Update the atlas list since the brick will be uploaded
-					//INFO(brickIndex+i);
-					bricksInPBO_[_pboIndex][brickIndex + i] = LinearCoord(x, y, z);
+                    // Put each brick in the correct buffer place.
+                    // This needs to be done because the values are in brick order, and
+                    // the volume needs to be filled with one big float array.
+                    FillVolume(&seqBuffer[numBrickVals_*i], mappedBuffer, x, y, z);
+                    // Update the atlas list since the brick will be uploaded
+                    //INFO(brickIndex+i);
+                    bricksInPBO_[_pboIndex][brickIndex + i] = LinearCoord(x, y, z);
 
-				}
-			}
+                }
+            }
 
-			delete[] seqBuffer;
+            delete[] seqBuffer;
 
-		} // if in pbo
+        } // if in pbo
 
-		// Update the brick index
-		brickIndex += sequence;
+        // Update the brick index
+        brickIndex += sequence;
 
-	}
+    }
 
-	glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-	return true;
+    return true;
 }
 
 bool BrickManager::PBOToAtlas(BUFFER_INDEX _pboIndex) {
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboHandle_[_pboIndex]);
-	glm::size3_t dim = textureAtlas_->dimensions();
-	glBindTexture(GL_TEXTURE_3D, *textureAtlas_);
-	glTexSubImage3D(GL_TEXTURE_3D,	// target
-		0,							// level
-		0,							// xoffset
-		0,							// yoffset
-		0,							// zoffset
-		dim[0],						// width
-		dim[1],						// height
-		dim[2],						// depth
-		GL_RED,						// format
-		GL_FLOAT,					// type
-		NULL);						// *pixels
-	glBindTexture(GL_TEXTURE_3D, 0);
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pboHandle_[_pboIndex]);
+    glm::size3_t dim = textureAtlas_->dimensions();
+    glBindTexture(GL_TEXTURE_3D, *textureAtlas_);
+    glTexSubImage3D(GL_TEXTURE_3D,    // target
+        0,                            // level
+        0,                            // xoffset
+        0,                            // yoffset
+        0,                            // zoffset
+        dim[0],                        // width
+        dim[1],                        // height
+        dim[2],                        // depth
+        GL_RED,                        // format
+        GL_FLOAT,                    // type
+        NULL);                        // *pixels
+    glBindTexture(GL_TEXTURE_3D, 0);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-	return true;
+    return true;
 }
 
 ghoul::opengl::Texture* BrickManager::textureAtlas() {
-	return textureAtlas_;
+    return textureAtlas_;
 }
 
 unsigned int BrickManager::pbo(BUFFER_INDEX _pboIndex) {
-	return pboHandle_[_pboIndex];
+    return pboHandle_[_pboIndex];
 }
 
 const std::vector<int>& BrickManager::brickList(BUFFER_INDEX index) const {
-	return brickLists_.at(index);
+    return brickLists_.at(index);
 }
 
 }
diff --git a/modules/multiresvolume/rendering/brickmanager.h b/modules/multiresvolume/rendering/brickmanager.h
index 171d0983b7..ddc72c49a1 100644
--- a/modules/multiresvolume/rendering/brickmanager.h
+++ b/modules/multiresvolume/rendering/brickmanager.h
@@ -31,79 +31,79 @@
 #include <vector>
 
 namespace ghoul {
-	namespace opengl {
-		class Texture;
-	}
+    namespace opengl {
+        class Texture;
+    }
 }
 
 namespace openspace {
 
 class BrickManager {
 public:
-	enum BUFFER_INDEX { EVEN = 0, ODD = 1 };
+    enum BUFFER_INDEX { EVEN = 0, ODD = 1 };
 
-	BrickManager(TSP* tsp);
-	~BrickManager();
+    BrickManager(TSP* tsp);
+    ~BrickManager();
 
-	bool readHeader();
+    bool readHeader();
 
-	bool initialize(); 
+    bool initialize(); 
 
-	bool BuildBrickList(BUFFER_INDEX _bufIdx, std::vector<int> &_brickRequest);
+    bool BuildBrickList(BUFFER_INDEX _bufIdx, std::vector<int> &_brickRequest);
 
-	bool FillVolume(float *_in, float *_out,
-		unsigned int _x,
-		unsigned int _y,
-		unsigned int _z);
-	bool DiskToPBO(BUFFER_INDEX _pboIndex);
-	bool PBOToAtlas(BUFFER_INDEX _pboIndex);
+    bool FillVolume(float *_in, float *_out,
+        unsigned int _x,
+        unsigned int _y,
+        unsigned int _z);
+    bool DiskToPBO(BUFFER_INDEX _pboIndex);
+    bool PBOToAtlas(BUFFER_INDEX _pboIndex);
 
-	ghoul::opengl::Texture* textureAtlas();
-	unsigned int pbo(BUFFER_INDEX _pboIndex);
-	const std::vector<int>& brickList(BUFFER_INDEX index) const;
+    ghoul::opengl::Texture* textureAtlas();
+    unsigned int pbo(BUFFER_INDEX _pboIndex);
+    const std::vector<int>& brickList(BUFFER_INDEX index) const;
 
 private:
 
-	void IncCoord();
-	unsigned int LinearCoord(int _x, int _y, int _z);
-	void CoordsFromLin(int _idx, int &_x, int &_y, int &_z);
+    void IncCoord();
+    unsigned int LinearCoord(int _x, int _y, int _z);
+    void CoordsFromLin(int _idx, int &_x, int &_y, int &_z);
 
-	TSP* _tsp;
-	TSP::Header _header;
+    TSP* _tsp;
+    TSP::Header _header;
 
-	unsigned int numBricks_;
-	unsigned int brickDim_;
-	unsigned int paddedBrickDim_;
-	unsigned int atlasDim_;
+    unsigned int numBricks_;
+    unsigned int brickDim_;
+    unsigned int paddedBrickDim_;
+    unsigned int atlasDim_;
 
-	const unsigned int paddingWidth_ = 1;
+    const unsigned int paddingWidth_ = 1;
 
-	unsigned int numBrickVals_;
-	unsigned int numBricksFrame_;
-	unsigned int numBricksTree_;
-	unsigned int brickSize_;
-	unsigned int volumeSize_;
-	unsigned int numValsTot_;
+    unsigned int numBrickVals_;
+    unsigned int numBricksFrame_;
+    unsigned int numBricksTree_;
+    unsigned int brickSize_;
+    unsigned int volumeSize_;
+    unsigned int numValsTot_;
 
-	// Texture coordinates to be assigned
-	int xCoord_;
-	int yCoord_;
-	int zCoord_;
+    // Texture coordinates to be assigned
+    int xCoord_;
+    int yCoord_;
+    int zCoord_;
 
-	// Texture where the actual atlas is kept
-	ghoul::opengl::Texture* textureAtlas_;
+    // Texture where the actual atlas is kept
+    ghoul::opengl::Texture* textureAtlas_;
 
-	std::vector<std::vector<int> > brickLists_;
+    std::vector<std::vector<int> > brickLists_;
 
-	bool hasReadHeader_;
-	bool atlasInitialized_;
+    bool hasReadHeader_;
+    bool atlasInitialized_;
 
-	// PBOs
-	unsigned int pboHandle_[2];
+    // PBOs
+    unsigned int pboHandle_[2];
 
-	// Caching, one for each PBO
-	std::vector<std::vector<int> > bricksInPBO_;
-	std::vector<std::vector<bool> > usedCoords_;
+    // Caching, one for each PBO
+    std::vector<std::vector<int> > bricksInPBO_;
+    std::vector<std::vector<bool> > usedCoords_;
 };
 
 } // namespace openspace
diff --git a/modules/multiresvolume/rendering/brickselector.h b/modules/multiresvolume/rendering/brickselector.h
index 1cb8bd33a6..8d99fe5b5e 100644
--- a/modules/multiresvolume/rendering/brickselector.h
+++ b/modules/multiresvolume/rendering/brickselector.h
@@ -32,7 +32,7 @@ namespace openspace {
 class BrickSelector {
 public:
     virtual ~BrickSelector() {};
-	virtual bool initialize() { return true; };
+    virtual bool initialize() { return true; };
     virtual void selectBricks(int timestep,
                       std::vector<int>& bricks) = 0;
 };
diff --git a/modules/multiresvolume/rendering/histogram.cpp b/modules/multiresvolume/rendering/histogram.cpp
index 4f78fab787..57fc8eeb04 100644
--- a/modules/multiresvolume/rendering/histogram.cpp
+++ b/modules/multiresvolume/rendering/histogram.cpp
@@ -72,7 +72,7 @@ Histogram& Histogram::operator=(Histogram&& other) {
     _numBins = other._numBins;
     _data = other._data;
     other._data = nullptr;
-	return *this;
+    return *this;
 }
 
 
diff --git a/modules/multiresvolume/rendering/histogrammanager.cpp b/modules/multiresvolume/rendering/histogrammanager.cpp
index 8a5d8a67b8..ed4d21eefe 100644
--- a/modules/multiresvolume/rendering/histogrammanager.cpp
+++ b/modules/multiresvolume/rendering/histogrammanager.cpp
@@ -132,7 +132,7 @@ std::vector<float> HistogramManager::readValues(TSP* tsp, unsigned int brickInde
 bool HistogramManager::loadFromFile(const std::string& filename) {
     std::ifstream file(filename, std::ios::in | std::ios::binary);
     if (!file.is_open()) {
-	return false;
+    return false;
     }
 
     int numHistograms;
@@ -148,10 +148,10 @@ bool HistogramManager::loadFromFile(const std::string& filename) {
     _histograms = std::vector<Histogram>(numHistograms);
 
     for (int i = 0; i < numHistograms; ++i) {
-	int offset = i*_numBins;
-	float* data = new float[_numBins];
-	memcpy(data, &histogramData[offset], sizeof(float) * _numBins);
-	_histograms[i] = Histogram(_minBin, _maxBin, _numBins, data);
+    int offset = i*_numBins;
+    float* data = new float[_numBins];
+    memcpy(data, &histogramData[offset], sizeof(float) * _numBins);
+    _histograms[i] = Histogram(_minBin, _maxBin, _numBins, data);
     }
 
     delete[] histogramData;
@@ -164,7 +164,7 @@ bool HistogramManager::loadFromFile(const std::string& filename) {
 bool HistogramManager::saveToFile(const std::string& filename) {
     std::ofstream file(filename, std::ios::out | std::ios::binary);
     if (!file.is_open()) {
-	return false;
+    return false;
     }
 
     int numHistograms = _histograms.size();
@@ -177,8 +177,8 @@ bool HistogramManager::saveToFile(const std::string& filename) {
     float* histogramData = new float[nFloats];
 
     for (int i = 0; i < numHistograms; ++i) {
-	int offset = i*_numBins;
-	memcpy(&histogramData[offset], _histograms[i].data(), sizeof(float) * _numBins);
+    int offset = i*_numBins;
+    memcpy(&histogramData[offset], _histograms[i].data(), sizeof(float) * _numBins);
     }
 
     file.write(reinterpret_cast<char*>(histogramData), sizeof(float) * nFloats);
diff --git a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
index c05bd712be..4a5ffacf32 100644
--- a/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
+++ b/modules/multiresvolume/rendering/renderablemultiresvolume.cpp
@@ -154,7 +154,7 @@ RenderableMultiresVolume::RenderableMultiresVolume (const ghoul::Dictionary& dic
     if (hasTimeData) {
         _loop = false;
     } else {
-	_loop = true;
+    _loop = true;
         LWARNING("Node " << name << " does not provide valid time information. Viewing one image per frame.");
     }
 
diff --git a/modules/multiresvolume/rendering/tfbrickselector.cpp b/modules/multiresvolume/rendering/tfbrickselector.cpp
index dfc53f4cb9..bf7e50c24d 100644
--- a/modules/multiresvolume/rendering/tfbrickselector.cpp
+++ b/modules/multiresvolume/rendering/tfbrickselector.cpp
@@ -99,7 +99,7 @@ void TfBrickSelector::selectBricks(int timestep, std::vector<int>& bricks) {
         if (bs.splitType == BrickSelection::SplitType::Temporal) {
             unsigned int childBrickIndex;
             bool pickRightTimeChild = bs.timestepInRightChild(timestep);
-	    //	    assert(!pickRightTimeChild && "picked right child");
+        //        assert(!pickRightTimeChild && "picked right child");
 
             // On average on the whole time period, splitting this spatial brick in two time steps
             // would generate twice as much streaming. Current number of streams of this spatial brick
@@ -276,11 +276,11 @@ float TfBrickSelector::temporalSplitPoints(unsigned int brickIndex) {
 
     /*if (currentError + 0.001 < splitError) {
         std::cout << "Warning! (TEMPORAL SPLIT) Current error " << currentError << " is smaller than split error " << splitError << "." << std::endl;
-	}*/
+    }*/
     float diff = currentError - splitError;
     if (diff < 0.0) {
-	//std::cout << "local temporal split minimum for brick " << brickIndex << std::endl;
-	diff = -diff;
+    //std::cout << "local temporal split minimum for brick " << brickIndex << std::endl;
+    diff = -diff;
     }
     return diff * 0.5;
 }
@@ -302,12 +302,12 @@ float TfBrickSelector::spatialSplitPoints(unsigned int brickIndex) {
 
     /*if (currentError + 0.001 < splitError) {
         std::cout << "Warning! (SPATIAL SPLIT) Current error " << currentError << " is smaller than split error " << splitError << "." << std::endl;
-	}*/
+    }*/
 
     float diff = currentError - splitError;
     if (diff < 0.0) {
-	//std::cout << "local spatial split minimum for brick " << brickIndex << std::endl;
-	diff = -diff;
+    //std::cout << "local spatial split minimum for brick " << brickIndex << std::endl;
+    diff = -diff;
     }
 
     return diff * 0.125;
diff --git a/modules/multiresvolume/rendering/tsp.cpp b/modules/multiresvolume/rendering/tsp.cpp
index 886f903dbe..49b39f4782 100644
--- a/modules/multiresvolume/rendering/tsp.cpp
+++ b/modules/multiresvolume/rendering/tsp.cpp
@@ -37,601 +37,601 @@
 #include <queue>
 
 namespace {
-	const std::string _loggerCat = "TSP";
+    const std::string _loggerCat = "TSP";
 }
 
 namespace openspace {
 
 TSP::TSP(const std::string& filename)
-	: _filename(filename)
-	, _dataSSBO(0)
-	, paddedBrickDim_(0)
-	, numTotalNodes_(0)
-	, numBSTLevels_(0)
-	, numBSTNodes_(0)
-	, numOTLevels_(0)
-	, numOTNodes_(0)
-	, minSpatialError_(0.0f)
-	, maxSpatialError_(0.0f)
-	, medianSpatialError_(0.0f)
-	, minTemporalError_(0.0f)
-	, maxTemporalError_(0.0f)
-	, medianTemporalError_(0.0f)
+    : _filename(filename)
+    , _dataSSBO(0)
+    , paddedBrickDim_(0)
+    , numTotalNodes_(0)
+    , numBSTLevels_(0)
+    , numBSTNodes_(0)
+    , numOTLevels_(0)
+    , numOTNodes_(0)
+    , minSpatialError_(0.0f)
+    , maxSpatialError_(0.0f)
+    , medianSpatialError_(0.0f)
+    , minTemporalError_(0.0f)
+    , maxTemporalError_(0.0f)
+    , medianTemporalError_(0.0f)
 {
-	_file.open(_filename, std::ios::in | std::ios::binary);
+    _file.open(_filename, std::ios::in | std::ios::binary);
 }
 
 TSP::~TSP() {
-	if (_file.is_open())
-		_file.close();
+    if (_file.is_open())
+        _file.close();
 }
 
 bool TSP::load() {
-	if (!readHeader()) {
-		LERROR("Could not read header");
-		return false;
-	}
+    if (!readHeader()) {
+        LERROR("Could not read header");
+        return false;
+    }
 
-	if (readCache()) {
-	//if (false) {
-		LINFO("Using cache");
-	}
-	else {
-		if (!construct()) {
-			LERROR("Could not construct");
-			return false;
-		}
+    if (readCache()) {
+    //if (false) {
+        LINFO("Using cache");
+    }
+    else {
+        if (!construct()) {
+            LERROR("Could not construct");
+            return false;
+        }
 
-		if (false) {
-			if (!calculateSpatialError()) {
-				LERROR("Could not calculate spatial error");
-				return false;
-			}
-			if (!calculateTemporalError()) {
-				LERROR("Could not calculate temporal error");
-				return false;
-			}
-			if (!writeCache()) {
-				LERROR("Could not write cache");
-				return false;
-			}
-		}
-	}
-	initalizeSSO();
+        if (false) {
+            if (!calculateSpatialError()) {
+                LERROR("Could not calculate spatial error");
+                return false;
+            }
+            if (!calculateTemporalError()) {
+                LERROR("Could not calculate temporal error");
+                return false;
+            }
+            if (!writeCache()) {
+                LERROR("Could not write cache");
+                return false;
+            }
+        }
+    }
+    initalizeSSO();
 
-	return true;
+    return true;
 }
 
 bool TSP::readHeader() {
 
-	if (!_file.good())
-		return false;
+    if (!_file.good())
+        return false;
 
-	_file.seekg(_file.beg);
+    _file.seekg(_file.beg);
 
-	_file.read(reinterpret_cast<char*>(&_header), sizeof(Header));
-	/*
-	file.read(reinterpret_cast<char*>(&gridType_),			sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&numOrigTimesteps_),	sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&numTimesteps_),		sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&xBrickDim_),			sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&yBrickDim_),			sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&zBrickDim_),			sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&xNumBricks_),		sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&yNumBricks_),		sizeof(unsigned int));
-	file.read(reinterpret_cast<char*>(&zNumBricks_),		sizeof(unsigned int));
-	*/
+    _file.read(reinterpret_cast<char*>(&_header), sizeof(Header));
+    /*
+    file.read(reinterpret_cast<char*>(&gridType_),            sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&numOrigTimesteps_),    sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&numTimesteps_),        sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&xBrickDim_),            sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&yBrickDim_),            sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&zBrickDim_),            sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&xNumBricks_),        sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&yNumBricks_),        sizeof(unsigned int));
+    file.read(reinterpret_cast<char*>(&zNumBricks_),        sizeof(unsigned int));
+    */
 
-	LDEBUG("Grid type: " << _header.gridType_);
-	LDEBUG("Brick dimensions: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
-	LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
+    LDEBUG("Grid type: " << _header.gridType_);
+    LDEBUG("Brick dimensions: " << _header.xBrickDim_ << " " << _header.yBrickDim_ << " " << _header.zBrickDim_);
+    LDEBUG("Num bricks: " << _header.xNumBricks_ << " " << _header.yNumBricks_ << " " << _header.zNumBricks_);
 
-	paddedBrickDim_ = _header.xBrickDim_ + 2 * paddingWidth_;
-	// TODO support dimensions of different size
-	numOTLevels_ = static_cast<unsigned int>(log((int)_header.xNumBricks_) / log(2) + 1);
-	numOTNodes_ = static_cast<unsigned int>((pow(8, numOTLevels_) - 1) / 7);
-	numBSTLevels_ = static_cast<unsigned int>(log((int)_header.numTimesteps_) / log(2) + 1);
-	numBSTNodes_ = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
-	numTotalNodes_ = numOTNodes_ * numBSTNodes_;
+    paddedBrickDim_ = _header.xBrickDim_ + 2 * paddingWidth_;
+    // TODO support dimensions of different size
+    numOTLevels_ = static_cast<unsigned int>(log((int)_header.xNumBricks_) / log(2) + 1);
+    numOTNodes_ = static_cast<unsigned int>((pow(8, numOTLevels_) - 1) / 7);
+    numBSTLevels_ = static_cast<unsigned int>(log((int)_header.numTimesteps_) / log(2) + 1);
+    numBSTNodes_ = static_cast<unsigned int>(_header.numTimesteps_ * 2 - 1);
+    numTotalNodes_ = numOTNodes_ * numBSTNodes_;
 
-	LDEBUG("Num OT levels: " << numOTLevels_);
-	LDEBUG("Num OT nodes: " << numOTNodes_);
-	LDEBUG("Num BST levels: " << numBSTLevels_);
-	LDEBUG("Num BST nodes: " << numBSTNodes_);
-	LDEBUG("NUm total nodes: " << numTotalNodes_);
+    LDEBUG("Num OT levels: " << numOTLevels_);
+    LDEBUG("Num OT nodes: " << numOTNodes_);
+    LDEBUG("Num BST levels: " << numBSTLevels_);
+    LDEBUG("Num BST nodes: " << numBSTNodes_);
+    LDEBUG("NUm total nodes: " << numTotalNodes_);
 
-	// Allocate space for TSP structure
-	data_.resize(numTotalNodes_*NUM_DATA);
-	LDEBUG("data size: " << data_.size());
+    // Allocate space for TSP structure
+    data_.resize(numTotalNodes_*NUM_DATA);
+    LDEBUG("data size: " << data_.size());
 
-	return true;
+    return true;
 }
 
 bool TSP::construct() {
 
-	LDEBUG("Constructing TSP tree");
+    LDEBUG("Constructing TSP tree");
 
-	// Loop over the OTs (one per BST node)
-	for (unsigned int OT = 0; OT<numBSTNodes_; ++OT) {
+    // Loop over the OTs (one per BST node)
+    for (unsigned int OT = 0; OT<numBSTNodes_; ++OT) {
 
-		// Start at the root of each OT  
-		unsigned int OTNode = OT*numOTNodes_;
+        // Start at the root of each OT  
+        unsigned int OTNode = OT*numOTNodes_;
 
-		// Calculate BST level (first level is level 0)
-		unsigned int BSTLevel = static_cast<unsigned int>(log(OT + 1) / log(2));
+        // Calculate BST level (first level is level 0)
+        unsigned int BSTLevel = static_cast<unsigned int>(log(OT + 1) / log(2));
 
-		// Traverse OT
-		unsigned int OTChild = 1;
-		unsigned int OTLevel = 0;
-		while (OTLevel < numOTLevels_) {
+        // Traverse OT
+        unsigned int OTChild = 1;
+        unsigned int OTLevel = 0;
+        while (OTLevel < numOTLevels_) {
 
-			unsigned int OTNodesInLevel = static_cast<unsigned int>(pow(8, OTLevel));
-			for (unsigned int i = 0; i<OTNodesInLevel; ++i) {
+            unsigned int OTNodesInLevel = static_cast<unsigned int>(pow(8, OTLevel));
+            for (unsigned int i = 0; i<OTNodesInLevel; ++i) {
 
-				// Brick index
-				data_[OTNode*NUM_DATA + BRICK_INDEX] = (int)OTNode;
+                // Brick index
+                data_[OTNode*NUM_DATA + BRICK_INDEX] = (int)OTNode;
 
-				// Error metrics
-				//int localOTNode = (OTNode - OT*numOTNodes_);
-				data_[OTNode*NUM_DATA + TEMPORAL_ERR] = static_cast<int>(numBSTLevels_ - 1 - BSTLevel);
-				data_[OTNode*NUM_DATA + SPATIAL_ERR] = static_cast<int>(numOTLevels_ - 1 - OTLevel);
+                // Error metrics
+                //int localOTNode = (OTNode - OT*numOTNodes_);
+                data_[OTNode*NUM_DATA + TEMPORAL_ERR] = static_cast<int>(numBSTLevels_ - 1 - BSTLevel);
+                data_[OTNode*NUM_DATA + SPATIAL_ERR] = static_cast<int>(numOTLevels_ - 1 - OTLevel);
 
-				if (BSTLevel == 0) {
-					// Calculate OT child index (-1 if node is leaf)
-					int OTChildIndex =
-						(OTChild < numOTNodes_) ? static_cast<int>(OT*numOTNodes_ + OTChild) : -1;
-					data_[OTNode*NUM_DATA + CHILD_INDEX] = OTChildIndex;
-				}
-				else {
-					// Calculate BST child index (-1 if node is BST leaf)
+                if (BSTLevel == 0) {
+                    // Calculate OT child index (-1 if node is leaf)
+                    int OTChildIndex =
+                        (OTChild < numOTNodes_) ? static_cast<int>(OT*numOTNodes_ + OTChild) : -1;
+                    data_[OTNode*NUM_DATA + CHILD_INDEX] = OTChildIndex;
+                }
+                else {
+                    // Calculate BST child index (-1 if node is BST leaf)
 
-					// First BST node of current level
-					int firstNode =
-						static_cast<unsigned int>((2 * pow(2, BSTLevel - 1) - 1)*numOTNodes_);
-					// First BST node of next level
-					int firstChild =
-						static_cast<unsigned int>((2 * pow(2, BSTLevel) - 1)*numOTNodes_);
-					// Difference between first nodes between levels
-					int levelGap = firstChild - firstNode;
-					// How many nodes away from the first node are we?
-					int offset = (OTNode - firstNode) / numOTNodes_;
+                    // First BST node of current level
+                    int firstNode =
+                        static_cast<unsigned int>((2 * pow(2, BSTLevel - 1) - 1)*numOTNodes_);
+                    // First BST node of next level
+                    int firstChild =
+                        static_cast<unsigned int>((2 * pow(2, BSTLevel) - 1)*numOTNodes_);
+                    // Difference between first nodes between levels
+                    int levelGap = firstChild - firstNode;
+                    // How many nodes away from the first node are we?
+                    int offset = (OTNode - firstNode) / numOTNodes_;
 
-					// Use level gap and offset to calculate child index
-					int BSTChildIndex =
-						(BSTLevel < numBSTLevels_ - 1) ?
-						static_cast<int>(OTNode + levelGap + (offset*numOTNodes_)) : -1;
+                    // Use level gap and offset to calculate child index
+                    int BSTChildIndex =
+                        (BSTLevel < numBSTLevels_ - 1) ?
+                        static_cast<int>(OTNode + levelGap + (offset*numOTNodes_)) : -1;
 
-					data_[OTNode*NUM_DATA + CHILD_INDEX] = BSTChildIndex;
-				}
+                    data_[OTNode*NUM_DATA + CHILD_INDEX] = BSTChildIndex;
+                }
 
-				OTNode++;
-				OTChild += 8;
+                OTNode++;
+                OTChild += 8;
 
-			}
+            }
 
-			OTLevel++;
-		}
-	}
-	return true;
+            OTLevel++;
+        }
+    }
+    return true;
 }
 
 bool TSP::initalizeSSO() {
 
-	if (!_dataSSBO)
-		glGenBuffers(1, &_dataSSBO);
+    if (!_dataSSBO)
+        glGenBuffers(1, &_dataSSBO);
 
-	const size_t size = sizeof(GLint)*data_.size();
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, _dataSSBO);
-	//glBufferData(GL_SHADER_STORAGE_BUFFER, size, data_.data(), GL_DYNAMIC_READ);
-	glBufferData(GL_SHADER_STORAGE_BUFFER, size, data_.data(), GL_STATIC_DRAW);
-	glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
-	glFinish();
-	return true;
+    const size_t size = sizeof(GLint)*data_.size();
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, _dataSSBO);
+    //glBufferData(GL_SHADER_STORAGE_BUFFER, size, data_.data(), GL_DYNAMIC_READ);
+    glBufferData(GL_SHADER_STORAGE_BUFFER, size, data_.data(), GL_STATIC_DRAW);
+    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
+    glFinish();
+    return true;
 }
 
 const TSP::Header& TSP::header() const {
-	return _header;
+    return _header;
 }
 
 long long TSP::dataPosition() {
-	return sizeof(Header);
+    return sizeof(Header);
 }
 
 std::ifstream& TSP::file() {
-	return _file;
+    return _file;
 }
 
 unsigned int TSP::numTotalNodes() const { 
-	return numTotalNodes_; 
+    return numTotalNodes_; 
 }
 
 unsigned int TSP::numValuesPerNode() const { 
-	return NUM_DATA; 
+    return NUM_DATA; 
 }
 
 unsigned int TSP::numBSTNodes() const { 
-	return numBSTNodes_; 
+    return numBSTNodes_; 
 }
 
 unsigned int TSP::numBSTLevels() const {
-	return numBSTLevels_;
+    return numBSTLevels_;
 }
 
 unsigned int TSP::numOTNodes() const { 
-	return numOTNodes_; 
+    return numOTNodes_; 
 }
 
 unsigned int TSP::numOTLevels() const { 
-	return numOTLevels_; 
+    return numOTLevels_; 
 }
 
 unsigned int TSP::brickDim() const {
-	return _header.xBrickDim_;
+    return _header.xBrickDim_;
 }
 
 unsigned int TSP::paddedBrickDim() const {
-	return paddedBrickDim_;
+    return paddedBrickDim_;
 }
 
 unsigned int TSP::numBricksPerAxis() const {
-	return _header.xNumBricks_;
+    return _header.xNumBricks_;
 }
 
 GLuint TSP::ssbo() const {
-	return _dataSSBO;
+    return _dataSSBO;
 }
 
 bool TSP::calculateSpatialError() {
-	unsigned int numBrickVals = paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
+    unsigned int numBrickVals = paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
 
-	if (!_file.is_open())
-		return false;
+    if (!_file.is_open())
+        return false;
 
-	std::vector<float> buffer(numBrickVals);
-	std::vector<float> averages(numTotalNodes_);
-	std::vector<float> stdDevs(numTotalNodes_);
+    std::vector<float> buffer(numBrickVals);
+    std::vector<float> averages(numTotalNodes_);
+    std::vector<float> stdDevs(numTotalNodes_);
 
-	// First pass: Calculate average color for each brick
-	LDEBUG("Calculating spatial error, first pass");
-	for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
+    // First pass: Calculate average color for each brick
+    LDEBUG("Calculating spatial error, first pass");
+    for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
 
-		// Offset in file
-		std::streampos offset = dataPosition() + static_cast<long long>(brick*numBrickVals*sizeof(float));
-		_file.seekg(offset);
+        // Offset in file
+        std::streampos offset = dataPosition() + static_cast<long long>(brick*numBrickVals*sizeof(float));
+        _file.seekg(offset);
 
-		_file.read(reinterpret_cast<char*>(&buffer[0]),
-			static_cast<size_t>(numBrickVals)*sizeof(float));
+        _file.read(reinterpret_cast<char*>(&buffer[0]),
+            static_cast<size_t>(numBrickVals)*sizeof(float));
 
-		double average = 0.0;
-		for (auto it = buffer.begin(); it != buffer.end(); ++it) {
-			average += *it;
-		}
+        double average = 0.0;
+        for (auto it = buffer.begin(); it != buffer.end(); ++it) {
+            average += *it;
+        }
 
-		averages[brick] = average / static_cast<double>(numBrickVals);
-	}
+        averages[brick] = average / static_cast<double>(numBrickVals);
+    }
 
-	// Spatial SNR stats
-	float minError = 1e20f;
-	float maxError = 0.f;
-	std::vector<float> medianArray(numTotalNodes_);
+    // Spatial SNR stats
+    float minError = 1e20f;
+    float maxError = 0.f;
+    std::vector<float> medianArray(numTotalNodes_);
 
-	// Second pass: For each brick, compare the covered leaf voxels with
-	// the brick average
-	LDEBUG("Calculating spatial error, second pass");
-	for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
+    // Second pass: For each brick, compare the covered leaf voxels with
+    // the brick average
+    LDEBUG("Calculating spatial error, second pass");
+    for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
 
-		// Fetch mean intensity 
-		float brickAvg = averages[brick];
+        // Fetch mean intensity 
+        float brickAvg = averages[brick];
 
-		// Sum  for std dev computation
-		float stdDev = 0.f;
+        // Sum  for std dev computation
+        float stdDev = 0.f;
 
-		// Get a list of leaf bricks that the current brick covers
-		std::list<unsigned int> coveredLeafBricks =
-			CoveredLeafBricks(brick);
+        // Get a list of leaf bricks that the current brick covers
+        std::list<unsigned int> coveredLeafBricks =
+            CoveredLeafBricks(brick);
 
-		// If the brick is already a leaf, assign a negative error.
-		// Ad hoc "hack" to distinguish leafs from other nodes that happens
-		// to get a zero error due to rounding errors or other reasons.
-		if (coveredLeafBricks.size() == 1) {
-			stdDev = -0.1f;
-		}
-		else {
+        // If the brick is already a leaf, assign a negative error.
+        // Ad hoc "hack" to distinguish leafs from other nodes that happens
+        // to get a zero error due to rounding errors or other reasons.
+        if (coveredLeafBricks.size() == 1) {
+            stdDev = -0.1f;
+        }
+        else {
 
-			// Calculate "standard deviation" corresponding to leaves
-			for (auto lb = coveredLeafBricks.begin();
-				lb != coveredLeafBricks.end(); ++lb) {
+            // Calculate "standard deviation" corresponding to leaves
+            for (auto lb = coveredLeafBricks.begin();
+                lb != coveredLeafBricks.end(); ++lb) {
 
-				// Read brick
-				std::streampos offset = dataPosition() + static_cast<long long>((*lb)*numBrickVals*sizeof(float));
-				_file.seekg(offset);
+                // Read brick
+                std::streampos offset = dataPosition() + static_cast<long long>((*lb)*numBrickVals*sizeof(float));
+                _file.seekg(offset);
 
-				_file.read(reinterpret_cast<char*>(&buffer[0]),
-					static_cast<size_t>(numBrickVals)*sizeof(float));
+                _file.read(reinterpret_cast<char*>(&buffer[0]),
+                    static_cast<size_t>(numBrickVals)*sizeof(float));
 
-				// Add to sum
-				for (auto v = buffer.begin(); v != buffer.end(); ++v) {
-					stdDev += pow(*v - brickAvg, 2.f);
-				}
+                // Add to sum
+                for (auto v = buffer.begin(); v != buffer.end(); ++v) {
+                    stdDev += pow(*v - brickAvg, 2.f);
+                }
 
 
-			}
+            }
 
-			// Finish calculation
-			if (sizeof(float) != sizeof(int)) {
-				LERROR("Float and int sizes don't match, can't reintepret");
-				return false;
-			}
+            // Finish calculation
+            if (sizeof(float) != sizeof(int)) {
+                LERROR("Float and int sizes don't match, can't reintepret");
+                return false;
+            }
 
-			stdDev /= static_cast<float>(coveredLeafBricks.size()*numBrickVals);
-			stdDev = sqrt(stdDev);
+            stdDev /= static_cast<float>(coveredLeafBricks.size()*numBrickVals);
+            stdDev = sqrt(stdDev);
 
-		} // if not leaf
+        } // if not leaf
 
-		if (stdDev < minError) {
-			minError = stdDev;
-		}
-		else if (stdDev > maxError) {
-			maxError = stdDev;
-		}
+        if (stdDev < minError) {
+            minError = stdDev;
+        }
+        else if (stdDev > maxError) {
+            maxError = stdDev;
+        }
 
-		stdDevs[brick] = stdDev;
-		medianArray[brick] = stdDev;
+        stdDevs[brick] = stdDev;
+        medianArray[brick] = stdDev;
 
-	}
+    }
 
-	std::sort(medianArray.begin(), medianArray.end());
-	//float medError = medianArray[medianArray.size()/2];
+    std::sort(medianArray.begin(), medianArray.end());
+    //float medError = medianArray[medianArray.size()/2];
 
-	/*
-	LDEBUG("\nMin spatial std dev: " << minError);
-	LDEBUG("Max spatial std dev: " << maxError);
-	LDEBUG("Median spatial std dev: " << medError);
-	LDEBUG("");
-	*/
+    /*
+    LDEBUG("\nMin spatial std dev: " << minError);
+    LDEBUG("Max spatial std dev: " << maxError);
+    LDEBUG("Median spatial std dev: " << medError);
+    LDEBUG("");
+    */
 
-	// "Normalize" errors
-	float minNorm = 1e20f;
-	float maxNorm = 0.f;
-	for (unsigned int i = 0; i<numTotalNodes_; ++i) {
-		//float normalized = (stdDevs[i]-minError)/(maxError-minError);
-		if (stdDevs[i] > 0.f) {
-			stdDevs[i] = pow(stdDevs[i], 0.5f);
-		}
-		//data_[i*NUM_DATA + SPATIAL_ERR] = *reinterpret_cast<int*>(&stdDevs[i]);
-		data_[i*NUM_DATA + SPATIAL_ERR] = glm::floatBitsToInt(stdDevs[i]);
-		if (stdDevs[i] < minNorm) {
-			minNorm = stdDevs[i];
-		}
-		else if (stdDevs[i] > maxNorm) {
-			maxNorm = stdDevs[i];
-		}
-	}
+    // "Normalize" errors
+    float minNorm = 1e20f;
+    float maxNorm = 0.f;
+    for (unsigned int i = 0; i<numTotalNodes_; ++i) {
+        //float normalized = (stdDevs[i]-minError)/(maxError-minError);
+        if (stdDevs[i] > 0.f) {
+            stdDevs[i] = pow(stdDevs[i], 0.5f);
+        }
+        //data_[i*NUM_DATA + SPATIAL_ERR] = *reinterpret_cast<int*>(&stdDevs[i]);
+        data_[i*NUM_DATA + SPATIAL_ERR] = glm::floatBitsToInt(stdDevs[i]);
+        if (stdDevs[i] < minNorm) {
+            minNorm = stdDevs[i];
+        }
+        else if (stdDevs[i] > maxNorm) {
+            maxNorm = stdDevs[i];
+        }
+    }
 
-	std::sort(stdDevs.begin(), stdDevs.end());
-	float medNorm = stdDevs[stdDevs.size() / 2];
+    std::sort(stdDevs.begin(), stdDevs.end());
+    float medNorm = stdDevs[stdDevs.size() / 2];
 
-	minSpatialError_ = minNorm;
-	maxSpatialError_ = maxNorm;
-	medianSpatialError_ = medNorm;
+    minSpatialError_ = minNorm;
+    maxSpatialError_ = maxNorm;
+    medianSpatialError_ = medNorm;
 
-	LDEBUG("Min normalized spatial std dev: " << minNorm);
-	LDEBUG("Max normalized spatial std dev: " << maxNorm);
-	LDEBUG("Median normalized spatial std dev: " << medNorm);
+    LDEBUG("Min normalized spatial std dev: " << minNorm);
+    LDEBUG("Max normalized spatial std dev: " << maxNorm);
+    LDEBUG("Median normalized spatial std dev: " << medNorm);
 
-	return true;
+    return true;
 }
 
 bool TSP::calculateTemporalError() {
 
-	if (!_file.is_open())
-		return false;
+    if (!_file.is_open())
+        return false;
 
-	LDEBUG("Calculating temporal error");
+    LDEBUG("Calculating temporal error");
 
-	// Statistics
-	//float minErr = 1e20f;
-	//float maxErr = 0.f;
-	std::vector<float> meanArray(numTotalNodes_);
+    // Statistics
+    //float minErr = 1e20f;
+    //float maxErr = 0.f;
+    std::vector<float> meanArray(numTotalNodes_);
 
-	// Save errors
-	std::vector<float> errors(numTotalNodes_);
+    // Save errors
+    std::vector<float> errors(numTotalNodes_);
 
-	// Calculate temporal error for one brick at a time
-	for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
+    // Calculate temporal error for one brick at a time
+    for (unsigned int brick = 0; brick<numTotalNodes_; ++brick) {
 
-		unsigned int numBrickVals =
-			paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
+        unsigned int numBrickVals =
+            paddedBrickDim_*paddedBrickDim_*paddedBrickDim_;
 
-		// Save the individual voxel's average over timesteps. Because the
-		// BSTs are built by averaging leaf nodes, we only need to sample
-		// the brick at the correct coordinate.
-		std::vector<float> voxelAverages(numBrickVals);
-		std::vector<float> voxelStdDevs(numBrickVals);
+        // Save the individual voxel's average over timesteps. Because the
+        // BSTs are built by averaging leaf nodes, we only need to sample
+        // the brick at the correct coordinate.
+        std::vector<float> voxelAverages(numBrickVals);
+        std::vector<float> voxelStdDevs(numBrickVals);
 
-		// Read the whole brick to fill the averages
-		std::streampos offset = dataPosition() + static_cast<long long>(brick*numBrickVals*sizeof(float));
-		_file.seekg(offset);
+        // Read the whole brick to fill the averages
+        std::streampos offset = dataPosition() + static_cast<long long>(brick*numBrickVals*sizeof(float));
+        _file.seekg(offset);
 
-		_file.read(reinterpret_cast<char*>(&voxelAverages[0]),
-			static_cast<size_t>(numBrickVals)*sizeof(float));
+        _file.read(reinterpret_cast<char*>(&voxelAverages[0]),
+            static_cast<size_t>(numBrickVals)*sizeof(float));
 
-		// Build a list of the BST leaf bricks (within the same octree level) that
-		// this brick covers
-		std::list<unsigned int> coveredBricks = CoveredBSTLeafBricks(brick);
+        // Build a list of the BST leaf bricks (within the same octree level) that
+        // this brick covers
+        std::list<unsigned int> coveredBricks = CoveredBSTLeafBricks(brick);
 
-		// If the brick is at the lowest BST level, automatically set the error 
-		// to -0.1 (enables using -1 as a marker for "no error accepted");
-		// Somewhat ad hoc to get around the fact that the error could be
-		// 0.0 higher up in the tree
-		if (coveredBricks.size() == 1) {
-			errors[brick] = -0.1f;
-		} else {
-			// Calculate standard deviation per voxel, average over brick
-			float avgStdDev = 0.f;
-			for (unsigned int voxel = 0; voxel<numBrickVals; ++voxel) {
+        // If the brick is at the lowest BST level, automatically set the error 
+        // to -0.1 (enables using -1 as a marker for "no error accepted");
+        // Somewhat ad hoc to get around the fact that the error could be
+        // 0.0 higher up in the tree
+        if (coveredBricks.size() == 1) {
+            errors[brick] = -0.1f;
+        } else {
+            // Calculate standard deviation per voxel, average over brick
+            float avgStdDev = 0.f;
+            for (unsigned int voxel = 0; voxel<numBrickVals; ++voxel) {
 
-				float stdDev = 0.f;
-				for (auto leaf = coveredBricks.begin();
-					leaf != coveredBricks.end(); ++leaf) {
+                float stdDev = 0.f;
+                for (auto leaf = coveredBricks.begin();
+                    leaf != coveredBricks.end(); ++leaf) {
 
-					// Sample the leaves at the corresponding voxel position
+                    // Sample the leaves at the corresponding voxel position
 
-					std::streampos offset = dataPosition() + static_cast<long long>((*leaf*numBrickVals + voxel)*sizeof(float));
-					_file.seekg(offset);
+                    std::streampos offset = dataPosition() + static_cast<long long>((*leaf*numBrickVals + voxel)*sizeof(float));
+                    _file.seekg(offset);
 
-					float sample;
-					_file.read(reinterpret_cast<char*>(&sample), sizeof(float));
+                    float sample;
+                    _file.read(reinterpret_cast<char*>(&sample), sizeof(float));
 
-					stdDev += pow(sample - voxelAverages[voxel], 2.f);
-				}
-				stdDev /= static_cast<float>(coveredBricks.size());
-				stdDev = sqrt(stdDev);
+                    stdDev += pow(sample - voxelAverages[voxel], 2.f);
+                }
+                stdDev /= static_cast<float>(coveredBricks.size());
+                stdDev = sqrt(stdDev);
 
-				avgStdDev += stdDev;
-			} // for voxel
+                avgStdDev += stdDev;
+            } // for voxel
 
-			avgStdDev /= static_cast<float>(numBrickVals);
-			meanArray[brick] = avgStdDev;
-			errors[brick] = avgStdDev;
+            avgStdDev /= static_cast<float>(numBrickVals);
+            meanArray[brick] = avgStdDev;
+            errors[brick] = avgStdDev;
 
-		}
+        }
 
-		/*
-		if (avgStdDev < minErr) {
-		minErr = avgStdDev;
-		} else if (avgStdDev > maxErr) {
-		maxErr = avgStdDev;
-		}
-		*/
+        /*
+        if (avgStdDev < minErr) {
+        minErr = avgStdDev;
+        } else if (avgStdDev > maxErr) {
+        maxErr = avgStdDev;
+        }
+        */
 
-	} // for all bricks
+    } // for all bricks
 
-	std::sort(meanArray.begin(), meanArray.end());
-	//float medErr = meanArray[meanArray.size()/2];
+    std::sort(meanArray.begin(), meanArray.end());
+    //float medErr = meanArray[meanArray.size()/2];
 
-	/*
-	LDEBUG("\nMin temporal error: " << minErr);
-	LDEBUG("Max temporal error: " << maxErr);
-	LDEBUG("Median temporal error: " << medErr);
-	*/
+    /*
+    LDEBUG("\nMin temporal error: " << minErr);
+    LDEBUG("Max temporal error: " << maxErr);
+    LDEBUG("Median temporal error: " << medErr);
+    */
 
-	// Adjust errors using user-provided exponents
-	float minNorm = 1e20f;
-	float maxNorm = 0.f;
-	for (unsigned int i = 0; i<numTotalNodes_; ++i) {
-		if (errors[i] > 0.f) {
-			errors[i] = pow(errors[i], 0.25f);
-		}
-		//data_[i*NUM_DATA + TEMPORAL_ERR] = *reinterpret_cast<int*>(&errors[i]);
-		data_[i*NUM_DATA + TEMPORAL_ERR] = glm::floatBitsToInt(errors[i]);
-		if (errors[i] < minNorm) {
-			minNorm = errors[i];
-		}
-		else if (errors[i] > maxNorm) {
-			maxNorm = errors[i];
-		}
-	}
+    // Adjust errors using user-provided exponents
+    float minNorm = 1e20f;
+    float maxNorm = 0.f;
+    for (unsigned int i = 0; i<numTotalNodes_; ++i) {
+        if (errors[i] > 0.f) {
+            errors[i] = pow(errors[i], 0.25f);
+        }
+        //data_[i*NUM_DATA + TEMPORAL_ERR] = *reinterpret_cast<int*>(&errors[i]);
+        data_[i*NUM_DATA + TEMPORAL_ERR] = glm::floatBitsToInt(errors[i]);
+        if (errors[i] < minNorm) {
+            minNorm = errors[i];
+        }
+        else if (errors[i] > maxNorm) {
+            maxNorm = errors[i];
+        }
+    }
 
-	std::sort(errors.begin(), errors.end());
-	float medNorm = errors[errors.size() / 2];
+    std::sort(errors.begin(), errors.end());
+    float medNorm = errors[errors.size() / 2];
 
-	minTemporalError_ = minNorm;
-	maxTemporalError_ = maxNorm;
-	medianTemporalError_ = medNorm;
+    minTemporalError_ = minNorm;
+    maxTemporalError_ = maxNorm;
+    medianTemporalError_ = medNorm;
 
-	LDEBUG("Min normalized temporal std dev: " << minNorm);
-	LDEBUG("Max normalized temporal std dev: " << maxNorm);
-	LDEBUG("Median normalized temporal std dev: " << medNorm);
+    LDEBUG("Min normalized temporal std dev: " << minNorm);
+    LDEBUG("Max normalized temporal std dev: " << maxNorm);
+    LDEBUG("Median normalized temporal std dev: " << medNorm);
 
-	return true;
+    return true;
 }
 
 
 bool TSP::readCache() {
 
-	if (!FileSys.cacheManager())
-		return false;
+    if (!FileSys.cacheManager())
+        return false;
 
-	ghoul::filesystem::File f = _filename;
-	std::string cacheFilename = FileSys.cacheManager()->cachedFilename(
+    ghoul::filesystem::File f = _filename;
+    std::string cacheFilename = FileSys.cacheManager()->cachedFilename(
         f.baseName(), "", ghoul::filesystem::CacheManager::Persistent::Yes);
 
-	std::ifstream file(cacheFilename, std::ios::in | std::ios::binary);
-	if (!file.is_open()) {
-		LWARNING("Failed to open " << cacheFilename);
-		return false;
-	}
+    std::ifstream file(cacheFilename, std::ios::in | std::ios::binary);
+    if (!file.is_open()) {
+        LWARNING("Failed to open " << cacheFilename);
+        return false;
+    }
 
 
-	file.read(reinterpret_cast<char*>(&minSpatialError_), sizeof(float));
-	file.read(reinterpret_cast<char*>(&maxSpatialError_), sizeof(float));
-	file.read(reinterpret_cast<char*>(&medianSpatialError_), sizeof(float));
-	file.read(reinterpret_cast<char*>(&minTemporalError_), sizeof(float));
-	file.read(reinterpret_cast<char*>(&maxTemporalError_), sizeof(float));
-	file.read(reinterpret_cast<char*>(&medianTemporalError_), sizeof(float));
-	size_t dataSize = static_cast<size_t>(numTotalNodes_*NUM_DATA)*sizeof(int);
-	file.read(reinterpret_cast<char*>(&data_[0]), dataSize);
-	file.close();
+    file.read(reinterpret_cast<char*>(&minSpatialError_), sizeof(float));
+    file.read(reinterpret_cast<char*>(&maxSpatialError_), sizeof(float));
+    file.read(reinterpret_cast<char*>(&medianSpatialError_), sizeof(float));
+    file.read(reinterpret_cast<char*>(&minTemporalError_), sizeof(float));
+    file.read(reinterpret_cast<char*>(&maxTemporalError_), sizeof(float));
+    file.read(reinterpret_cast<char*>(&medianTemporalError_), sizeof(float));
+    size_t dataSize = static_cast<size_t>(numTotalNodes_*NUM_DATA)*sizeof(int);
+    file.read(reinterpret_cast<char*>(&data_[0]), dataSize);
+    file.close();
 
-	LDEBUG("Cached errors:");
-	LDEBUG("Min spatial error: " << minSpatialError_);
-	LDEBUG("Max spatial error: " << maxSpatialError_);
-	LDEBUG("Median spatial error: " << medianSpatialError_);
-	LDEBUG("Min temporal error: " << minTemporalError_);
-	LDEBUG("Max temporal error: " << maxTemporalError_);
-	LDEBUG("Median temporal error: " << medianTemporalError_);
+    LDEBUG("Cached errors:");
+    LDEBUG("Min spatial error: " << minSpatialError_);
+    LDEBUG("Max spatial error: " << maxSpatialError_);
+    LDEBUG("Median spatial error: " << medianSpatialError_);
+    LDEBUG("Min temporal error: " << minTemporalError_);
+    LDEBUG("Max temporal error: " << maxTemporalError_);
+    LDEBUG("Median temporal error: " << medianTemporalError_);
 
-	return true;
+    return true;
 }
 
 bool TSP::writeCache() {
 
-	if (!FileSys.cacheManager())
-		return false;
+    if (!FileSys.cacheManager())
+        return false;
 
-	ghoul::filesystem::File f = _filename;
-	std::string cacheFilename = FileSys.cacheManager()->cachedFilename(
+    ghoul::filesystem::File f = _filename;
+    std::string cacheFilename = FileSys.cacheManager()->cachedFilename(
         f.baseName(), "", ghoul::filesystem::CacheManager::Persistent::Yes);
 
-	std::ofstream file(cacheFilename, std::ios::out | std::ios::binary);
-	if (!file.is_open()) {
-		LWARNING("Failed to open " << cacheFilename);
-		return false;
-	}
-	LINFO("Writing cache to " << cacheFilename);
+    std::ofstream file(cacheFilename, std::ios::out | std::ios::binary);
+    if (!file.is_open()) {
+        LWARNING("Failed to open " << cacheFilename);
+        return false;
+    }
+    LINFO("Writing cache to " << cacheFilename);
 
 
-	file.write(reinterpret_cast<char*>(&minSpatialError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&maxSpatialError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&medianSpatialError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&minTemporalError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&maxTemporalError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&medianTemporalError_), sizeof(float));
-	file.write(reinterpret_cast<char*>(&data_[0]), data_.size()*sizeof(float));
+    file.write(reinterpret_cast<char*>(&minSpatialError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&maxSpatialError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&medianSpatialError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&minTemporalError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&maxTemporalError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&medianTemporalError_), sizeof(float));
+    file.write(reinterpret_cast<char*>(&data_[0]), data_.size()*sizeof(float));
 
-	file.close();
+    file.close();
 
-	/*
-	LDEBUG("\nData:");
-	for (unsigned i=0; i<data_.size()/NUM_DATA; ++i) {
-	LDEBUG("Brick nr " << i);
-	LDEBUG("Brick index " << data_[i*NUM_DATA + BRICK_INDEX]);
-	LDEBUG("Child index " << data_[i*NUM_DATA + CHILD_INDEX]);
-	LDEBUG("Spatial err " << *reinterpret_cast<float*>(&data_[i*NUM_DATA + SPATIAL_ERR]));
-	LDEBUG("Temporal err " << *reinterpret_cast<float*>(&data_[i*NUM_DATA + TEMPORAL_ERR]));
-	}
-	*/
+    /*
+    LDEBUG("\nData:");
+    for (unsigned i=0; i<data_.size()/NUM_DATA; ++i) {
+    LDEBUG("Brick nr " << i);
+    LDEBUG("Brick index " << data_[i*NUM_DATA + BRICK_INDEX]);
+    LDEBUG("Child index " << data_[i*NUM_DATA + CHILD_INDEX]);
+    LDEBUG("Spatial err " << *reinterpret_cast<float*>(&data_[i*NUM_DATA + SPATIAL_ERR]));
+    LDEBUG("Temporal err " << *reinterpret_cast<float*>(&data_[i*NUM_DATA + TEMPORAL_ERR]));
+    }
+    */
 
-	return true;
+    return true;
 }
 
 float TSP::getSpatialError(unsigned int _brickIndex) {
-	return reinterpret_cast<float &>(data_[_brickIndex*NUM_DATA + SPATIAL_ERR]);
+    return reinterpret_cast<float &>(data_[_brickIndex*NUM_DATA + SPATIAL_ERR]);
 }
 
 float TSP::getTemporalError(unsigned int _brickIndex) {
-	return reinterpret_cast<float &>(data_[_brickIndex*NUM_DATA + TEMPORAL_ERR]);
+    return reinterpret_cast<float &>(data_[_brickIndex*NUM_DATA + TEMPORAL_ERR]);
 }
 
 unsigned int TSP::getFirstOctreeChild(unsigned int _brickIndex) {
@@ -675,81 +675,81 @@ bool TSP::isOctreeLeaf(unsigned int _brickIndex) {
 
 
 std::list<unsigned int> TSP::CoveredLeafBricks(unsigned int _brickIndex) {
-	std::list<unsigned int> out;
+    std::list<unsigned int> out;
 
-	// Find what octree skeleton node the index belongs to
-	unsigned int OTNode = _brickIndex % numOTNodes_;
+    // Find what octree skeleton node the index belongs to
+    unsigned int OTNode = _brickIndex % numOTNodes_;
 
-	// Find what BST node the index corresponds to using int division
-	unsigned int BSTNode = _brickIndex / numOTNodes_;
-	// Calculate BST offset (to translate to root octree)
-	unsigned int BSTOffset = BSTNode * numOTNodes_;
+    // Find what BST node the index corresponds to using int division
+    unsigned int BSTNode = _brickIndex / numOTNodes_;
+    // Calculate BST offset (to translate to root octree)
+    unsigned int BSTOffset = BSTNode * numOTNodes_;
 
-	// Traverse root octree structure to leaves
-	// When visiting the leaves, translate back to correct BST level and save
-	std::queue<unsigned int> queue;
-	queue.push(OTNode);
-	do {
+    // Traverse root octree structure to leaves
+    // When visiting the leaves, translate back to correct BST level and save
+    std::queue<unsigned int> queue;
+    queue.push(OTNode);
+    do {
 
-		// Get front of queue and pop it
-		unsigned int toVisit = queue.front();
-		queue.pop();
+        // Get front of queue and pop it
+        unsigned int toVisit = queue.front();
+        queue.pop();
 
-		// See if the node has children
-		int child = data_[toVisit*NUM_DATA + CHILD_INDEX];
-		if (child == -1) {
-			// Translate back and save
-			out.push_back(toVisit + BSTOffset);
-		}
-		else {
-			// Queue the eight children
-			for (int i = 0; i<8; ++i) {
-				queue.push(child + i);
-			}
-		}
+        // See if the node has children
+        int child = data_[toVisit*NUM_DATA + CHILD_INDEX];
+        if (child == -1) {
+            // Translate back and save
+            out.push_back(toVisit + BSTOffset);
+        }
+        else {
+            // Queue the eight children
+            for (int i = 0; i<8; ++i) {
+                queue.push(child + i);
+            }
+        }
 
-	} while (!queue.empty());
+    } while (!queue.empty());
 
-	return out;
+    return out;
 }
 
 std::list<unsigned int> TSP::CoveredBSTLeafBricks(unsigned int _brickIndex) {
-	std::list<unsigned int> out;
+    std::list<unsigned int> out;
 
-	// Traverse the BST children until we are at root
-	std::queue<unsigned int> queue;
-	queue.push(_brickIndex);
-	do {
+    // Traverse the BST children until we are at root
+    std::queue<unsigned int> queue;
+    queue.push(_brickIndex);
+    do {
 
-		unsigned int toVisit = queue.front();
-		queue.pop();
+        unsigned int toVisit = queue.front();
+        queue.pop();
 
-		bool BSTRoot = toVisit < numOTNodes_;
-		if (BSTRoot) {
-			if (numBSTLevels_ == 1) {
-				out.push_back(toVisit);
-			}
-			else {
-				queue.push(toVisit + numOTNodes_);
-				queue.push(toVisit + numOTNodes_ * 2);
-			}
-		}
-		else {
-			int child = data_[toVisit*NUM_DATA + CHILD_INDEX];
-			if (child == -1) {
-				// Save leaf brick to list
-				out.push_back(toVisit);
-			}
-			else {
-				// Queue children
-				queue.push(child);
-				queue.push(child + numOTNodes_);
-			}
-		}
+        bool BSTRoot = toVisit < numOTNodes_;
+        if (BSTRoot) {
+            if (numBSTLevels_ == 1) {
+                out.push_back(toVisit);
+            }
+            else {
+                queue.push(toVisit + numOTNodes_);
+                queue.push(toVisit + numOTNodes_ * 2);
+            }
+        }
+        else {
+            int child = data_[toVisit*NUM_DATA + CHILD_INDEX];
+            if (child == -1) {
+                // Save leaf brick to list
+                out.push_back(toVisit);
+            }
+            else {
+                // Queue children
+                queue.push(child);
+                queue.push(child + numOTNodes_);
+            }
+        }
 
-	} while (!queue.empty());
+    } while (!queue.empty());
 
-	return out;
+    return out;
 }
 
 }
diff --git a/modules/multiresvolume/rendering/tsp.h b/modules/multiresvolume/rendering/tsp.h
index 6e419e7b6a..6addb710ba 100644
--- a/modules/multiresvolume/rendering/tsp.h
+++ b/modules/multiresvolume/rendering/tsp.h
@@ -39,108 +39,108 @@ namespace openspace {
 class TSP {
 public:
 
-	struct Header {
-		unsigned int gridType_;
-		unsigned int numOrigTimesteps_;
-		unsigned int numTimesteps_;
-		unsigned int xBrickDim_;
-		unsigned int yBrickDim_;
-		unsigned int zBrickDim_;
-		unsigned int xNumBricks_;
-		unsigned int yNumBricks_;
-		unsigned int zNumBricks_;
+    struct Header {
+        unsigned int gridType_;
+        unsigned int numOrigTimesteps_;
+        unsigned int numTimesteps_;
+        unsigned int xBrickDim_;
+        unsigned int yBrickDim_;
+        unsigned int zBrickDim_;
+        unsigned int xNumBricks_;
+        unsigned int yNumBricks_;
+        unsigned int zNumBricks_;
 
-	};
+    };
 
-	enum NodeData {
-		BRICK_INDEX = 0,
-		CHILD_INDEX,
-		SPATIAL_ERR,
-		TEMPORAL_ERR,
-		NUM_DATA
-	};
+    enum NodeData {
+        BRICK_INDEX = 0,
+        CHILD_INDEX,
+        SPATIAL_ERR,
+        TEMPORAL_ERR,
+        NUM_DATA
+    };
 
-	TSP(const std::string& filename);
-	~TSP();
+    TSP(const std::string& filename);
+    ~TSP();
 
-	// load performs readHeader, readCache, writeCache and construct 
-	// in the correct sequence
-	bool load();
+    // load performs readHeader, readCache, writeCache and construct 
+    // in the correct sequence
+    bool load();
 
-	bool readHeader();
-	bool readCache();
-	bool writeCache();
-	bool construct();
-	bool initalizeSSO();
+    bool readHeader();
+    bool readCache();
+    bool writeCache();
+    bool construct();
+    bool initalizeSSO();
 
-	const Header& header() const;
-	static long long dataPosition();
-	std::ifstream& file();
-	unsigned int numTotalNodes() const;
-	unsigned int numValuesPerNode() const;
-	unsigned int numBSTNodes() const;
-	unsigned int numBSTLevels() const;
-	unsigned int numOTNodes() const;
-	unsigned int numOTLevels() const;
-	unsigned int brickDim() const;
-	unsigned int paddedBrickDim() const;
-	unsigned int numBricksPerAxis() const;
-	GLuint ssbo() const;
+    const Header& header() const;
+    static long long dataPosition();
+    std::ifstream& file();
+    unsigned int numTotalNodes() const;
+    unsigned int numValuesPerNode() const;
+    unsigned int numBSTNodes() const;
+    unsigned int numBSTLevels() const;
+    unsigned int numOTNodes() const;
+    unsigned int numOTLevels() const;
+    unsigned int brickDim() const;
+    unsigned int paddedBrickDim() const;
+    unsigned int numBricksPerAxis() const;
+    GLuint ssbo() const;
 
-	bool calculateSpatialError();
-	bool calculateTemporalError();
+    bool calculateSpatialError();
+    bool calculateTemporalError();
 
-	float getSpatialError(unsigned int _brickIndex);
-	float getTemporalError(unsigned int _brickIndex);
-	unsigned int getFirstOctreeChild(unsigned int _brickIndex);
+    float getSpatialError(unsigned int _brickIndex);
+    float getTemporalError(unsigned int _brickIndex);
+    unsigned int getFirstOctreeChild(unsigned int _brickIndex);
 
-	unsigned int getBstLeft(unsigned int _brickIndex);
-	unsigned int getBstRight(unsigned int _brickIndex);
+    unsigned int getBstLeft(unsigned int _brickIndex);
+    unsigned int getBstRight(unsigned int _brickIndex);
 
-	bool isBstLeaf(unsigned int _brickIndex);
-	bool isOctreeLeaf(unsigned int _brickIndex);
+    bool isBstLeaf(unsigned int _brickIndex);
+    bool isOctreeLeaf(unsigned int _brickIndex);
 
 private:
-	// Returns a list of the octree leaf nodes that a given input 
-	// brick covers. If the input is already a leaf, the list will
-	// only contain that one index.
-	std::list<unsigned int> CoveredLeafBricks(unsigned int _brickIndex);
+    // Returns a list of the octree leaf nodes that a given input 
+    // brick covers. If the input is already a leaf, the list will
+    // only contain that one index.
+    std::list<unsigned int> CoveredLeafBricks(unsigned int _brickIndex);
 
-	// Returns a list of the BST leaf nodes that a given input brick
-	// covers (at the same spatial subdivision level).
-	std::list<unsigned int> CoveredBSTLeafBricks(unsigned int _brickIndex);
+    // Returns a list of the BST leaf nodes that a given input brick
+    // covers (at the same spatial subdivision level).
+    std::list<unsigned int> CoveredBSTLeafBricks(unsigned int _brickIndex);
 
-	// Return a list of eight children brick incices given a brick index
-	std::list<unsigned int> ChildBricks(unsigned int _brickIndex);
+    // Return a list of eight children brick incices given a brick index
+    std::list<unsigned int> ChildBricks(unsigned int _brickIndex);
 
-	std::string _filename;
-	std::ifstream _file;
-	std::streampos _dataOffset;
+    std::string _filename;
+    std::ifstream _file;
+    std::streampos _dataOffset;
 
-	// Holds the actual structure
-	std::vector<int> data_;
-	GLuint _dataSSBO;
+    // Holds the actual structure
+    std::vector<int> data_;
+    GLuint _dataSSBO;
 
-	// Data from file
-	Header _header;
+    // Data from file
+    Header _header;
 
-	// Additional metadata
-	unsigned int paddedBrickDim_;
-	unsigned int numTotalNodes_;
-	unsigned int numBSTLevels_;
-	unsigned int numBSTNodes_;
-	unsigned int numOTLevels_;
-	unsigned int numOTNodes_;
+    // Additional metadata
+    unsigned int paddedBrickDim_;
+    unsigned int numTotalNodes_;
+    unsigned int numBSTLevels_;
+    unsigned int numBSTNodes_;
+    unsigned int numOTLevels_;
+    unsigned int numOTNodes_;
 
-	const unsigned int paddingWidth_ = 1;
+    const unsigned int paddingWidth_ = 1;
 
-	// Error stats
-	float minSpatialError_;
-	float maxSpatialError_;
-	float medianSpatialError_;
-	float minTemporalError_;
-	float maxTemporalError_;
-	float medianTemporalError_;
+    // Error stats
+    float minSpatialError_;
+    float maxSpatialError_;
+    float medianSpatialError_;
+    float minTemporalError_;
+    float maxTemporalError_;
+    float medianTemporalError_;
 
 }; // class TSP
 }  // namespace openspace
diff --git a/modules/multiresvolume/shaders/boundsFs.glsl b/modules/multiresvolume/shaders/boundsFs.glsl
index 34b184df57..bb4f9c8cd3 100644
--- a/modules/multiresvolume/shaders/boundsFs.glsl
+++ b/modules/multiresvolume/shaders/boundsFs.glsl
@@ -29,9 +29,9 @@ in vec4 worldPosition;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 fragColor = vec4(vPosition+0.5, 1.0);
-	vec4 position = worldPosition;
-	float depth = pscDepth(position);
+    vec4 fragColor = vec4(vPosition+0.5, 1.0);
+    vec4 position = worldPosition;
+    float depth = pscDepth(position);
 
     Fragment frag;
     frag.color = fragColor;
diff --git a/modules/multiresvolume/shaders/boundsVs.glsl b/modules/multiresvolume/shaders/boundsVs.glsl
index fc328f30df..ab1cd161f7 100644
--- a/modules/multiresvolume/shaders/boundsVs.glsl
+++ b/modules/multiresvolume/shaders/boundsVs.glsl
@@ -35,13 +35,13 @@ out vec4 worldPosition;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vPosition = vertPosition.xyz;
-	worldPosition = modelTransform*vertPosition;
-	
-	vec4 position = pscTransform(worldPosition, mat4(1.0));
+    vPosition = vertPosition.xyz;
+    worldPosition = modelTransform*vertPosition;
     
-	// project the position to view space
-	gl_Position = viewProjection * position;
+    vec4 position = pscTransform(worldPosition, mat4(1.0));
+    
+    // project the position to view space
+    gl_Position = viewProjection * position;
 
     gl_Position.z = 1.0;
 }
diff --git a/modules/newhorizons/newhorizonsmodule.cpp b/modules/newhorizons/newhorizonsmodule.cpp
index 466439e989..3476c91b40 100644
--- a/modules/newhorizons/newhorizonsmodule.cpp
+++ b/modules/newhorizons/newhorizonsmodule.cpp
@@ -59,12 +59,12 @@ void NewHorizonsModule::internalInitialize() {
     auto fRenderable = FactoryManager::ref().factory<Renderable>();
     ghoul_assert(fRenderable, "No renderable factory existed");
 
-	fRenderable->registerClass<RenderableShadowCylinder>("RenderableShadowCylinder");
+    fRenderable->registerClass<RenderableShadowCylinder>("RenderableShadowCylinder");
     fRenderable->registerClass<RenderableCrawlingLine>("RenderableCrawlingLine");
     fRenderable->registerClass<RenderableFov>("RenderableFov");
     fRenderable->registerClass<RenderablePlaneProjection>("RenderablePlaneProjection");
     fRenderable->registerClass<RenderablePlanetProjection>("RenderablePlanetProjection");
-	fRenderable->registerClass<RenderableModelProjection>("RenderableModelProjection");
+    fRenderable->registerClass<RenderableModelProjection>("RenderableModelProjection");
 
     auto fPlanetGeometryProjection = FactoryManager::ref().factory<planetgeometryprojection::PlanetGeometryProjection>();
     fPlanetGeometryProjection->registerClass<planetgeometryprojection::SimpleSphereGeometryProjection>("SimpleSphereProjection");
diff --git a/modules/newhorizons/rendering/planetgeometryprojection.cpp b/modules/newhorizons/rendering/planetgeometryprojection.cpp
index f945a6fd86..1517b26942 100644
--- a/modules/newhorizons/rendering/planetgeometryprojection.cpp
+++ b/modules/newhorizons/rendering/planetgeometryprojection.cpp
@@ -36,17 +36,17 @@ namespace planetgeometryprojection {
 
 PlanetGeometryProjection* PlanetGeometryProjection::createFromDictionary(const ghoul::Dictionary& dictionary)
 {
-	std::string geometryType;
-	const bool success = dictionary.getValue(KeyType, geometryType);
-	if (!success) {
+    std::string geometryType;
+    const bool success = dictionary.getValue(KeyType, geometryType);
+    if (!success) {
         LERROR("PlanetGeometry did not contain a correct value of the key '"
-			<< KeyType << "'");
+            << KeyType << "'");
         return nullptr;
-	}
-	ghoul::TemplateFactory<PlanetGeometryProjection>* factory
-		= FactoryManager::ref().factory<PlanetGeometryProjection>();
+    }
+    ghoul::TemplateFactory<PlanetGeometryProjection>* factory
+        = FactoryManager::ref().factory<PlanetGeometryProjection>();
 
-	PlanetGeometryProjection* result = factory->create(geometryType, dictionary);
+    PlanetGeometryProjection* result = factory->create(geometryType, dictionary);
     if (result == nullptr) {
         LERROR("Failed to create a PlanetGeometry object of type '" << geometryType
                                                                     << "'");
@@ -58,7 +58,7 @@ PlanetGeometryProjection* PlanetGeometryProjection::createFromDictionary(const g
 PlanetGeometryProjection::PlanetGeometryProjection()
     : _parent(nullptr)
 {
-	setName("PlanetGeometryProjection");
+    setName("PlanetGeometryProjection");
 }
 
 PlanetGeometryProjection::~PlanetGeometryProjection()
diff --git a/modules/newhorizons/rendering/planetgeometryprojection.h b/modules/newhorizons/rendering/planetgeometryprojection.h
index 8a621c7ae9..056637c309 100644
--- a/modules/newhorizons/rendering/planetgeometryprojection.h
+++ b/modules/newhorizons/rendering/planetgeometryprojection.h
@@ -37,14 +37,14 @@ class PlanetGeometryProjection : public properties::PropertyOwner {
 public:
     static PlanetGeometryProjection* createFromDictionary(const ghoul::Dictionary& dictionary);
 
-	PlanetGeometryProjection();
-	virtual ~PlanetGeometryProjection();
+    PlanetGeometryProjection();
+    virtual ~PlanetGeometryProjection();
     virtual bool initialize(RenderablePlanetProjection* parent);
     virtual void deinitialize();
     virtual void render() = 0;
 
 protected:
-	RenderablePlanetProjection* _parent;
+    RenderablePlanetProjection* _parent;
 };
 
 }  // namespace planetgeometry
diff --git a/modules/newhorizons/rendering/renderablecrawlingline.cpp b/modules/newhorizons/rendering/renderablecrawlingline.cpp
index 063262723b..c4f557ba9f 100644
--- a/modules/newhorizons/rendering/renderablecrawlingline.cpp
+++ b/modules/newhorizons/rendering/renderablecrawlingline.cpp
@@ -32,13 +32,13 @@
 //#include <imgui.h>
 
 namespace {
-	const std::string _loggerCat = "RenderableCrawlingLine";
+    const std::string _loggerCat = "RenderableCrawlingLine";
 
     const std::string KeySource = "Source";
     const std::string KeyTarget = "Target";
     const std::string KeyInstrument = "Instrument";
     const std::string KeyReferenceFrame = "Frame";
-	const std::string keyColor = "RGB";
+    const std::string keyColor = "RGB";
 
     static const int SourcePosition = 0;
     static const int TargetPosition = 1;
@@ -59,23 +59,23 @@ RenderableCrawlingLine::RenderableCrawlingLine(const ghoul::Dictionary& dictiona
     dictionary.getValue(KeyReferenceFrame, _referenceFrame);
 
 
-	if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
-		dictionary.getValue(keyColor, _lineColor);
-	else
-		_lineColor = glm::vec3(1);
+    if (dictionary.hasKeyAndValue<glm::vec3>(keyColor))
+        dictionary.getValue(keyColor, _lineColor);
+    else
+        _lineColor = glm::vec3(1);
 }
 
 bool RenderableCrawlingLine::isReady() const {
-	bool ready = true;
+    bool ready = true;
     ready &= !_source.empty();
     ready &= !_target.empty();
     ready &= !_instrumentName.empty();
-	ready &= (_program != nullptr);
-	return ready;
+    ready &= (_program != nullptr);
+    return ready;
 }
 
 bool RenderableCrawlingLine::initialize() {
-	_frameCounter = 0;
+    _frameCounter = 0;
     bool completeSuccess = true;
 
     RenderEngine& renderEngine = OsEng.renderEngine();
@@ -87,25 +87,25 @@ bool RenderableCrawlingLine::initialize() {
     if (!_program)
         return false;
 
-	glGenVertexArrays(1, &_vao);
-	glGenBuffers(1, &_vbo);
+    glGenVertexArrays(1, &_vao);
+    glGenBuffers(1, &_vbo);
 
     glBindVertexArray(_vao);
     glBindBuffer(GL_ARRAY_BUFFER, _vbo);
     glBufferData(GL_ARRAY_BUFFER, 2 * sizeof(psc), NULL, GL_DYNAMIC_DRAW);
 
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, (void*)0);
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 bool RenderableCrawlingLine::deinitialize(){
-	glDeleteVertexArrays(1, &_vao);
+    glDeleteVertexArrays(1, &_vao);
     _vao = 0;
-	glDeleteBuffers(1, &_vbo);
+    glDeleteBuffers(1, &_vbo);
     _vbo = 0;
 
     RenderEngine& renderEngine = OsEng.renderEngine();
@@ -114,45 +114,45 @@ bool RenderableCrawlingLine::deinitialize(){
         _program = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 void RenderableCrawlingLine::render(const RenderData& data) {
-	if (_drawLine) {
-	    _program->activate();
-		_frameCounter++;
-	    // fetch data
-	    psc currentPosition = data.position;
-	    psc campos = data.camera.position();
-	    glm::mat4 camrot = data.camera.viewRotationMatrix();
+    if (_drawLine) {
+        _program->activate();
+        _frameCounter++;
+        // fetch data
+        psc currentPosition = data.position;
+        psc campos = data.camera.position();
+        glm::mat4 camrot = data.camera.viewRotationMatrix();
 
-	    glm::mat4 transform = glm::mat4(1);
+        glm::mat4 transform = glm::mat4(1);
 
-	    // setup the data to the shader
-	    _program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	    _program->setUniform("ModelTransform", transform);
+        // setup the data to the shader
+        _program->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+        _program->setUniform("ModelTransform", transform);
 
-		int frame = _frameCounter % 60;
-		float fadingFactor = static_cast<float>(sin((frame * pi_c()) / 60));
-		float alpha = 0.6f + fadingFactor*0.4f;
+        int frame = _frameCounter % 60;
+        float fadingFactor = static_cast<float>(sin((frame * pi_c()) / 60));
+        float alpha = 0.6f + fadingFactor*0.4f;
 
-		glLineWidth(2.f);
+        glLineWidth(2.f);
 
         _program->setUniform("_alpha", alpha);
-		_program->setUniform("color", _lineColor);
-	    setPscUniforms(*_program.get(), data.camera, data.position);
+        _program->setUniform("color", _lineColor);
+        setPscUniforms(*_program.get(), data.camera, data.position);
 
-	    glBindVertexArray(_vao);
+        glBindVertexArray(_vao);
         glBindBuffer(GL_ARRAY_BUFFER, _vbo);
         glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(psc) * 2, _positions);
 
         glEnableVertexAttribArray(0);
         glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
 
-	    glDrawArrays(GL_LINES, 0, 2);
-	    glBindVertexArray(0);
-	
-	    _program->deactivate();
+        glDrawArrays(GL_LINES, 0, 2);
+        glBindVertexArray(0);
+    
+        _program->deactivate();
     }
 }
 
@@ -161,16 +161,16 @@ void RenderableCrawlingLine::update(const UpdateData& data) {
         _program->rebuildFromFile();
     glm::dmat3 transformMatrix = SpiceManager::ref().positionTransformMatrix(_source, _referenceFrame, data.time);
 
-	glm::mat4 tmp = glm::mat4(1);
-	for (int i = 0; i < 3; i++) {
-		for (int j = 0; j < 3; j++){
-			tmp[i][j] = static_cast<float>(transformMatrix[i][j]);
-		}
-	}
+    glm::mat4 tmp = glm::mat4(1);
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++){
+            tmp[i][j] = static_cast<float>(transformMatrix[i][j]);
+        }
+    }
 
-	_positions[SourcePosition] = PowerScaledCoordinate::CreatePowerScaledCoordinate(0, 0, 0);
+    _positions[SourcePosition] = PowerScaledCoordinate::CreatePowerScaledCoordinate(0, 0, 0);
 
-	glm::dvec3 boresight;
+    glm::dvec3 boresight;
     try {
         SpiceManager::FieldOfViewResult res =
             SpiceManager::ref().fieldOfView(_source);
@@ -181,10 +181,10 @@ void RenderableCrawlingLine::update(const UpdateData& data) {
         LERROR(e.what());
     }
     
-	glm::vec4 target(boresight[0], boresight[1], boresight[2], 12);
-	target = tmp * target;
+    glm::vec4 target(boresight[0], boresight[1], boresight[2], 12);
+    target = tmp * target;
 
-	_positions[TargetPosition] = target;
+    _positions[TargetPosition] = target;
 
     if (ImageSequencer::ref().isReady()) {
         _imageSequenceTime = ImageSequencer::ref().instrumentActiveTime(_instrumentName);
diff --git a/modules/newhorizons/rendering/renderablecrawlingline.h b/modules/newhorizons/rendering/renderablecrawlingline.h
index 442116ef1b..2e8df6991b 100644
--- a/modules/newhorizons/rendering/renderablecrawlingline.h
+++ b/modules/newhorizons/rendering/renderablecrawlingline.h
@@ -48,10 +48,10 @@ private:
     std::string _source;
     std::string _target;
     std::string _referenceFrame;
-	glm::vec3 _lineColor;
+    glm::vec3 _lineColor;
 
     psc _positions[2];
-	int _frameCounter;
+    int _frameCounter;
 
     bool _drawLine;
     float _imageSequenceTime;
diff --git a/modules/newhorizons/rendering/renderablefov.cpp b/modules/newhorizons/rendering/renderablefov.cpp
index 889a5acf00..a443ab964c 100644
--- a/modules/newhorizons/rendering/renderablefov.cpp
+++ b/modules/newhorizons/rendering/renderablefov.cpp
@@ -46,27 +46,27 @@
 #include <chrono>
 
 namespace {
-	const std::string _loggerCat              = "RenderableFov";
-	//constants
-	const std::string keyBody                 = "Body";
-	const std::string keyFrame                = "Frame";
-	const std::string keyPathModule           = "ModulePath";
-	const std::string keyColor                = "RGB";
-	const std::string keyInstrument           = "Instrument.Name";
-	const std::string keyInstrumentMethod     = "Instrument.Method";
-	const std::string keyInstrumentAberration = "Instrument.Aberration";
+    const std::string _loggerCat              = "RenderableFov";
+    //constants
+    const std::string keyBody                 = "Body";
+    const std::string keyFrame                = "Frame";
+    const std::string keyPathModule           = "ModulePath";
+    const std::string keyColor                = "RGB";
+    const std::string keyInstrument           = "Instrument.Name";
+    const std::string keyInstrumentMethod     = "Instrument.Method";
+    const std::string keyInstrumentAberration = "Instrument.Aberration";
     const std::string keyPotentialTargets     = "PotentialTargets";
 }
 
 namespace openspace {
 
 RenderableFov::RenderableFov(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _lineWidth("lineWidth", "Line Width", 1.f, 1.f, 20.f)
-	, _drawSolid("solidDraw", "Draw as Quads", false)
-	, _programObject(nullptr)
-	, _texture(nullptr)
-	, _drawFOV(false)
+    : Renderable(dictionary)
+    , _lineWidth("lineWidth", "Line Width", 1.f, 1.f, 20.f)
+    , _drawSolid("solidDraw", "Draw as Quads", false)
+    , _programObject(nullptr)
+    , _texture(nullptr)
+    , _drawFOV(false)
     , _mode(GL_LINES)
 {
     bool success = dictionary.getValue(keyBody, _spacecraft);
@@ -98,11 +98,11 @@ RenderableFov::RenderableFov(const ghoul::Dictionary& dictionary)
     }
 
     addProperty(_lineWidth);
-	addProperty(_drawSolid);
+    addProperty(_drawSolid);
 }
 
 void RenderableFov::allocateData() { 
-	// fetch data for specific instrument (shape, boresight, bounds etc)
+    // fetch data for specific instrument (shape, boresight, bounds etc)
     try {
         SpiceManager::FieldOfViewResult res = SpiceManager::ref().fieldOfView(_instrumentID);
         
@@ -127,11 +127,11 @@ void RenderableFov::allocateData() {
 }
 
 RenderableFov::~RenderableFov() {
-	deinitialize();
+    deinitialize();
 }
 
 bool RenderableFov::initialize() {
-	bool completeSuccess = true;
+    bool completeSuccess = true;
     if (_programObject == nullptr) {
 
         RenderEngine& renderEngine = OsEng.renderEngine();
@@ -142,9 +142,9 @@ bool RenderableFov::initialize() {
         if (!_programObject)
             return false;
     }
-	allocateData();
-	sendToGPU();
-	return completeSuccess;
+    allocateData();
+    sendToGPU();
+    return completeSuccess;
 }
 
 bool RenderableFov::deinitialize() {
@@ -154,89 +154,89 @@ bool RenderableFov::deinitialize() {
         _programObject = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 bool RenderableFov::isReady() const {
-	return _programObject != nullptr;
+    return _programObject != nullptr;
 }
 
 void RenderableFov::sendToGPU() {
-	// Initialize and upload to graphics card
+    // Initialize and upload to graphics card
 
-	// FOV lines
-	glGenVertexArrays(1, &_fovBoundsVAO);
-	glGenBuffers(1, &_fovBoundsVBO);
-	glBindVertexArray(_fovBoundsVAO);
-	glBindBuffer(GL_ARRAY_BUFFER, _fovBoundsVBO);
-	glBufferData(GL_ARRAY_BUFFER, _vBoundsSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vBoundsSize * sizeof(GLfloat), _fovBounds.data());
+    // FOV lines
+    glGenVertexArrays(1, &_fovBoundsVAO);
+    glGenBuffers(1, &_fovBoundsVBO);
+    glBindVertexArray(_fovBoundsVAO);
+    glBindBuffer(GL_ARRAY_BUFFER, _fovBoundsVBO);
+    glBufferData(GL_ARRAY_BUFFER, _vBoundsSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vBoundsSize * sizeof(GLfloat), _fovBounds.data());
 
-	GLsizei st = sizeof(GLfloat) * _stride;
+    GLsizei st = sizeof(GLfloat) * _stride;
 
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
-	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
-	// Orthogonal Plane
-	glGenVertexArrays(1, &_fovPlaneVAO);
-	glGenBuffers(1, &_fovPlaneVBO);
+    // Orthogonal Plane
+    glGenVertexArrays(1, &_fovPlaneVAO);
+    glGenBuffers(1, &_fovPlaneVBO);
 
-	glBindVertexArray(_fovPlaneVAO);
-	glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
-	glBufferData(GL_ARRAY_BUFFER, _vPlaneSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
+    glBindVertexArray(_fovPlaneVAO);
+    glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
+    glBufferData(GL_ARRAY_BUFFER, _vPlaneSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
 
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
-	glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
+    glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 }
 
 void RenderableFov::updateGPU() {
-	glBindBuffer(GL_ARRAY_BUFFER, _fovBoundsVBO);
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vBoundsSize * sizeof(GLfloat), _fovBounds.data());
-	if (!_rebuild){
-		// no new points
-		glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
-		glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
-	}else{
-		// new points - memory change 
-		glBindVertexArray(_fovPlaneVAO);
-		glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
-		glBufferData(GL_ARRAY_BUFFER, _vPlaneSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
-		glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
+    glBindBuffer(GL_ARRAY_BUFFER, _fovBoundsVBO);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vBoundsSize * sizeof(GLfloat), _fovBounds.data());
+    if (!_rebuild){
+        // no new points
+        glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
+        glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
+    }else{
+        // new points - memory change 
+        glBindVertexArray(_fovPlaneVAO);
+        glBindBuffer(GL_ARRAY_BUFFER, _fovPlaneVBO);
+        glBufferData(GL_ARRAY_BUFFER, _vPlaneSize * sizeof(GLfloat), NULL, GL_STATIC_DRAW); // orphaning the buffer, sending NULL data.
+        glBufferSubData(GL_ARRAY_BUFFER, 0, _vPlaneSize * sizeof(GLfloat), _fovPlane.data());
 
-		GLsizei st = sizeof(GLfloat) * _stride;
-		glEnableVertexAttribArray(0);
-		glEnableVertexAttribArray(1);
-		glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
-		glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
-	}
+        GLsizei st = sizeof(GLfloat) * _stride;
+        glEnableVertexAttribArray(0);
+        glEnableVertexAttribArray(1);
+        glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, st, (void*)0);
+        glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, st, (void*)(4 * sizeof(GLfloat)));
+    }
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 }
 
 // various helper methods
 void RenderableFov::insertPoint(std::vector<float>& arr, glm::vec4 p, glm::vec4 c) {
-	for (int i = 0; i < 4; i++){
-		arr.push_back(p[i]);
-	}
-	for (int i = 0; i < 4; i++){
-		arr.push_back(c[i]);
-	}
-	_nrInserted++;
+    for (int i = 0; i < 4; i++){
+        arr.push_back(p[i]);
+    }
+    for (int i = 0; i < 4; i++){
+        arr.push_back(c[i]);
+    }
+    _nrInserted++;
 }
 
 glm::dvec3 RenderableFov::interpolate(glm::dvec3 p0, glm::dvec3 p1, float t) {
-	assert(t >= 0 && t <= 1);
-	float t2 = (1.f - t);
-	return glm::dvec3(p0.x*t2 + p1.x*t, p0.y*t2 + p1.y*t, p0.z*t2 + p1.z*t);
+    assert(t >= 0 && t <= 1);
+    float t2 = (1.f - t);
+    return glm::dvec3(p0.x*t2 + p1.x*t, p0.y*t2 + p1.y*t, p0.z*t2 + p1.z*t);
 }
 
 
@@ -260,11 +260,11 @@ psc RenderableFov::checkForIntercept(glm::dvec3 ray) {
     ivec = result.surfaceVector;
 //    bool intercepted = result.interceptFound;
     
-	ivec *= 0.9999;// because fov lands exactly on top of surface we need to move it out slightly
-	_interceptVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(ivec[0], ivec[1], ivec[2]);
-	_interceptVector[3] += 3;
+    ivec *= 0.9999;// because fov lands exactly on top of surface we need to move it out slightly
+    _interceptVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(ivec[0], ivec[1], ivec[2]);
+    _interceptVector[3] += 3;
 
-	return _interceptVector;
+    return _interceptVector;
 }
 // Orthogonal projection next to planets surface
 psc RenderableFov::orthogonalProjection(glm::dvec3 vecFov) {
@@ -273,15 +273,15 @@ psc RenderableFov::orthogonalProjection(glm::dvec3 vecFov) {
     vecFov = SpiceManager::ref().frameTransformationMatrix(_instrumentID, _frame, _time) * vecFov;
     glm::dvec3 p = glm::proj(vecToTarget, vecFov);
 
-	psc projection = PowerScaledCoordinate::CreatePowerScaledCoordinate(p[0], p[1], p[2]);
-	projection[3] += 3;
+    psc projection = PowerScaledCoordinate::CreatePowerScaledCoordinate(p[0], p[1], p[2]);
+    projection[3] += 3;
 
-	return projection;
+    return projection;
 }
 // Bisection method, simple recurtion
 glm::dvec3 RenderableFov::bisection(glm::dvec3 p1, glm::dvec3 p2, double tolerance) {
-	//check if point is on surface
-	glm::dvec3 half = interpolate(p1, p2, 0.5f);
+    //check if point is on surface
+    glm::dvec3 half = interpolate(p1, p2, 0.5f);
     
     std::string bodyfixed = "IAU_";
     bool convert = (_frame.find(bodyfixed) == std::string::npos);
@@ -302,45 +302,45 @@ glm::dvec3 RenderableFov::bisection(glm::dvec3 p1, glm::dvec3 p2, double toleran
     ivec = result.surfaceVector;
     bool intercepted = result.interceptFound;
     
-	if (glm::distance(_previousHalf, half) < tolerance){
-		_previousHalf = glm::dvec3(0);
-		return half;
-	}
-	_previousHalf = half;
-	//recursive search
-	if (!intercepted){
-		return bisection(p1, half, tolerance);
-	}
-	else{
-		return bisection(half, p2, tolerance);
-	}
+    if (glm::distance(_previousHalf, half) < tolerance){
+        _previousHalf = glm::dvec3(0);
+        return half;
+    }
+    _previousHalf = half;
+    //recursive search
+    if (!intercepted){
+        return bisection(p1, half, tolerance);
+    }
+    else{
+        return bisection(half, p2, tolerance);
+    }
 }
 
 
 void RenderableFov::fovSurfaceIntercept(bool H[], std::vector<glm::dvec3> bounds) {
-	_nrInserted = 0;
-	_fovPlane.clear();// empty the array
+    _nrInserted = 0;
+    _fovPlane.clear();// empty the array
 
-	double tolerance = 0.000000001; // very low tolerance factor
+    double tolerance = 0.000000001; // very low tolerance factor
 
-	glm::dvec3 mid;
-	glm::dvec3 interpolated;
-	glm::dvec3 current;
-	glm::dvec3 next;
-	glm::vec4 tmp(1);
-	if (bounds.size() > 1){
-		for (int i = 0; i < bounds.size(); i++){
-			int k = (i + 1 > bounds.size() - 1) ? 0 : i + 1;
+    glm::dvec3 mid;
+    glm::dvec3 interpolated;
+    glm::dvec3 current;
+    glm::dvec3 next;
+    glm::vec4 tmp(1);
+    if (bounds.size() > 1){
+        for (int i = 0; i < bounds.size(); i++){
+            int k = (i + 1 > bounds.size() - 1) ? 0 : i + 1;
 
-			current = bounds[i];
-			next = bounds[k];
+            current = bounds[i];
+            next = bounds[k];
 
-			if (H[i] == false){ // If point is non-interceptive, project it. 
-				insertPoint(_fovPlane, orthogonalProjection(current).vec4(), tmp);
-				if (H[i + 1] == false && _withinFOV){
-					// IFF incident point is also non-interceptive BUT something is within FOV
-					// we need then to check if this segment makes contact with surface
-					glm::dvec3 half = interpolate(current, next, 0.5f);
+            if (H[i] == false){ // If point is non-interceptive, project it. 
+                insertPoint(_fovPlane, orthogonalProjection(current).vec4(), tmp);
+                if (H[i + 1] == false && _withinFOV){
+                    // IFF incident point is also non-interceptive BUT something is within FOV
+                    // we need then to check if this segment makes contact with surface
+                    glm::dvec3 half = interpolate(current, next, 0.5f);
                     
                     std::string bodyfixed = "IAU_";
                     bool convert = (_frame.find(bodyfixed) == std::string::npos);
@@ -363,117 +363,117 @@ void RenderableFov::fovSurfaceIntercept(bool H[], std::vector<glm::dvec3> bounds
                     bool intercepted = res.interceptFound;
 
                     
-					if (intercepted){
-						// find the two outer most points of intersection 
-						glm::dvec3 root1 = bisection(half, current, tolerance);
-						glm::dvec3 root2 = bisection(half, next, tolerance);
+                    if (intercepted){
+                        // find the two outer most points of intersection 
+                        glm::dvec3 root1 = bisection(half, current, tolerance);
+                        glm::dvec3 root2 = bisection(half, next, tolerance);
 
-						insertPoint(_fovPlane, orthogonalProjection(root1).vec4(), col_sq);
-						for (int j = 1; j < _isteps; j++){
-							float t = (static_cast<float>(j) / _isteps);
-							interpolated = interpolate(root1, root2, t);
-							_interceptVector = checkForIntercept(interpolated);
-							insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
-						}
-						insertPoint(_fovPlane, orthogonalProjection(root2).vec4(), col_sq);
-					}
-				}
-			}
-			if (H[i] == true && H[i + 1] == false){ // current point is interceptive, next is not
-				// find outer most point for interpolation
-				mid = bisection(current, next, tolerance);
-				for (int j = 1; j <= _isteps; j++){
-					float t = (static_cast<float>(j) / _isteps);
-					interpolated = interpolate(current, mid, t);
-					_interceptVector = (j < _isteps) ? checkForIntercept(interpolated) : orthogonalProjection(interpolated);
-					insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
-				}
-			}
-			if (H[i] == false && H[i + 1] == true){ // current point is non-interceptive, next is
-				mid = bisection(next, current, tolerance);
-				for (int j = 1; j <= _isteps; j++){
-					float t = (static_cast<float>(j) / _isteps);
-					interpolated = interpolate(mid, next, t);
-					_interceptVector = (j > 1) ? checkForIntercept(interpolated) : orthogonalProjection(interpolated);
-					insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
-				}
-			}
-			if (H[i] == true && H[i + 1] == true){ // both points intercept
-				for (int j = 0; j <= _isteps; j++){
-					float t = (static_cast<float>(j) / _isteps);
-					interpolated = interpolate(current, next, t);
-					_interceptVector = checkForIntercept(interpolated);
-					insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
-				}
-			}
-		}
-	 }
-	if (_nrInserted == 0){
-		_rebuild = false;
-	} 
-	else {
-		_rebuild = true;
-		//update size etc;
-		_vPlaneSize  = static_cast<unsigned int>(_fovPlane.size());
-	}
+                        insertPoint(_fovPlane, orthogonalProjection(root1).vec4(), col_sq);
+                        for (int j = 1; j < _isteps; j++){
+                            float t = (static_cast<float>(j) / _isteps);
+                            interpolated = interpolate(root1, root2, t);
+                            _interceptVector = checkForIntercept(interpolated);
+                            insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
+                        }
+                        insertPoint(_fovPlane, orthogonalProjection(root2).vec4(), col_sq);
+                    }
+                }
+            }
+            if (H[i] == true && H[i + 1] == false){ // current point is interceptive, next is not
+                // find outer most point for interpolation
+                mid = bisection(current, next, tolerance);
+                for (int j = 1; j <= _isteps; j++){
+                    float t = (static_cast<float>(j) / _isteps);
+                    interpolated = interpolate(current, mid, t);
+                    _interceptVector = (j < _isteps) ? checkForIntercept(interpolated) : orthogonalProjection(interpolated);
+                    insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
+                }
+            }
+            if (H[i] == false && H[i + 1] == true){ // current point is non-interceptive, next is
+                mid = bisection(next, current, tolerance);
+                for (int j = 1; j <= _isteps; j++){
+                    float t = (static_cast<float>(j) / _isteps);
+                    interpolated = interpolate(mid, next, t);
+                    _interceptVector = (j > 1) ? checkForIntercept(interpolated) : orthogonalProjection(interpolated);
+                    insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
+                }
+            }
+            if (H[i] == true && H[i + 1] == true){ // both points intercept
+                for (int j = 0; j <= _isteps; j++){
+                    float t = (static_cast<float>(j) / _isteps);
+                    interpolated = interpolate(current, next, t);
+                    _interceptVector = checkForIntercept(interpolated);
+                    insertPoint(_fovPlane, _interceptVector.vec4(), col_sq);
+                }
+            }
+        }
+     }
+    if (_nrInserted == 0){
+        _rebuild = false;
+    } 
+    else {
+        _rebuild = true;
+        //update size etc;
+        _vPlaneSize  = static_cast<unsigned int>(_fovPlane.size());
+    }
 }
 
 // This method is purely cosmetics, can very well be removed 
 // but be sure to set colors somewhere. 
 void RenderableFov::computeColors() {
-	double t2 = (openspace::ImageSequencer::ref().getNextCaptureTime());
-	double diff = (t2 - _time);
-	float t = 0.0;
-	float interpolationStart = 7.0; //seconds before
-	if (diff <= interpolationStart)
-		t = static_cast<float>(1.0 - (diff / interpolationStart));
+    double t2 = (openspace::ImageSequencer::ref().getNextCaptureTime());
+    double diff = (t2 - _time);
+    float t = 0.0;
+    float interpolationStart = 7.0; //seconds before
+    if (diff <= interpolationStart)
+        t = static_cast<float>(1.0 - (diff / interpolationStart));
 
-	if (diff < 0.0) t = 0.f;
+    if (diff < 0.0) t = 0.f;
 
-	// This is a bit hardcoded - either we go for color tables
-	// or make these properties.
-	col_gray    = glm::vec4(0.7);
-	col_project = glm::vec4(0.0, 1.0, 0.00, 1); 
-	col_start   = glm::vec4(1.00, 0.89, 0.00, 1);
-	col_end     = glm::vec4(1.00, 0.29, 0.00, 1);
-	col_blue    = glm::vec4(0, 0.5, 0.7, 1);
-	col_sq      = glm::vec4(1.00, 0.29, 0.00, 1);
-	
-	col_end  = col_project*t + col_end*(1 - t);
-	col_blue = col_project*t + col_blue*(1 - t);
-	col_sq   = col_project*t + col_sq*(1 - t);
-	
-	float alpha;
-	alpha = _drawSolid ? 0.5f : 0.8f;
+    // This is a bit hardcoded - either we go for color tables
+    // or make these properties.
+    col_gray    = glm::vec4(0.7);
+    col_project = glm::vec4(0.0, 1.0, 0.00, 1); 
+    col_start   = glm::vec4(1.00, 0.89, 0.00, 1);
+    col_end     = glm::vec4(1.00, 0.29, 0.00, 1);
+    col_blue    = glm::vec4(0, 0.5, 0.7, 1);
+    col_sq      = glm::vec4(1.00, 0.29, 0.00, 1);
+    
+    col_end  = col_project*t + col_end*(1 - t);
+    col_blue = col_project*t + col_blue*(1 - t);
+    col_sq   = col_project*t + col_sq*(1 - t);
+    
+    float alpha;
+    alpha = _drawSolid ? 0.5f : 0.8f;
 
-	col_blue.w = alpha;
-	col_project.w = alpha;
-	col_end.w = alpha;
+    col_blue.w = alpha;
+    col_project.w = alpha;
+    col_end.w = alpha;
 }
 
 void RenderableFov::determineTarget(){
-	_fovTarget = _potentialTargets[0]; //default;
-	for (int i = 0; i < _potentialTargets.size(); i++){
-		_withinFOV = openspace::SpiceManager::ref().isTargetInFieldOfView(
+    _fovTarget = _potentialTargets[0]; //default;
+    for (int i = 0; i < _potentialTargets.size(); i++){
+        _withinFOV = openspace::SpiceManager::ref().isTargetInFieldOfView(
                                                                             _potentialTargets[i],                                                                            _spacecraft,
                                                                             
-			_instrumentID,
+            _instrumentID,
                                                                           SpiceManager::FieldOfViewMethod::Ellipsoid,
                                                                               _aberrationCorrection,
-			_time
-			);
-		if (_withinFOV){
-			_fovTarget = _potentialTargets[i];
-			break;
-		}
-	}
+            _time
+            );
+        if (_withinFOV){
+            _fovTarget = _potentialTargets[i];
+            break;
+        }
+    }
 }
 
 void RenderableFov::computeIntercepts(const RenderData& data){
-	// for each FOV vector
-	_fovBounds.clear();
-	for (int i = 0; i <= _bounds.size(); i++){
-		int r = (i == _bounds.size()) ? 0 : i;
+    // for each FOV vector
+    _fovBounds.clear();
+    for (int i = 0; i <= _bounds.size(); i++){
+        int r = (i == _bounds.size()) ? 0 : i;
         std::string bodyfixed = "IAU_";
         bool convert = (_frame.find(bodyfixed) == std::string::npos);
         if (convert)
@@ -493,103 +493,103 @@ void RenderableFov::computeIntercepts(const RenderData& data){
         ivec = res.surfaceVector;
         _interceptTag[r] = res.interceptFound;
         
-		// if not found, use the orthogonal projected point
-		if (!_interceptTag[r]) _projectionBounds[r] = orthogonalProjection(_bounds[r]);
+        // if not found, use the orthogonal projected point
+        if (!_interceptTag[r]) _projectionBounds[r] = orthogonalProjection(_bounds[r]);
 
-		glm::vec4 fovOrigin = glm::vec4(0); //This will have to be fixed once spacecraft is 1:1!
+        glm::vec4 fovOrigin = glm::vec4(0); //This will have to be fixed once spacecraft is 1:1!
 
-		if (_interceptTag[r]){
-			_interceptVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(ivec[0], ivec[1], ivec[2]);
-			_interceptVector[3] += 3;
-			// INTERCEPTIONS
-			insertPoint(_fovBounds, fovOrigin, col_start);
-			insertPoint(_fovBounds, _interceptVector.vec4(), col_end);
-		}
-		else if (_withinFOV){
-			// OBJECT IN FOV, NO INTERCEPT FOR THIS FOV-RAY
-			insertPoint(_fovBounds, fovOrigin, glm::vec4(0, 0, 1, 1));
-			insertPoint(_fovBounds, _projectionBounds[r].vec4(), col_blue);
-		}
-		else{
-			glm::vec4 corner(_bounds[r][0], _bounds[r][1], _bounds[r][2], data.position[3] + 2);
-			corner = _spacecraftRotation*corner;
-			// NONE OF THE FOV-RAYS INTERCEPT AND NO OBJECT IN FOV
-			insertPoint(_fovBounds, fovOrigin, col_gray);
-			insertPoint(_fovBounds, corner, glm::vec4(0));
-		}
-	}
-	_interceptTag[_bounds.size()] = _interceptTag[0];
-	fovSurfaceIntercept(_interceptTag, _bounds);
+        if (_interceptTag[r]){
+            _interceptVector = PowerScaledCoordinate::CreatePowerScaledCoordinate(ivec[0], ivec[1], ivec[2]);
+            _interceptVector[3] += 3;
+            // INTERCEPTIONS
+            insertPoint(_fovBounds, fovOrigin, col_start);
+            insertPoint(_fovBounds, _interceptVector.vec4(), col_end);
+        }
+        else if (_withinFOV){
+            // OBJECT IN FOV, NO INTERCEPT FOR THIS FOV-RAY
+            insertPoint(_fovBounds, fovOrigin, glm::vec4(0, 0, 1, 1));
+            insertPoint(_fovBounds, _projectionBounds[r].vec4(), col_blue);
+        }
+        else{
+            glm::vec4 corner(_bounds[r][0], _bounds[r][1], _bounds[r][2], data.position[3] + 2);
+            corner = _spacecraftRotation*corner;
+            // NONE OF THE FOV-RAYS INTERCEPT AND NO OBJECT IN FOV
+            insertPoint(_fovBounds, fovOrigin, col_gray);
+            insertPoint(_fovBounds, corner, glm::vec4(0));
+        }
+    }
+    _interceptTag[_bounds.size()] = _interceptTag[0];
+    fovSurfaceIntercept(_interceptTag, _bounds);
 
-	glm::vec3 aim = (_spacecraftRotation * glm::vec4(_boresight, 1)).xyz();
+    glm::vec3 aim = (_spacecraftRotation * glm::vec4(_boresight, 1)).xyz();
     glm::dvec3 position =
-	SpiceManager::ref().targetPosition(_fovTarget,
-		    							  _spacecraft,
-		    							  _frame,
-		    							  _aberrationCorrection,
-		    							  _time,
-		    							  _lt);
+    SpiceManager::ref().targetPosition(_fovTarget,
+                                          _spacecraft,
+                                          _frame,
+                                          _aberrationCorrection,
+                                          _time,
+                                          _lt);
     psc p = PowerScaledCoordinate::CreatePowerScaledCoordinate(position.x, position.y, position.z);
-	pss length = p.length();
-	if (length[0] < DBL_EPSILON) {
-		_drawFOV = false;
-		return;
-	}
-	//if aimed 80 deg away from target, dont draw white square
-	if (glm::dot(glm::normalize(aim), glm::normalize(p.vec3())) < 0.2){
-		_drawFOV = false;
-	}
+    pss length = p.length();
+    if (length[0] < DBL_EPSILON) {
+        _drawFOV = false;
+        return;
+    }
+    //if aimed 80 deg away from target, dont draw white square
+    if (glm::dot(glm::normalize(aim), glm::normalize(p.vec3())) < 0.2){
+        _drawFOV = false;
+    }
 }
 
 void RenderableFov::render(const RenderData& data) {
-	assert(_programObject);
-	_programObject->activate();
+    assert(_programObject);
+    _programObject->activate();
 
-	_drawFOV = false;
-	// setup the data to the shader
-	_programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_programObject->setUniform("ModelTransform", glm::mat4(1));
-	setPscUniforms(*_programObject.get(), data.camera, data.position);
-	
-	if (openspace::ImageSequencer::ref().isReady())
-		_drawFOV = ImageSequencer::ref().instrumentActive(_instrumentID);
+    _drawFOV = false;
+    // setup the data to the shader
+    _programObject->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _programObject->setUniform("ModelTransform", glm::mat4(1));
+    setPscUniforms(*_programObject.get(), data.camera, data.position);
+    
+    if (openspace::ImageSequencer::ref().isReady())
+        _drawFOV = ImageSequencer::ref().instrumentActive(_instrumentID);
 
-	if (_drawFOV){
-		// update only when time progresses.
-		if (_oldTime != _time){
-			determineTarget();
-			computeColors();
-			computeIntercepts(data);
-			updateGPU();
-		}
-		_oldTime = _time;
-		_mode = _drawSolid ? GL_TRIANGLE_STRIP : GL_LINES;
+    if (_drawFOV){
+        // update only when time progresses.
+        if (_oldTime != _time){
+            determineTarget();
+            computeColors();
+            computeIntercepts(data);
+            updateGPU();
+        }
+        _oldTime = _time;
+        _mode = _drawSolid ? GL_TRIANGLE_STRIP : GL_LINES;
 
-		glLineWidth(_lineWidth);
-		glBindVertexArray(_fovBoundsVAO);
-		glDrawArrays(_mode, 0, static_cast<int>(_vBoundsSize / _stride));
-		glBindVertexArray(0);
+        glLineWidth(_lineWidth);
+        glBindVertexArray(_fovBoundsVAO);
+        glDrawArrays(_mode, 0, static_cast<int>(_vBoundsSize / _stride));
+        glBindVertexArray(0);
 
-		if (_drawFOV){
-			glLineWidth(2.f);
-			glBindVertexArray(_fovPlaneVAO);
-			glDrawArrays(GL_LINE_LOOP, 0, static_cast<int>(_vPlaneSize / _stride));
-			glBindVertexArray(0);
-		}
+        if (_drawFOV){
+            glLineWidth(2.f);
+            glBindVertexArray(_fovPlaneVAO);
+            glDrawArrays(GL_LINE_LOOP, 0, static_cast<int>(_vPlaneSize / _stride));
+            glBindVertexArray(0);
+        }
         glLineWidth(1.f);
-	}
-	_programObject->deactivate();
+    }
+    _programObject->deactivate();
 }
 
 void RenderableFov::update(const UpdateData& data) {
-	_time  = data.time;
+    _time  = data.time;
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(_instrumentID, _frame, data.time);
-	_spacecraftRotation = glm::mat4(1);
-	for (int i = 0; i < 3; i++){
-		for (int j = 0; j < 3; j++){
-			_spacecraftRotation[i][j] = static_cast<float>(_stateMatrix[i][j]);
-		}
-	}
+    _spacecraftRotation = glm::mat4(1);
+    for (int i = 0; i < 3; i++){
+        for (int j = 0; j < 3; j++){
+            _spacecraftRotation[i][j] = static_cast<float>(_stateMatrix[i][j]);
+        }
+    }
 }
 
 } // namespace openspace
diff --git a/modules/newhorizons/rendering/renderablefov.h b/modules/newhorizons/rendering/renderablefov.h
index 831efdb92b..44ca581bd8 100644
--- a/modules/newhorizons/rendering/renderablefov.h
+++ b/modules/newhorizons/rendering/renderablefov.h
@@ -41,94 +41,94 @@
 namespace openspace {
 class RenderableFov : public Renderable{
 public:
-	RenderableFov(const ghoul::Dictionary& dictionary);
-	~RenderableFov();
+    RenderableFov(const ghoul::Dictionary& dictionary);
+    ~RenderableFov();
 
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
  private:
     // properties
     properties::FloatProperty _lineWidth;
-	properties::BoolProperty _drawSolid;
+    properties::BoolProperty _drawSolid;
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
-	ghoul::opengl::Texture* _texture;
-	openspace::SceneGraphNode* _targetNode;
+    ghoul::opengl::Texture* _texture;
+    openspace::SceneGraphNode* _targetNode;
 
-	// class methods
-	void loadTexture();
-	void allocateData();
-	void insertPoint(std::vector<float>& arr, glm::vec4 p, glm::vec4 c);
-	void fovSurfaceIntercept(bool H[], std::vector<glm::dvec3> bounds);
-	void determineTarget();
-	void updateGPU();
-	void sendToGPU();
+    // class methods
+    void loadTexture();
+    void allocateData();
+    void insertPoint(std::vector<float>& arr, glm::vec4 p, glm::vec4 c);
+    void fovSurfaceIntercept(bool H[], std::vector<glm::dvec3> bounds);
+    void determineTarget();
+    void updateGPU();
+    void sendToGPU();
 
 
-	// helper methods
-	void computeColors();
-	void computeIntercepts(const RenderData& data);
-	psc orthogonalProjection(glm::dvec3 camvec);
-	psc checkForIntercept(glm::dvec3 ray);
-	psc pscInterpolate(psc p0, psc p1, float t);
-	glm::dvec3 interpolate(glm::dvec3 p0, glm::dvec3 p1, float t);
-	glm::dvec3 bisection(glm::dvec3 p1, glm::dvec3 p2, double tolerance);
+    // helper methods
+    void computeColors();
+    void computeIntercepts(const RenderData& data);
+    psc orthogonalProjection(glm::dvec3 camvec);
+    psc checkForIntercept(glm::dvec3 ray);
+    psc pscInterpolate(psc p0, psc p1, float t);
+    glm::dvec3 interpolate(glm::dvec3 p0, glm::dvec3 p1, float t);
+    glm::dvec3 bisection(glm::dvec3 p1, glm::dvec3 p2, double tolerance);
 
-	// instance variables
-	int _nrInserted = 0;
-	int _isteps;
-	bool _rebuild = false;
-	bool _interceptTag[8];
-	bool _withinFOV;
-	std::vector<psc> _projectionBounds;
-	psc _interceptVector;
+    // instance variables
+    int _nrInserted = 0;
+    int _isteps;
+    bool _rebuild = false;
+    bool _interceptTag[8];
+    bool _withinFOV;
+    std::vector<psc> _projectionBounds;
+    psc _interceptVector;
 
-	std::vector<float> _fovBounds;
-	std::vector<float> _fovPlane;
+    std::vector<float> _fovBounds;
+    std::vector<float> _fovPlane;
 
-	// spice
-	std::string _spacecraft;
-	std::string _observer;
-	std::string _frame;
-	std::string _instrumentID;
+    // spice
+    std::string _spacecraft;
+    std::string _observer;
+    std::string _frame;
+    std::string _instrumentID;
     SpiceManager::AberrationCorrection _aberrationCorrection;
-	std::string _fovTarget;
-	glm::dvec3 ipoint, ivec;
-	glm::dvec3 _previousHalf;
-	glm::dvec3 _boresight;
-	glm::dmat3 _stateMatrix;
-	glm::mat4 _spacecraftRotation;
-	std::vector<glm::dvec3> _bounds;
-	std::vector<std::string> _potentialTargets;
-	bool _drawFOV;
-	double _lt;
+    std::string _fovTarget;
+    glm::dvec3 ipoint, ivec;
+    glm::dvec3 _previousHalf;
+    glm::dvec3 _boresight;
+    glm::dmat3 _stateMatrix;
+    glm::mat4 _spacecraftRotation;
+    std::vector<glm::dvec3> _bounds;
+    std::vector<std::string> _potentialTargets;
+    bool _drawFOV;
+    double _lt;
 
-	// GPU 
-	GLuint _fovBoundsVAO;
-	GLuint _fovBoundsVBO;
-	unsigned int _vBoundsSize;
-	GLuint _fovPlaneVAO;
-	GLuint _fovPlaneVBO;
-	unsigned int _vPlaneSize;
-	GLenum _mode;
-	unsigned int _stride;
+    // GPU 
+    GLuint _fovBoundsVAO;
+    GLuint _fovBoundsVBO;
+    unsigned int _vBoundsSize;
+    GLuint _fovPlaneVAO;
+    GLuint _fovPlaneVBO;
+    unsigned int _vPlaneSize;
+    GLenum _mode;
+    unsigned int _stride;
 
-	// time
-	double _time = 0;
-	double _oldTime = 0;
+    // time
+    double _time = 0;
+    double _oldTime = 0;
 
-	// colors
-	glm::vec4 col_sq;      // orthogonal white square
-	glm::vec4 col_project; // color when projections occur
-	glm::vec4 col_start;   // intersection start color
-	glm::vec4 col_end;     // intersection end color
-	glm::vec4 col_blue;    // withinFov color
-	glm::vec4 col_gray;    // no intersection color
+    // colors
+    glm::vec4 col_sq;      // orthogonal white square
+    glm::vec4 col_project; // color when projections occur
+    glm::vec4 col_start;   // intersection start color
+    glm::vec4 col_end;     // intersection end color
+    glm::vec4 col_blue;    // withinFov color
+    glm::vec4 col_gray;    // no intersection color
 
 };
 }
diff --git a/modules/newhorizons/rendering/renderablemodelprojection.cpp b/modules/newhorizons/rendering/renderablemodelprojection.cpp
index 0030eaabd5..4b15ab5f0f 100644
--- a/modules/newhorizons/rendering/renderablemodelprojection.cpp
+++ b/modules/newhorizons/rendering/renderablemodelprojection.cpp
@@ -42,254 +42,254 @@
 #include <thread>
 
 namespace {
-	const std::string _loggerCat = "RenderableModelProjection";
-	const std::string keySource = "Rotation.Source";
-	const std::string keyDestination = "Rotation.Destination";
-	const std::string keyBody = "Body";
-	const std::string keyGeometry = "Geometry";
+    const std::string _loggerCat = "RenderableModelProjection";
+    const std::string keySource = "Rotation.Source";
+    const std::string keyDestination = "Rotation.Destination";
+    const std::string keyBody = "Body";
+    const std::string keyGeometry = "Geometry";
 
-	const std::string keyTextureColor = "Textures.Color";
-	const std::string keyTextureProject = "Textures.Project";
-	const std::string keyTextureDefault = "Textures.Default";
+    const std::string keyTextureColor = "Textures.Color";
+    const std::string keyTextureProject = "Textures.Project";
+    const std::string keyTextureDefault = "Textures.Default";
 
-	const std::string keySequenceDir = "Projection.Sequence";
-	const std::string keySequenceType = "Projection.SequenceType";
-	const std::string keyProjObserver = "Projection.Observer";
-	const std::string keyProjTarget = "Projection.Target";
-	const std::string keyProjAberration = "Projection.Aberration";
+    const std::string keySequenceDir = "Projection.Sequence";
+    const std::string keySequenceType = "Projection.SequenceType";
+    const std::string keyProjObserver = "Projection.Observer";
+    const std::string keyProjTarget = "Projection.Target";
+    const std::string keyProjAberration = "Projection.Aberration";
 
-	const std::string keyInstrument = "Instrument.Name";
-	const std::string keyInstrumentFovy = "Instrument.Fovy";
-	const std::string keyInstrumentAspect = "Instrument.Aspect";
-	const std::string keyInstrumentNear = "Instrument.Near";
-	const std::string keyInstrumentFar = "Instrument.Far";
+    const std::string keyInstrument = "Instrument.Name";
+    const std::string keyInstrumentFovy = "Instrument.Fovy";
+    const std::string keyInstrumentAspect = "Instrument.Aspect";
+    const std::string keyInstrumentNear = "Instrument.Near";
+    const std::string keyInstrumentFar = "Instrument.Far";
 
-	const std::string keyTranslation = "DataInputTranslation";
-	const std::string sequenceTypeImage = "image-sequence";
+    const std::string keyTranslation = "DataInputTranslation";
+    const std::string sequenceTypeImage = "image-sequence";
 
 }
 
 namespace openspace {
 
 RenderableModelProjection::RenderableModelProjection(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _colorTexturePath("colorTexture", "Color Texture")
-	, _projectionTexturePath("projectionTexture", "RGB Texture")
-	, _rotationX("rotationX", "RotationX", 0, 0, 360)
-	, _rotationY("rotationY", "RotationY", 0, 0, 360)
-	, _rotationZ("rotationZ", "RotationZ", 0, 0, 360)
-	, _programObject(nullptr)
-	, _fboProgramObject(nullptr)
-	, _texture(nullptr)
-	, _geometry(nullptr)
-	, _textureOriginal(nullptr)
-	, _textureProj(nullptr)
-	, _textureWhiteSquare(nullptr)
-	, _alpha(1.f)
-	, _performShading("performShading", "Perform Shading", true)
-	, _performProjection("performProjection", "Perform Projections", true)
-	, _frameCount(0)
-	, _programIsDirty(false)
+    : Renderable(dictionary)
+    , _colorTexturePath("colorTexture", "Color Texture")
+    , _projectionTexturePath("projectionTexture", "RGB Texture")
+    , _rotationX("rotationX", "RotationX", 0, 0, 360)
+    , _rotationY("rotationY", "RotationY", 0, 0, 360)
+    , _rotationZ("rotationZ", "RotationZ", 0, 0, 360)
+    , _programObject(nullptr)
+    , _fboProgramObject(nullptr)
+    , _texture(nullptr)
+    , _geometry(nullptr)
+    , _textureOriginal(nullptr)
+    , _textureProj(nullptr)
+    , _textureWhiteSquare(nullptr)
+    , _alpha(1.f)
+    , _performShading("performShading", "Perform Shading", true)
+    , _performProjection("performProjection", "Perform Projections", true)
+    , _frameCount(0)
+    , _programIsDirty(false)
 {
-	std::string name;
-	bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
-	ghoul_assert(success, "Name was not passed to RenderableModelProjection");
+    std::string name;
+    bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
+    ghoul_assert(success, "Name was not passed to RenderableModelProjection");
 
-	ghoul::Dictionary geometryDictionary;
-	success = dictionary.getValue(keyGeometry, geometryDictionary);
-	if (success) {
-		geometryDictionary.setValue(SceneGraphNode::KeyName, name);
-		_geometry = modelgeometry::ModelGeometry::createFromDictionary(geometryDictionary);
-	}
+    ghoul::Dictionary geometryDictionary;
+    success = dictionary.getValue(keyGeometry, geometryDictionary);
+    if (success) {
+        geometryDictionary.setValue(SceneGraphNode::KeyName, name);
+        _geometry = modelgeometry::ModelGeometry::createFromDictionary(geometryDictionary);
+    }
 
-	std::string texturePath = "";
-	success = dictionary.getValue(keyTextureColor, texturePath);
-	if (success)
-		_colorTexturePath = absPath(texturePath);
-		
-	success = dictionary.getValue(keyTextureProject, texturePath);
-	if (success)
-		_projectionTexturePath = absPath(texturePath);
+    std::string texturePath = "";
+    success = dictionary.getValue(keyTextureColor, texturePath);
+    if (success)
+        _colorTexturePath = absPath(texturePath);
+        
+    success = dictionary.getValue(keyTextureProject, texturePath);
+    if (success)
+        _projectionTexturePath = absPath(texturePath);
 
-	success = dictionary.getValue(keyTextureDefault, texturePath);
-	if (success)
-		_defaultProjImage = absPath(texturePath);
+    success = dictionary.getValue(keyTextureDefault, texturePath);
+    if (success)
+        _defaultProjImage = absPath(texturePath);
 
-	addPropertySubOwner(_geometry);
+    addPropertySubOwner(_geometry);
 
-	addProperty(_colorTexturePath);
-	addProperty(_projectionTexturePath);
-	_colorTexturePath.onChange(std::bind(&RenderableModelProjection::loadTexture, this));
-	_projectionTexturePath.onChange(std::bind(&RenderableModelProjection::loadProjectionTexture, this));
+    addProperty(_colorTexturePath);
+    addProperty(_projectionTexturePath);
+    _colorTexturePath.onChange(std::bind(&RenderableModelProjection::loadTexture, this));
+    _projectionTexturePath.onChange(std::bind(&RenderableModelProjection::loadProjectionTexture, this));
 
-	dictionary.getValue(keySource, _source);
-	dictionary.getValue(keyDestination, _destination);
-	dictionary.getValue(keyBody, _target);
-	if (_target != "")
-		setBody(_target);
+    dictionary.getValue(keySource, _source);
+    dictionary.getValue(keyDestination, _destination);
+    dictionary.getValue(keyBody, _target);
+    if (_target != "")
+        setBody(_target);
 
-	bool completeSuccess = true;
-	completeSuccess &= dictionary.getValue(keyInstrument, _instrumentID);
-	completeSuccess &= dictionary.getValue(keyProjObserver, _projectorID);
-	completeSuccess &= dictionary.getValue(keyProjTarget, _projecteeID);
-	completeSuccess &= dictionary.getValue(keyInstrumentFovy, _fovy);
-	completeSuccess &= dictionary.getValue(keyInstrumentAspect, _aspectRatio);
-	completeSuccess &= dictionary.getValue(keyInstrumentNear, _nearPlane);
-	completeSuccess &= dictionary.getValue(keyInstrumentFar, _farPlane);
-	ghoul_assert(completeSuccess, "All neccessary attributes not found in modfile");
+    bool completeSuccess = true;
+    completeSuccess &= dictionary.getValue(keyInstrument, _instrumentID);
+    completeSuccess &= dictionary.getValue(keyProjObserver, _projectorID);
+    completeSuccess &= dictionary.getValue(keyProjTarget, _projecteeID);
+    completeSuccess &= dictionary.getValue(keyInstrumentFovy, _fovy);
+    completeSuccess &= dictionary.getValue(keyInstrumentAspect, _aspectRatio);
+    completeSuccess &= dictionary.getValue(keyInstrumentNear, _nearPlane);
+    completeSuccess &= dictionary.getValue(keyInstrumentFar, _farPlane);
+    ghoul_assert(completeSuccess, "All neccessary attributes not found in modfile");
     
     std::string a = "NONE";
-	bool s = dictionary.getValue(keyProjAberration, a);
+    bool s = dictionary.getValue(keyProjAberration, a);
     _aberration = SpiceManager::AberrationCorrection(a);
     completeSuccess &= s;
     ghoul_assert(completeSuccess, "All neccessary attributes not found in modfile");
     
-	openspace::SpiceManager::ref().addFrame(_target, _source);
-	setBoundingSphere(pss(1.f, 9.f));
+    openspace::SpiceManager::ref().addFrame(_target, _source);
+    setBoundingSphere(pss(1.f, 9.f));
 
-	addProperty(_performShading);
-	addProperty(_performProjection);
-	addProperty(_rotationX);
-	addProperty(_rotationY);
-	addProperty(_rotationZ);
+    addProperty(_performShading);
+    addProperty(_performProjection);
+    addProperty(_rotationX);
+    addProperty(_rotationY);
+    addProperty(_rotationZ);
 
-	SequenceParser* parser;
+    SequenceParser* parser;
 
-	bool foundSequence = dictionary.getValue(keySequenceDir, _sequenceSource);
-	if (foundSequence) {
-		_sequenceSource = absPath(_sequenceSource);
+    bool foundSequence = dictionary.getValue(keySequenceDir, _sequenceSource);
+    if (foundSequence) {
+        _sequenceSource = absPath(_sequenceSource);
 
-		foundSequence = dictionary.getValue(keySequenceType, _sequenceType);
+        foundSequence = dictionary.getValue(keySequenceType, _sequenceType);
         ghoul_assert(foundSequence, "Did not find sequence");
-		//Important: client must define translation-list in mod file IFF playbook
-		if (dictionary.hasKey(keyTranslation)) {
-			ghoul::Dictionary translationDictionary;
-			//get translation dictionary
-			dictionary.getValue(keyTranslation, translationDictionary);
-			if (_sequenceType == sequenceTypeImage) {
-				parser = new LabelParser(name, _sequenceSource, translationDictionary);
-				openspace::ImageSequencer::ref().runSequenceParser(parser);
+        //Important: client must define translation-list in mod file IFF playbook
+        if (dictionary.hasKey(keyTranslation)) {
+            ghoul::Dictionary translationDictionary;
+            //get translation dictionary
+            dictionary.getValue(keyTranslation, translationDictionary);
+            if (_sequenceType == sequenceTypeImage) {
+                parser = new LabelParser(name, _sequenceSource, translationDictionary);
+                openspace::ImageSequencer::ref().runSequenceParser(parser);
 
-			}
-		}
-		else {
-			LWARNING("No translation provided, please make sure all spice calls match playbook!");
-		}
-	}
+            }
+        }
+        else {
+            LWARNING("No translation provided, please make sure all spice calls match playbook!");
+        }
+    }
 
 }
 
 bool RenderableModelProjection::isReady() const {
-	bool ready = true;
-	ready &= (_programObject != nullptr);
-	ready &= (_texture != nullptr);
-	return ready;
+    bool ready = true;
+    ready &= (_programObject != nullptr);
+    ready &= (_texture != nullptr);
+    return ready;
 }
 
 bool RenderableModelProjection::initialize() {
-	bool completeSuccess = true;
-		
-	if (_programObject == nullptr) {
+    bool completeSuccess = true;
+        
+    if (_programObject == nullptr) {
         RenderEngine& renderEngine = OsEng.renderEngine();
         _programObject = renderEngine.buildRenderProgram("ModelShader",
             "${MODULES}/newhorizons/shaders/modelShader_vs.glsl",
             "${MODULES}/newhorizons/shaders/modelShader_fs.glsl");
 
-		if (!_programObject)
-			return false;
-	}
-	_programObject->setProgramObjectCallback([&](ghoul::opengl::ProgramObject*) { this->_programIsDirty = true; } );
+        if (!_programObject)
+            return false;
+    }
+    _programObject->setProgramObjectCallback([&](ghoul::opengl::ProgramObject*) { this->_programIsDirty = true; } );
 
-	if (_fboProgramObject == nullptr) {
-		_fboProgramObject = ghoul::opengl::ProgramObject::Build("ProjectionPass",
-			"${MODULES}/newhorizons/shaders/projectionPass_vs.glsl",
-			"${MODULES}/newhorizons/shaders/projectionPass_fs.glsl");
-		if (!_fboProgramObject)
-			return false;
-	}
-	_fboProgramObject->setProgramObjectCallback([&](ghoul::opengl::ProgramObject*) { this->_programIsDirty = true; } );
+    if (_fboProgramObject == nullptr) {
+        _fboProgramObject = ghoul::opengl::ProgramObject::Build("ProjectionPass",
+            "${MODULES}/newhorizons/shaders/projectionPass_vs.glsl",
+            "${MODULES}/newhorizons/shaders/projectionPass_fs.glsl");
+        if (!_fboProgramObject)
+            return false;
+    }
+    _fboProgramObject->setProgramObjectCallback([&](ghoul::opengl::ProgramObject*) { this->_programIsDirty = true; } );
 
-	loadTexture();
-	loadProjectionTexture();
+    loadTexture();
+    loadProjectionTexture();
 
-	completeSuccess &= (_texture != nullptr);
-	completeSuccess &= (_textureOriginal != nullptr);
-	completeSuccess &= (_textureProj != nullptr);
-	completeSuccess &= (_textureWhiteSquare != nullptr);
+    completeSuccess &= (_texture != nullptr);
+    completeSuccess &= (_textureOriginal != nullptr);
+    completeSuccess &= (_textureProj != nullptr);
+    completeSuccess &= (_textureWhiteSquare != nullptr);
 
-	completeSuccess &= _geometry->initialize(this);
-	completeSuccess &= !_source.empty();
-	completeSuccess &= !_destination.empty();
-		
+    completeSuccess &= _geometry->initialize(this);
+    completeSuccess &= !_source.empty();
+    completeSuccess &= !_destination.empty();
+        
 
-	bool gotverts = _geometry->getVertices(&_geometryVertecies) && _geometry->getIndices(&_geometryIndeces);
-	if (!gotverts)
-		LWARNING("Lack of vertex data from geometry for image projection");
+    bool gotverts = _geometry->getVertices(&_geometryVertecies) && _geometry->getIndices(&_geometryIndeces);
+    if (!gotverts)
+        LWARNING("Lack of vertex data from geometry for image projection");
 
-	completeSuccess &= auxiliaryRendertarget();
+    completeSuccess &= auxiliaryRendertarget();
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 bool RenderableModelProjection::auxiliaryRendertarget() {
-	bool completeSuccess = true;
-	// set FBO to texture to project to
+    bool completeSuccess = true;
+    // set FBO to texture to project to
 
-	GLint defaultFBO;
-	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFBO);
+    GLint defaultFBO;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFBO);
 
-	glGenFramebuffers(1, &_fboID);
-	glBindFramebuffer(GL_FRAMEBUFFER, _fboID);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *_texture, 0);
-	// check FBO status
-	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-	if (status != GL_FRAMEBUFFER_COMPLETE)
-		completeSuccess &= false;
-	// switch back to window-system-provided framebuffer
-	glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
+    glGenFramebuffers(1, &_fboID);
+    glBindFramebuffer(GL_FRAMEBUFFER, _fboID);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, *_texture, 0);
+    // check FBO status
+    GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+    if (status != GL_FRAMEBUFFER_COMPLETE)
+        completeSuccess &= false;
+    // switch back to window-system-provided framebuffer
+    glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
 
-	int vertexSize = sizeof(modelgeometry::ModelGeometry::Vertex);
+    int vertexSize = sizeof(modelgeometry::ModelGeometry::Vertex);
 
-	glGenVertexArrays(1, &_vaoID);
-	glGenBuffers(1, &_vbo);
-	glGenBuffers(1, &_ibo);
+    glGenVertexArrays(1, &_vaoID);
+    glGenBuffers(1, &_vbo);
+    glGenBuffers(1, &_ibo);
 
-	glBindVertexArray(_vaoID);
-	glBindBuffer(GL_ARRAY_BUFFER, _vbo);
-	glBufferData(GL_ARRAY_BUFFER, _geometryVertecies.size() * vertexSize, &_geometryVertecies[0], GL_STATIC_DRAW);
+    glBindVertexArray(_vaoID);
+    glBindBuffer(GL_ARRAY_BUFFER, _vbo);
+    glBufferData(GL_ARRAY_BUFFER, _geometryVertecies.size() * vertexSize, &_geometryVertecies[0], GL_STATIC_DRAW);
 
-	glEnableVertexAttribArray(0);
-	glEnableVertexAttribArray(1);
-	glEnableVertexAttribArray(2);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, vertexSize,
-		reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, location)));
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, vertexSize,
-		reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, tex)));
-	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, vertexSize,
-		reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, normal)));
-			
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
-	glBufferData(GL_ELEMENT_ARRAY_BUFFER, _geometryIndeces.size() * sizeof(int), &_geometryIndeces[0], GL_STATIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glEnableVertexAttribArray(1);
+    glEnableVertexAttribArray(2);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, vertexSize,
+        reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, location)));
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, vertexSize,
+        reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, tex)));
+    glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, vertexSize,
+        reinterpret_cast<const GLvoid*>(offsetof(modelgeometry::ModelGeometry::Vertex, normal)));
+            
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, _geometryIndeces.size() * sizeof(int), &_geometryIndeces[0], GL_STATIC_DRAW);
 
-	glBindVertexArray(0);
+    glBindVertexArray(0);
 
 
-	return completeSuccess;
+    return completeSuccess;
 }
 
 bool RenderableModelProjection::deinitialize() {
-	if (_geometry) {
-		_geometry->deinitialize();
-		delete _geometry;
-	}
+    if (_geometry) {
+        _geometry->deinitialize();
+        delete _geometry;
+    }
 
-	_geometry = nullptr;
-	_texture = nullptr;
-	_textureProj = nullptr;
-	_textureOriginal = nullptr;
-	_textureWhiteSquare = nullptr;
+    _geometry = nullptr;
+    _texture = nullptr;
+    _textureProj = nullptr;
+    _textureOriginal = nullptr;
+    _textureWhiteSquare = nullptr;
 
-	glDeleteBuffers(1, &_vbo);
+    glDeleteBuffers(1, &_vbo);
 
     RenderEngine& renderEngine = OsEng.renderEngine();
     if (_programObject) {
@@ -297,139 +297,139 @@ bool RenderableModelProjection::deinitialize() {
         _programObject = nullptr;
     }
 
-	return true;
+    return true;
 }
 
 void RenderableModelProjection::render(const RenderData& data) {
-	if (!_programObject) return;
-	if (!_textureProj) return;
-	_programObject->activate();
-	_frameCount++;
+    if (!_programObject) return;
+    if (!_textureProj) return;
+    _programObject->activate();
+    _frameCount++;
 
-	_camScaling = data.camera.scaling();
-	_up = data.camera.lookUpVector();
+    _camScaling = data.camera.scaling();
+    _up = data.camera.lookUpVector();
 
-	if (_capture && _performProjection)
-		project();
+    if (_capture && _performProjection)
+        project();
 
-	attitudeParameters(_time);
-	_imageTimes.clear();
-		
-	double time = openspace::Time::ref().currentTime();
-	bool targetPositionCoverage = openspace::SpiceManager::ref().hasSpkCoverage(_target, time);
-	if (!targetPositionCoverage) {
-		int frame = _frameCount % 180;
+    attitudeParameters(_time);
+    _imageTimes.clear();
+        
+    double time = openspace::Time::ref().currentTime();
+    bool targetPositionCoverage = openspace::SpiceManager::ref().hasSpkCoverage(_target, time);
+    if (!targetPositionCoverage) {
+        int frame = _frameCount % 180;
 
-		float fadingFactor = static_cast<float>(sin((frame * M_PI) / 180));
-		_alpha = 0.5f + fadingFactor * 0.5f;
-	}
-	else
-		_alpha = 1.0f;
-		
-	_programObject->setUniform("ProjectorMatrix", _projectorMatrix);
-	_programObject->setUniform("boresight", _boresight);
-	_programObject->setUniform("_performShading", _performShading);
-	_programObject->setUniform("sun_pos", _sunPosition.vec3());
-	_viewProjection = data.camera.viewProjectionMatrix();
-	_programObject->setUniform("ViewProjection", _viewProjection);
-	_programObject->setUniform("ModelTransform", _transform);
-	setPscUniforms(*_programObject.get(), data.camera, data.position);
-	
-	textureBind();
-	_geometry->render();
-		
-	// disable shader
-	_programObject->deactivate();
+        float fadingFactor = static_cast<float>(sin((frame * M_PI) / 180));
+        _alpha = 0.5f + fadingFactor * 0.5f;
+    }
+    else
+        _alpha = 1.0f;
+        
+    _programObject->setUniform("ProjectorMatrix", _projectorMatrix);
+    _programObject->setUniform("boresight", _boresight);
+    _programObject->setUniform("_performShading", _performShading);
+    _programObject->setUniform("sun_pos", _sunPosition.vec3());
+    _viewProjection = data.camera.viewProjectionMatrix();
+    _programObject->setUniform("ViewProjection", _viewProjection);
+    _programObject->setUniform("ModelTransform", _transform);
+    setPscUniforms(*_programObject.get(), data.camera, data.position);
+    
+    textureBind();
+    _geometry->render();
+        
+    // disable shader
+    _programObject->deactivate();
 }
 
 void RenderableModelProjection::update(const UpdateData& data) {
-	if (_programIsDirty) {
-		_programObject->rebuildFromFile();
-		_fboProgramObject->rebuildFromFile();
-		_programIsDirty = false;
-	}
-		
-	_time = data.time;
+    if (_programIsDirty) {
+        _programObject->rebuildFromFile();
+        _fboProgramObject->rebuildFromFile();
+        _programIsDirty = false;
+    }
+        
+    _time = data.time;
 
-	if (openspace::ImageSequencer::ref().isReady() && _performProjection) {
-		openspace::ImageSequencer::ref().updateSequencer(_time);
-		_capture = openspace::ImageSequencer::ref().getImagePaths(_imageTimes, _projecteeID, _instrumentID);
-	}
-		
-	// set spice-orientation in accordance to timestamp
+    if (openspace::ImageSequencer::ref().isReady() && _performProjection) {
+        openspace::ImageSequencer::ref().updateSequencer(_time);
+        _capture = openspace::ImageSequencer::ref().getImagePaths(_imageTimes, _projecteeID, _instrumentID);
+    }
+        
+    // set spice-orientation in accordance to timestamp
     if (!_source.empty()) {
         _stateMatrix = SpiceManager::ref().positionTransformMatrix(_source, _destination, _time);
     }
 
-	double  lt;
+    double  lt;
     glm::dvec3 p =
     openspace::SpiceManager::ref().targetPosition("SUN", _target, "GALACTIC", {}, _time, lt);
     _sunPosition = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
 }
 
 void RenderableModelProjection::imageProjectGPU() {
-		
-	// keep handle to the current bound FBO
-	GLint defaultFBO;
-	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFBO);
-	
-	GLint m_viewport[4];
-	glGetIntegerv(GL_VIEWPORT, m_viewport);	
-	glBindFramebuffer(GL_FRAMEBUFFER, _fboID);
-	// set blend eq
-	glEnable(GL_BLEND);
-	glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
-	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ZERO);
+        
+    // keep handle to the current bound FBO
+    GLint defaultFBO;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFBO);
+    
+    GLint m_viewport[4];
+    glGetIntegerv(GL_VIEWPORT, m_viewport);    
+    glBindFramebuffer(GL_FRAMEBUFFER, _fboID);
+    // set blend eq
+    glEnable(GL_BLEND);
+    glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+    glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ZERO);
 
-	glViewport(0, 0, static_cast<GLsizei>(_texture->width()), static_cast<GLsizei>(_texture->height()));
-	_fboProgramObject->activate();
+    glViewport(0, 0, static_cast<GLsizei>(_texture->width()), static_cast<GLsizei>(_texture->height()));
+    _fboProgramObject->activate();
 
-	ghoul::opengl::TextureUnit unitFboProject;
-	unitFboProject.activate();
-	_textureProj->bind();
-	_fboProgramObject->setUniform("projectTexture", unitFboProject);
+    ghoul::opengl::TextureUnit unitFboProject;
+    unitFboProject.activate();
+    _textureProj->bind();
+    _fboProgramObject->setUniform("projectTexture", unitFboProject);
 
-	ghoul::opengl::TextureUnit unitFboCurrent;
-	unitFboCurrent.activate();
-	_texture->bind();
-	_fboProgramObject->setUniform("currentTexture", unitFboCurrent);
-	_fboProgramObject->setUniform("ProjectorMatrix", _projectorMatrix);
-	_fboProgramObject->setUniform("ModelTransform", _transform);
-	_fboProgramObject->setUniform("_scaling", _camScaling);
-	_fboProgramObject->setUniform("boresight", _boresight);
+    ghoul::opengl::TextureUnit unitFboCurrent;
+    unitFboCurrent.activate();
+    _texture->bind();
+    _fboProgramObject->setUniform("currentTexture", unitFboCurrent);
+    _fboProgramObject->setUniform("ProjectorMatrix", _projectorMatrix);
+    _fboProgramObject->setUniform("ModelTransform", _transform);
+    _fboProgramObject->setUniform("_scaling", _camScaling);
+    _fboProgramObject->setUniform("boresight", _boresight);
 
-	glBindVertexArray(_vaoID);
-	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
-	glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(_geometryIndeces.size()), GL_UNSIGNED_INT, 0);
-	glBindVertexArray(0);
-	
-	_fboProgramObject->deactivate();
-	glDisable(GL_BLEND);
-	//bind back to default
-	glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
-	glViewport(m_viewport[0], m_viewport[1],
-		m_viewport[2], m_viewport[3]);
-			
+    glBindVertexArray(_vaoID);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _ibo);
+    glDrawElements(GL_TRIANGLES, static_cast<GLsizei>(_geometryIndeces.size()), GL_UNSIGNED_INT, 0);
+    glBindVertexArray(0);
+    
+    _fboProgramObject->deactivate();
+    glDisable(GL_BLEND);
+    //bind back to default
+    glBindFramebuffer(GL_FRAMEBUFFER, defaultFBO);
+    glViewport(m_viewport[0], m_viewport[1],
+        m_viewport[2], m_viewport[3]);
+            
 }
 
 void RenderableModelProjection::attitudeParameters(double time) {
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(_source, _destination, time);
     _instrumentMatrix = SpiceManager::ref().positionTransformMatrix(_instrumentID, _destination, time);
 
-	_transform = glm::mat4(1);
+    _transform = glm::mat4(1);
 
-	glm::mat4 rotPropX = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationX)), glm::vec3(1, 0, 0));
-	glm::mat4 rotPropY = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationY)), glm::vec3(0, 1, 0));
-	glm::mat4 rotPropZ = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationZ)), glm::vec3(0, 0, 1));
-		
-	for (int i = 0; i < 3; i++) {
-		for (int j = 0; j < 3; j++) {
-			_transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
-		}
-	}
-	_transform = _transform * rotPropX * rotPropY * rotPropZ;
+    glm::mat4 rotPropX = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationX)), glm::vec3(1, 0, 0));
+    glm::mat4 rotPropY = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationY)), glm::vec3(0, 1, 0));
+    glm::mat4 rotPropZ = glm::rotate(_transform, glm::radians(static_cast<float>(_rotationZ)), glm::vec3(0, 0, 1));
+        
+    for (int i = 0; i < 3; i++) {
+        for (int j = 0; j < 3; j++) {
+            _transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
+        }
+    }
+    _transform = _transform * rotPropX * rotPropY * rotPropZ;
 
-	glm::dvec3 boresight;
+    glm::dvec3 boresight;
     try {
         SpiceManager::FieldOfViewResult res = SpiceManager::ref().fieldOfView(_instrumentID);
         boresight = std::move(res.boresightVector);
@@ -437,101 +437,101 @@ void RenderableModelProjection::attitudeParameters(double time) {
         return;
     }
 
-	double lightTime;
+    double lightTime;
     glm::dvec3 p =
         SpiceManager::ref().targetPosition(_projectorID, _projecteeID, _destination, _aberration, time, lightTime);
     psc position = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
  
-	position[3] += (3 + _camScaling[1]);
-	glm::vec3 cpos = position.vec3();
+    position[3] += (3 + _camScaling[1]);
+    glm::vec3 cpos = position.vec3();
 
-	_projectorMatrix = computeProjectorMatrix(cpos, boresight, _up);
+    _projectorMatrix = computeProjectorMatrix(cpos, boresight, _up);
 }
 
 glm::mat4 RenderableModelProjection::computeProjectorMatrix(const glm::vec3 loc, glm::dvec3 aim, const glm::vec3 up) {
-	//rotate boresight into correct alignment
-	_boresight = _instrumentMatrix*aim;
-	glm::vec3 uptmp(_instrumentMatrix*glm::dvec3(up));
+    //rotate boresight into correct alignment
+    _boresight = _instrumentMatrix*aim;
+    glm::vec3 uptmp(_instrumentMatrix*glm::dvec3(up));
 
-	// create view matrix
-	glm::vec3 e3 = glm::normalize(_boresight);
-	glm::vec3 e1 = glm::normalize(glm::cross(uptmp, e3));
-	glm::vec3 e2 = glm::normalize(glm::cross(e3, e1));
-	glm::mat4 projViewMatrix = glm::mat4(e1.x, e2.x, e3.x, 0.f,
-											e1.y, e2.y, e3.y, 0.f,
-											e1.z, e2.z, e3.z, 0.f,
-											-glm::dot(e1, loc), -glm::dot(e2, loc), -glm::dot(e3, loc), 1.f);
-		
-	// create perspective projection matrix
-	glm::mat4 projProjectionMatrix = glm::perspective(glm::radians(_fovy), _aspectRatio, _nearPlane, _farPlane);
-	// bias matrix
-	glm::mat4 projNormalizationMatrix = glm::mat4(0.5f, 0, 0, 0,
-													0, 0.5f, 0, 0,
-													0, 0, 0.5f, 0,
-													0.5f, 0.5f, 0.5f, 1);
-	return projNormalizationMatrix*projProjectionMatrix*projViewMatrix;
+    // create view matrix
+    glm::vec3 e3 = glm::normalize(_boresight);
+    glm::vec3 e1 = glm::normalize(glm::cross(uptmp, e3));
+    glm::vec3 e2 = glm::normalize(glm::cross(e3, e1));
+    glm::mat4 projViewMatrix = glm::mat4(e1.x, e2.x, e3.x, 0.f,
+                                            e1.y, e2.y, e3.y, 0.f,
+                                            e1.z, e2.z, e3.z, 0.f,
+                                            -glm::dot(e1, loc), -glm::dot(e2, loc), -glm::dot(e3, loc), 1.f);
+        
+    // create perspective projection matrix
+    glm::mat4 projProjectionMatrix = glm::perspective(glm::radians(_fovy), _aspectRatio, _nearPlane, _farPlane);
+    // bias matrix
+    glm::mat4 projNormalizationMatrix = glm::mat4(0.5f, 0, 0, 0,
+                                                    0, 0.5f, 0, 0,
+                                                    0, 0, 0.5f, 0,
+                                                    0.5f, 0.5f, 0.5f, 1);
+    return projNormalizationMatrix*projProjectionMatrix*projViewMatrix;
 }
 
 
 void RenderableModelProjection::textureBind() {
-	ghoul::opengl::TextureUnit unit[2];
-	unit[0].activate();
-	_texture->bind();
-	_programObject->setUniform("currentTexture", unit[0]);
-	unit[1].activate();
-	_textureWhiteSquare->bind();
-	_programObject->setUniform("projectedTexture", unit[1]);
+    ghoul::opengl::TextureUnit unit[2];
+    unit[0].activate();
+    _texture->bind();
+    _programObject->setUniform("currentTexture", unit[0]);
+    unit[1].activate();
+    _textureWhiteSquare->bind();
+    _programObject->setUniform("projectedTexture", unit[1]);
 }
 
 void RenderableModelProjection::project() {
-	for (auto img : _imageTimes) {
-		std::thread t1(&RenderableModelProjection::attitudeParameters, this, img.startTime);
-		t1.join();
-		_projectionTexturePath = img.path;
-		imageProjectGPU(); //fbopass
-	}
-	_capture = false;
+    for (auto img : _imageTimes) {
+        std::thread t1(&RenderableModelProjection::attitudeParameters, this, img.startTime);
+        t1.join();
+        _projectionTexturePath = img.path;
+        imageProjectGPU(); //fbopass
+    }
+    _capture = false;
 }
 
 void RenderableModelProjection::loadTexture() {
-	_texture = nullptr;
-	if (_colorTexturePath.value() != "") {
+    _texture = nullptr;
+    if (_colorTexturePath.value() != "") {
         _texture = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_colorTexturePath)));
-		if (_texture) {
-			LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
-			_texture->uploadTexture();
-			_texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
-		}
-	}
-	_textureOriginal = nullptr;
-	if (_colorTexturePath.value() != "") {
+        if (_texture) {
+            LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
+            _texture->uploadTexture();
+            _texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
+        }
+    }
+    _textureOriginal = nullptr;
+    if (_colorTexturePath.value() != "") {
         _textureOriginal = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_colorTexturePath)));
-		if (_textureOriginal) {
-			LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
-			_textureOriginal->uploadTexture();
-			_textureOriginal->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
-		}
-	}
-	_textureWhiteSquare = nullptr;
-	if (_defaultProjImage != "") {
+        if (_textureOriginal) {
+            LDEBUG("Loaded texture from '" << absPath(_colorTexturePath) << "'");
+            _textureOriginal->uploadTexture();
+            _textureOriginal->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
+        }
+    }
+    _textureWhiteSquare = nullptr;
+    if (_defaultProjImage != "") {
         _textureWhiteSquare = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_defaultProjImage)));
-		if (_textureWhiteSquare) {
-			_textureWhiteSquare->uploadTexture();
-			_textureWhiteSquare->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
-		}
-	}
+        if (_textureWhiteSquare) {
+            _textureWhiteSquare->uploadTexture();
+            _textureWhiteSquare->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
+        }
+    }
 }
 
 void RenderableModelProjection::loadProjectionTexture() {
-	_textureProj = nullptr;
-	if (_projectionTexturePath.value() != "") {
+    _textureProj = nullptr;
+    if (_projectionTexturePath.value() != "") {
         _textureProj = std::move(ghoul::io::TextureReader::ref().loadTexture(absPath(_projectionTexturePath)));
-		if (_textureProj) {
-			_textureProj->uploadTexture();
-			_textureProj->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
-			_textureProj->setWrapping(ghoul::opengl::Texture::WrappingMode::ClampToBorder);
-		}
-	}
+        if (_textureProj) {
+            _textureProj->uploadTexture();
+            _textureProj->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
+            _textureProj->setWrapping(ghoul::opengl::Texture::WrappingMode::ClampToBorder);
+        }
+    }
 
 }
 
diff --git a/modules/newhorizons/rendering/renderablemodelprojection.h b/modules/newhorizons/rendering/renderablemodelprojection.h
index 61ea52b3f5..ea8e11ea45 100644
--- a/modules/newhorizons/rendering/renderablemodelprojection.h
+++ b/modules/newhorizons/rendering/renderablemodelprojection.h
@@ -40,42 +40,42 @@
 
 namespace openspace {
 
-	namespace modelgeometry {
-		class ModelGeometry;
-	}
+    namespace modelgeometry {
+        class ModelGeometry;
+    }
 
-	class RenderableModelProjection : public Renderable {
-	public:
-		RenderableModelProjection(const ghoul::Dictionary& dictionary);
+    class RenderableModelProjection : public Renderable {
+    public:
+        RenderableModelProjection(const ghoul::Dictionary& dictionary);
 
-		bool initialize() override;
-		bool deinitialize() override;
+        bool initialize() override;
+        bool deinitialize() override;
 
-		bool isReady() const override;
+        bool isReady() const override;
 
-		void render(const RenderData& data) override;
-		void update(const UpdateData& data) override;
+        void render(const RenderData& data) override;
+        void update(const UpdateData& data) override;
 
 
-	protected:
-		void loadTexture();
-		void loadProjectionTexture();
+    protected:
+        void loadTexture();
+        void loadProjectionTexture();
 
-	private:
-		bool auxiliaryRendertarget();
-		glm::mat4 computeProjectorMatrix(const glm::vec3 loc, glm::dvec3 aim, const glm::vec3 up);
-		void attitudeParameters(double time);
-		void imageProjectGPU();
+    private:
+        bool auxiliaryRendertarget();
+        glm::mat4 computeProjectorMatrix(const glm::vec3 loc, glm::dvec3 aim, const glm::vec3 up);
+        void attitudeParameters(double time);
+        void imageProjectGPU();
 
-		void textureBind();
-		void project();
+        void textureBind();
+        void project();
 
-		properties::StringProperty _colorTexturePath;
-		properties::BoolProperty _performProjection;
+        properties::StringProperty _colorTexturePath;
+        properties::BoolProperty _performProjection;
 
-		properties::IntProperty _rotationX;
-		properties::IntProperty _rotationY;
-		properties::IntProperty _rotationZ;
+        properties::IntProperty _rotationX;
+        properties::IntProperty _rotationY;
+        properties::IntProperty _rotationZ;
 
         std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
         std::unique_ptr<ghoul::opengl::ProgramObject> _fboProgramObject;
@@ -85,63 +85,63 @@ namespace openspace {
         std::unique_ptr<ghoul::opengl::Texture> _textureProj;
         std::unique_ptr<ghoul::opengl::Texture> _textureWhiteSquare;
 
-		modelgeometry::ModelGeometry* _geometry;
+        modelgeometry::ModelGeometry* _geometry;
 
-		float _alpha;
-		glm::dmat3 _stateMatrix;
-		glm::dmat3 _instrumentMatrix;
+        float _alpha;
+        glm::dmat3 _stateMatrix;
+        glm::dmat3 _instrumentMatrix;
 
-		properties::StringProperty  _projectionTexturePath;
-		std::string _defaultProjImage;
-		std::string _source;
-		std::string _destination;
-		std::string _target;
+        properties::StringProperty  _projectionTexturePath;
+        std::string _defaultProjImage;
+        std::string _source;
+        std::string _destination;
+        std::string _target;
 
-		// sequence loading
-		std::string _sequenceSource;
-		std::string _sequenceType;
+        // sequence loading
+        std::string _sequenceSource;
+        std::string _sequenceType;
 
-		// projection mod info
-		std::string _instrumentID;
-		std::string _projectorID;
-		std::string _projecteeID;
+        // projection mod info
+        std::string _instrumentID;
+        std::string _projectorID;
+        std::string _projecteeID;
         SpiceManager::AberrationCorrection _aberration;
-		std::vector<std::string> _potentialTargets;
-		float _fovy;
-		float _aspectRatio;
-		float _nearPlane;
-		float _farPlane;
+        std::vector<std::string> _potentialTargets;
+        float _fovy;
+        float _aspectRatio;
+        float _nearPlane;
+        float _farPlane;
 
-		// uniforms
-		glm::vec2  _camScaling;
-		glm::vec3  _up;
-		glm::mat4  _transform;
-		glm::mat4  _viewProjection;
-		glm::mat4  _projectorMatrix;
-		glm::vec3  _boresight;
+        // uniforms
+        glm::vec2  _camScaling;
+        glm::vec3  _up;
+        glm::mat4  _transform;
+        glm::mat4  _viewProjection;
+        glm::mat4  _projectorMatrix;
+        glm::vec3  _boresight;
 
-		// FBO stuff
-		GLuint _fboID;
-		GLuint _quad;
-		GLuint _vertexPositionBuffer;
+        // FBO stuff
+        GLuint _fboID;
+        GLuint _quad;
+        GLuint _vertexPositionBuffer;
 
-		GLuint _vbo;
-		GLuint _ibo;
-		GLuint _vaoID;
-		std::vector<modelgeometry::ModelGeometry::Vertex> _geometryVertecies;
-		std::vector<int> _geometryIndeces;
+        GLuint _vbo;
+        GLuint _ibo;
+        GLuint _vaoID;
+        std::vector<modelgeometry::ModelGeometry::Vertex> _geometryVertecies;
+        std::vector<int> _geometryIndeces;
 
-		std::vector<Image> _imageTimes;
-		int _frameCount;
-		double _time;
+        std::vector<Image> _imageTimes;
+        int _frameCount;
+        double _time;
 
-		bool _capture;
+        bool _capture;
 
-		psc _sunPosition;
+        psc _sunPosition;
 
-		properties::BoolProperty _performShading;
-		bool _programIsDirty;
-	};
+        properties::BoolProperty _performShading;
+        bool _programIsDirty;
+    };
 
 }  // namespace openspace
 
diff --git a/modules/newhorizons/rendering/renderableplaneprojection.cpp b/modules/newhorizons/rendering/renderableplaneprojection.cpp
index cdbd73dc50..5359541467 100644
--- a/modules/newhorizons/rendering/renderableplaneprojection.cpp
+++ b/modules/newhorizons/rendering/renderableplaneprojection.cpp
@@ -39,13 +39,13 @@
 #include <glm/gtx/projection.hpp>
 
 namespace {
-	const std::string _loggerCat = "RenderablePlaneProjection";
+    const std::string _loggerCat = "RenderablePlaneProjection";
     const std::string KeySpacecraft = "Spacecraft";
     const std::string KeyInstrument = "Instrument";
     const std::string KeyMoving = "Moving";
     const std::string KeyTexture = "Texture";
     const std::string KeyName = "Name";
-	const std::string KeyTarget = "DefaultTarget";
+    const std::string KeyTarget = "DefaultTarget";
     const std::string GalacticFrame = "GALACTIC";
     const double REALLY_FAR = 99999999999;
 }
@@ -53,54 +53,54 @@ namespace {
 namespace openspace {
 
 RenderablePlaneProjection::RenderablePlaneProjection(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
+    : Renderable(dictionary)
     , _texturePath("")
     , _planeIsDirty(false)
-	, _shader(nullptr)
+    , _shader(nullptr)
     , _textureIsDirty(false)
-	, _texture(nullptr)
-	, _quad(0)
-	, _vertexPositionBuffer(0)
-	, _name("ImagePlane")
-	, _previousTime(0)
-	, _moving(false)
-	, _hasImage(false)
+    , _texture(nullptr)
+    , _quad(0)
+    , _vertexPositionBuffer(0)
+    , _name("ImagePlane")
+    , _previousTime(0)
+    , _moving(false)
+    , _hasImage(false)
 {
-	dictionary.getValue(KeySpacecraft, _spacecraft);
-	dictionary.getValue(KeyInstrument, _instrument);
-	dictionary.getValue(KeyMoving, _moving);
-	dictionary.getValue(KeyName, _name);
-	dictionary.getValue(KeyTarget, _defaultTarget);
+    dictionary.getValue(KeySpacecraft, _spacecraft);
+    dictionary.getValue(KeyInstrument, _instrument);
+    dictionary.getValue(KeyMoving, _moving);
+    dictionary.getValue(KeyName, _name);
+    dictionary.getValue(KeyTarget, _defaultTarget);
 
-	std::string texturePath = "";
-	bool success = dictionary.getValue(KeyTexture, _texturePath);
-	if (success) {
-		_texturePath = absPath(_texturePath);
-		_textureFile = new ghoul::filesystem::File(_texturePath);
-	}
+    std::string texturePath = "";
+    bool success = dictionary.getValue(KeyTexture, _texturePath);
+    if (success) {
+        _texturePath = absPath(_texturePath);
+        _textureFile = new ghoul::filesystem::File(_texturePath);
+    }
 
-	loadTexture();
+    loadTexture();
 }
 
 RenderablePlaneProjection::~RenderablePlaneProjection() {
-	delete _textureFile;
+    delete _textureFile;
 }
 
 bool RenderablePlaneProjection::isReady() const {
-	bool ready = true;
-	if (!_shader)
-		ready &= false;
-	if (!_texture)
-		ready &= false;
-	return ready;
+    bool ready = true;
+    if (!_shader)
+        ready &= false;
+    if (!_texture)
+        ready &= false;
+    return ready;
 }
 
 bool RenderablePlaneProjection::initialize() {
-	glGenVertexArrays(1, &_quad); // generate array
-	glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
-	
-	// Plane program
-	if (_shader == nullptr) {
+    glGenVertexArrays(1, &_quad); // generate array
+    glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
+    
+    // Plane program
+    if (_shader == nullptr) {
         // Image Plane Program
         RenderEngine& renderEngine = OsEng.renderEngine();
         _shader = renderEngine.buildRenderProgram("Image Plane",
@@ -109,9 +109,9 @@ bool RenderablePlaneProjection::initialize() {
         if (!_shader) return false;
     }
 
-	setTarget(_defaultTarget);
-	loadTexture();
-	return isReady();
+    setTarget(_defaultTarget);
+    loadTexture();
+    return isReady();
 }
 
 bool RenderablePlaneProjection::deinitialize() {
@@ -121,114 +121,114 @@ bool RenderablePlaneProjection::deinitialize() {
         _shader = nullptr;
     }
 
-	glDeleteVertexArrays(1, &_quad);
-	_quad = 0;
-	glDeleteBuffers(1, &_vertexPositionBuffer);
-	_vertexPositionBuffer = 0;
+    glDeleteVertexArrays(1, &_quad);
+    _quad = 0;
+    glDeleteBuffers(1, &_vertexPositionBuffer);
+    _vertexPositionBuffer = 0;
     _texture = nullptr;
-	return true;
+    return true;
 }
 
 void RenderablePlaneProjection::render(const RenderData& data) {
-	bool active = ImageSequencer::ref().instrumentActive(_instrument);
-	if (!_hasImage || (_moving && !active))
-		return;
+    bool active = ImageSequencer::ref().instrumentActive(_instrument);
+    if (!_hasImage || (_moving && !active))
+        return;
 
-	glm::mat4 transform = glm::mat4(1.0);
+    glm::mat4 transform = glm::mat4(1.0);
 
-	for (int i = 0; i < 3; i++){
-		for (int j = 0; j < 3; j++){
-			transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
-		}
-	}
+    for (int i = 0; i < 3; i++){
+        for (int j = 0; j < 3; j++){
+            transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
+        }
+    }
 
-	// Activate shader
-	_shader->activate();
+    // Activate shader
+    _shader->activate();
 
-	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_shader->setUniform("ModelTransform", transform);
-	setPscUniforms(*_shader.get(), data.camera, data.position);
+    _shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _shader->setUniform("ModelTransform", transform);
+    setPscUniforms(*_shader.get(), data.camera, data.position);
 
-	ghoul::opengl::TextureUnit unit;
-	unit.activate();
-	_texture->bind();
-	_shader->setUniform("texture1", unit);
+    ghoul::opengl::TextureUnit unit;
+    unit.activate();
+    _texture->bind();
+    _shader->setUniform("texture1", unit);
 
-	glBindVertexArray(_quad);
-	glDrawArrays(GL_TRIANGLES, 0, 6);
+    glBindVertexArray(_quad);
+    glDrawArrays(GL_TRIANGLES, 0, 6);
 
-	_shader->deactivate();
+    _shader->deactivate();
 
 }
 
 void RenderablePlaneProjection::update(const UpdateData& data) {
-	
+    
 
-	double time = data.time;
-	const Image img = openspace::ImageSequencer::ref().getLatestImageForInstrument(_instrument);
-	
-	if (img.path == "")
-		return;
-	else
-		_hasImage = true;
+    double time = data.time;
+    const Image img = openspace::ImageSequencer::ref().getLatestImageForInstrument(_instrument);
+    
+    if (img.path == "")
+        return;
+    else
+        _hasImage = true;
 
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(_target.frame, GalacticFrame, time);
-	
-	double timePast = abs(img.startTime - _previousTime);
-	
-	std::string tex = _texturePath;
-	if (_moving || _planeIsDirty)
-		updatePlane(img, time);
+    
+    double timePast = abs(img.startTime - _previousTime);
+    
+    std::string tex = _texturePath;
+    if (_moving || _planeIsDirty)
+        updatePlane(img, time);
 
-	else if (timePast > DBL_EPSILON) {
-		_previousTime = time = img.startTime;
-		updatePlane(img, time);
-	}
+    else if (timePast > DBL_EPSILON) {
+        _previousTime = time = img.startTime;
+        updatePlane(img, time);
+    }
 
-	if (_shader->isDirty())
-		_shader->rebuildFromFile();
+    if (_shader->isDirty())
+        _shader->rebuildFromFile();
 
-	if (_textureIsDirty) {
-		loadTexture();
-		_textureIsDirty = false;
-	}
+    if (_textureIsDirty) {
+        loadTexture();
+        _textureIsDirty = false;
+    }
 }
 
 void RenderablePlaneProjection::loadTexture() {
-	if (_texturePath != "") {
+    if (_texturePath != "") {
         std::unique_ptr<ghoul::opengl::Texture> texture = ghoul::io::TextureReader::ref().loadTexture(absPath(_texturePath));
-		if (texture) {
+        if (texture) {
             if (texture->format() == ghoul::opengl::Texture::Format::Red)
                 texture->setSwizzleMask({ GL_RED, GL_RED, GL_RED, GL_ONE });
-			texture->uploadTexture();
+            texture->uploadTexture();
             // TODO: AnisotropicMipMap crashes on ATI cards ---abock
             //texture->setFilter(ghoul::opengl::Texture::FilterMode::AnisotropicMipMap);
             texture->setFilter(ghoul::opengl::Texture::FilterMode::Linear);
             _texture = std::move(texture);
 
-			delete _textureFile;
-			_textureFile = new ghoul::filesystem::File(_texturePath);
-			_textureFile->setCallback([&](const ghoul::filesystem::File&) { _textureIsDirty = true; });
-		}
-	}
+            delete _textureFile;
+            _textureFile = new ghoul::filesystem::File(_texturePath);
+            _textureFile->setCallback([&](const ghoul::filesystem::File&) { _textureIsDirty = true; });
+        }
+    }
 }
 
 void RenderablePlaneProjection::updatePlane(const Image img, double currentTime) {
-	
-	std::string frame;
-	std::vector<glm::dvec3> bounds;
-	glm::dvec3 boresight;
-	
-	std::string target = _defaultTarget;
-	// Turned on if the plane should be attached to the closest target, 
-	// rather than the target specified in img 
-	//if (!_moving) {
-	//	target = findClosestTarget(currentTime);
-	//}
-	if (img.path != "")
-	target = img.target;
+    
+    std::string frame;
+    std::vector<glm::dvec3> bounds;
+    glm::dvec3 boresight;
+    
+    std::string target = _defaultTarget;
+    // Turned on if the plane should be attached to the closest target, 
+    // rather than the target specified in img 
+    //if (!_moving) {
+    //    target = findClosestTarget(currentTime);
+    //}
+    if (img.path != "")
+    target = img.target;
 
-	setTarget(target);
+    setTarget(target);
 
     try {
         SpiceManager::FieldOfViewResult res = SpiceManager::ref().fieldOfView(_instrument);
@@ -240,8 +240,8 @@ void RenderablePlaneProjection::updatePlane(const Image img, double currentTime)
         LERROR(e.what());
     }
 
-	double lt;
-	psc projection[4];
+    double lt;
+    psc projection[4];
 
     glm::dvec3 vecToTarget = SpiceManager::ref().targetPosition(
         _target.body,
@@ -251,118 +251,118 @@ void RenderablePlaneProjection::updatePlane(const Image img, double currentTime)
         currentTime,
         lt
     );
-	// The apparent position, CN+S, makes image align best with target
+    // The apparent position, CN+S, makes image align best with target
 
-	for (int j = 0; j < bounds.size(); ++j) {
+    for (int j = 0; j < bounds.size(); ++j) {
         bounds[j] = SpiceManager::ref().frameTransformationMatrix(frame, GalacticFrame, currentTime) * bounds[j];
         glm::dvec3 cornerPosition = glm::proj(vecToTarget, bounds[j]);
-		
-		if (!_moving) {
-			cornerPosition -= vecToTarget;
-		}
+        
+        if (!_moving) {
+            cornerPosition -= vecToTarget;
+        }
         cornerPosition = SpiceManager::ref().frameTransformationMatrix(GalacticFrame, _target.frame, currentTime) * cornerPosition;
-				
-		projection[j] = PowerScaledCoordinate::CreatePowerScaledCoordinate(cornerPosition[0], cornerPosition[1], cornerPosition[2]);
-		projection[j][3] += 3;
-	}
+                
+        projection[j] = PowerScaledCoordinate::CreatePowerScaledCoordinate(cornerPosition[0], cornerPosition[1], cornerPosition[2]);
+        projection[j][3] += 3;
+    }
 
-	if (!_moving) {
-		SceneGraphNode* thisNode = OsEng.renderEngine().scene()->sceneGraphNode(_name);
-		SceneGraphNode* newParent = OsEng.renderEngine().scene()->sceneGraphNode(_target.node);
-		if (thisNode != nullptr && newParent != nullptr)
-			thisNode->setParent(newParent);
-	}
-	
-	const GLfloat vertex_data[] = { // square of two triangles drawn within fov in target coordinates
-		//	  x      y     z     w     s     t
-		projection[1][0], projection[1][1], projection[1][2], projection[1][3], 0, 1, // Lower left 1
-		projection[3][0], projection[3][1], projection[3][2], projection[3][3], 1, 0, // Upper right 2
-		projection[2][0], projection[2][1], projection[2][2], projection[2][3], 0, 0, // Upper left 3
-		projection[1][0], projection[1][1], projection[1][2], projection[1][3], 0, 1, // Lower left 4 = 1
-		projection[0][0], projection[0][1], projection[0][2], projection[0][3], 1, 1, // Lower right 5
-		projection[3][0], projection[3][1], projection[3][2], projection[3][3], 1, 0, // Upper left 6 = 2
-	};
+    if (!_moving) {
+        SceneGraphNode* thisNode = OsEng.renderEngine().scene()->sceneGraphNode(_name);
+        SceneGraphNode* newParent = OsEng.renderEngine().scene()->sceneGraphNode(_target.node);
+        if (thisNode != nullptr && newParent != nullptr)
+            thisNode->setParent(newParent);
+    }
+    
+    const GLfloat vertex_data[] = { // square of two triangles drawn within fov in target coordinates
+        //      x      y     z     w     s     t
+        projection[1][0], projection[1][1], projection[1][2], projection[1][3], 0, 1, // Lower left 1
+        projection[3][0], projection[3][1], projection[3][2], projection[3][3], 1, 0, // Upper right 2
+        projection[2][0], projection[2][1], projection[2][2], projection[2][3], 0, 0, // Upper left 3
+        projection[1][0], projection[1][1], projection[1][2], projection[1][3], 0, 1, // Lower left 4 = 1
+        projection[0][0], projection[0][1], projection[0][2], projection[0][3], 1, 1, // Lower right 5
+        projection[3][0], projection[3][1], projection[3][2], projection[3][3], 1, 0, // Upper left 6 = 2
+    };
 
-	glBindVertexArray(_quad); // bind array
-	glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer); // bind buffer
-	glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, reinterpret_cast<void*>(0));
-	glEnableVertexAttribArray(1);
-	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, reinterpret_cast<void*>(sizeof(GLfloat) * 4));
+    glBindVertexArray(_quad); // bind array
+    glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer); // bind buffer
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, reinterpret_cast<void*>(0));
+    glEnableVertexAttribArray(1);
+    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 6, reinterpret_cast<void*>(sizeof(GLfloat) * 4));
 
-	if (!_moving && img.path != "") {
-		_texturePath = img.path;
-		loadTexture();
-	}
+    if (!_moving && img.path != "") {
+        _texturePath = img.path;
+        loadTexture();
+    }
 }
 
 void RenderablePlaneProjection::setTarget(std::string body) {
 
-	if (body == "")
-		return;
+    if (body == "")
+        return;
 
-	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
-	Renderable* possibleTarget;
-	bool hasBody, found = false;
-	std::string targetBody;
+    std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
+    Renderable* possibleTarget;
+    bool hasBody, found = false;
+    std::string targetBody;
 
-	for (auto node : nodes)
-	{
-		possibleTarget = node->renderable();
-		if (possibleTarget != nullptr) {
-			hasBody = possibleTarget->hasBody();
-			if (hasBody && possibleTarget->getBody(targetBody) && (targetBody == body)) {
-				_target.node = node->name(); // get name from propertyOwner
-				found = true;
-				break;
-			}
-		}
-	}
-	if (found) {
-		_target.body = body;
-		_target.frame = openspace::SpiceManager::ref().frameFromBody(body);
-	}
+    for (auto node : nodes)
+    {
+        possibleTarget = node->renderable();
+        if (possibleTarget != nullptr) {
+            hasBody = possibleTarget->hasBody();
+            if (hasBody && possibleTarget->getBody(targetBody) && (targetBody == body)) {
+                _target.node = node->name(); // get name from propertyOwner
+                found = true;
+                break;
+            }
+        }
+    }
+    if (found) {
+        _target.body = body;
+        _target.frame = openspace::SpiceManager::ref().frameFromBody(body);
+    }
 }
 
 std::string RenderablePlaneProjection::findClosestTarget(double currentTime) {
 
-	std::vector<std::string> targets;
+    std::vector<std::string> targets;
 
-	std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
-	Renderable* possibleTarget;
-	std::string targetBody;
-	bool hasBody, found = false;
+    std::vector<SceneGraphNode*> nodes = OsEng.renderEngine().scene()->allSceneGraphNodes();
+    Renderable* possibleTarget;
+    std::string targetBody;
+    bool hasBody, found = false;
 
-	PowerScaledScalar min = PowerScaledScalar::CreatePSS(REALLY_FAR);
-	PowerScaledScalar distance = PowerScaledScalar::CreatePSS(0.0);
+    PowerScaledScalar min = PowerScaledScalar::CreatePSS(REALLY_FAR);
+    PowerScaledScalar distance = PowerScaledScalar::CreatePSS(0.0);
 
-	std::string closestTarget = "";
+    std::string closestTarget = "";
 
-	double lt;
+    double lt;
     glm::dvec3 p =
     SpiceManager::ref().targetPosition(_spacecraft, "SSB", GalacticFrame, {}, currentTime, lt);
     psc spacecraftPos = PowerScaledCoordinate::CreatePowerScaledCoordinate(p.x, p.y, p.z);
 
 
-	for (auto node : nodes)
-	{
-		possibleTarget = node->renderable();
-		if (possibleTarget != nullptr) {
-			hasBody = possibleTarget->hasBody();
-			if (hasBody && possibleTarget->getBody(targetBody)) {
+    for (auto node : nodes)
+    {
+        possibleTarget = node->renderable();
+        if (possibleTarget != nullptr) {
+            hasBody = possibleTarget->hasBody();
+            if (hasBody && possibleTarget->getBody(targetBody)) {
                 found = SpiceManager::ref().isTargetInFieldOfView(targetBody, _spacecraft, _instrument, SpiceManager::FieldOfViewMethod::Ellipsoid, {}, currentTime);
-				if (found){
-					targets.push_back(node->name()); // get name from propertyOwner
-					distance = (node->worldPosition() - spacecraftPos).length();
-					if (distance < min)
-						closestTarget = targetBody;
-				}
-			}
-		}
-	}
+                if (found){
+                    targets.push_back(node->name()); // get name from propertyOwner
+                    distance = (node->worldPosition() - spacecraftPos).length();
+                    if (distance < min)
+                        closestTarget = targetBody;
+                }
+            }
+        }
+    }
 
-	return closestTarget;
+    return closestTarget;
 }
 
 } // namespace openspace
diff --git a/modules/newhorizons/rendering/renderableplaneprojection.h b/modules/newhorizons/rendering/renderableplaneprojection.h
index aceeb597be..21edb0257f 100644
--- a/modules/newhorizons/rendering/renderableplaneprojection.h
+++ b/modules/newhorizons/rendering/renderableplaneprojection.h
@@ -35,66 +35,66 @@
 #include <memory>
 
 namespace ghoul {
-	namespace filesystem {
-		class File;
-	}
-	namespace opengl {
-		class ProgramObject;
-		class Texture;
-	}
+    namespace filesystem {
+        class File;
+    }
+    namespace opengl {
+        class ProgramObject;
+        class Texture;
+    }
 }
 
 namespace openspace {
 struct LinePoint;
 
 struct target {
-	std::string body;
-	std::string frame;
-	std::string node;
+    std::string body;
+    std::string frame;
+    std::string node;
 };
 
 class RenderablePlaneProjection : public Renderable {
 public:
-	RenderablePlaneProjection(const ghoul::Dictionary& dictionary);
-	~RenderablePlaneProjection();
+    RenderablePlaneProjection(const ghoul::Dictionary& dictionary);
+    ~RenderablePlaneProjection();
     
-	bool initialize() override;
-	bool deinitialize() override;
+    bool initialize() override;
+    bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	void render(const RenderData& data) override;
-	void update(const UpdateData& data) override;
+    void render(const RenderData& data) override;
+    void update(const UpdateData& data) override;
 
 private:
-	void loadTexture();
-	void updatePlane(const Image img, double currentTime);
-	std::string findClosestTarget(double currentTime);
-	void setTarget(std::string body);
+    void loadTexture();
+    void updatePlane(const Image img, double currentTime);
+    std::string findClosestTarget(double currentTime);
+    void setTarget(std::string body);
 
-	std::string _texturePath;
-		
-	bool _planeIsDirty;
+    std::string _texturePath;
+        
+    bool _planeIsDirty;
 
-	glm::dmat3 _stateMatrix;
-	std::string _frame;
+    glm::dmat3 _stateMatrix;
+    std::string _frame;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
-	bool _textureIsDirty;
+    bool _textureIsDirty;
     std::unique_ptr<ghoul::opengl::Texture> _texture = nullptr;
 //    ghoul::opengl::Texture* _texture;
-	ghoul::filesystem::File* _textureFile;
-	GLuint _quad;
-	GLuint _vertexPositionBuffer;
-	std::string _spacecraft;
-	std::string _instrument;
-	std::string _defaultTarget;
+    ghoul::filesystem::File* _textureFile;
+    GLuint _quad;
+    GLuint _vertexPositionBuffer;
+    std::string _spacecraft;
+    std::string _instrument;
+    std::string _defaultTarget;
 
-	double _previousTime;
-	target _target;
-	std::string _name;
-	bool _moving;
-	bool _hasImage;
+    double _previousTime;
+    target _target;
+    std::string _name;
+    bool _moving;
+    bool _hasImage;
 };
 
 } // namespace openspace
diff --git a/modules/newhorizons/rendering/renderableplanetprojection.cpp b/modules/newhorizons/rendering/renderableplanetprojection.cpp
index 46f343e699..3fb24e11e7 100644
--- a/modules/newhorizons/rendering/renderableplanetprojection.cpp
+++ b/modules/newhorizons/rendering/renderableplanetprojection.cpp
@@ -481,15 +481,15 @@ void RenderablePlanetProjection::project(){
     // Comment out if not using queue and prefer old method -------------
     // + in update() function
     //if (!imageQueue.empty()){
-    //	Image& img = imageQueue.front();
-    //	RenderablePlanetProjection::attitudeParameters(img.startTime);
-    //	// if image has new path - ie actual image, NOT placeholder
-    //	if (_projectionTexturePath.value() != img.path){
-    //		// rebind and upload 
-    //		_projectionTexturePath = img.path; 
-    //	}
-    //	imageProjectGPU(); // fbopass
-    //	imageQueue.pop();
+    //    Image& img = imageQueue.front();
+    //    RenderablePlanetProjection::attitudeParameters(img.startTime);
+    //    // if image has new path - ie actual image, NOT placeholder
+    //    if (_projectionTexturePath.value() != img.path){
+    //        // rebind and upload 
+    //        _projectionTexturePath = img.path; 
+    //    }
+    //    imageProjectGPU(); // fbopass
+    //    imageQueue.pop();
     //}
     // ------------------------------------------------------------------
 
@@ -574,7 +574,7 @@ void RenderablePlanetProjection::update(const UpdateData& data){
     // @mm
     //_capture = true;
     //for (auto img : _imageTimes){
-    //	imageQueue.push(img);
+    //    imageQueue.push(img);
     //}
     //_imageTimes.clear();
     // --------------------------------------------------------------
diff --git a/modules/newhorizons/rendering/renderableplanetprojection.h b/modules/newhorizons/rendering/renderableplanetprojection.h
index e1d9c9b29f..d5daaca21b 100644
--- a/modules/newhorizons/rendering/renderableplanetprojection.h
+++ b/modules/newhorizons/rendering/renderableplanetprojection.h
@@ -60,99 +60,99 @@ class PlanetGeometryProjection;
 
 class RenderablePlanetProjection : public Renderable {
 public:
-	RenderablePlanetProjection(const ghoul::Dictionary& dictionary);
-	~RenderablePlanetProjection();
+    RenderablePlanetProjection(const ghoul::Dictionary& dictionary);
+    ~RenderablePlanetProjection();
 
     bool initialize() override;
     bool deinitialize() override;
-	bool isReady() const override;
+    bool isReady() const override;
 
 
-	void render(const RenderData& data) override;
+    void render(const RenderData& data) override;
     void update(const UpdateData& data) override;
-	ghoul::opengl::Texture* baseTexture() { return _texture.get(); };
+    ghoul::opengl::Texture* baseTexture() { return _texture.get(); };
 
 protected:
 
     void loadTexture();
-	void loadProjectionTexture();
-	bool auxiliaryRendertarget();
-	glm::mat4 computeProjectorMatrix(const glm::vec3 loc, glm::dvec3 aim, const glm::vec3 up);
-	void attitudeParameters(double time);
+    void loadProjectionTexture();
+    bool auxiliaryRendertarget();
+    glm::mat4 computeProjectorMatrix(const glm::vec3 loc, glm::dvec3 aim, const glm::vec3 up);
+    void attitudeParameters(double time);
 
-	void textureBind();
-	void project();
-	void clearAllProjections();
+    void textureBind();
+    void project();
+    void clearAllProjections();
 private:
-	void imageProjectGPU();
+    void imageProjectGPU();
 
-	std::map<std::string, Decoder*> _fileTranslation;
+    std::map<std::string, Decoder*> _fileTranslation;
 
     properties::StringProperty  _colorTexturePath;
-	properties::StringProperty  _projectionTexturePath;
-	properties::IntProperty _rotation;
-	properties::FloatProperty _fadeProjection;
-	properties::BoolProperty _performProjection;
-	properties::BoolProperty _clearAllProjections;
+    properties::StringProperty  _projectionTexturePath;
+    properties::IntProperty _rotation;
+    properties::FloatProperty _fadeProjection;
+    properties::BoolProperty _performProjection;
+    properties::BoolProperty _clearAllProjections;
 
     std::unique_ptr<ghoul::opengl::ProgramObject> _programObject;
     std::unique_ptr<ghoul::opengl::ProgramObject> _fboProgramObject;
 
     std::unique_ptr<ghoul::opengl::Texture> _texture;
-	std::unique_ptr<ghoul::opengl::Texture> _textureOriginal;
-	std::unique_ptr<ghoul::opengl::Texture> _textureProj;
+    std::unique_ptr<ghoul::opengl::Texture> _textureOriginal;
+    std::unique_ptr<ghoul::opengl::Texture> _textureProj;
     std::unique_ptr<ghoul::opengl::Texture> _textureWhiteSquare;
-	planetgeometryprojection::PlanetGeometryProjection* _geometry;
-	
-	glm::vec2  _camScaling;
-	glm::vec3  _up;
-	glm::mat4  _transform;
-	glm::mat4  _projectorMatrix;
+    planetgeometryprojection::PlanetGeometryProjection* _geometry;
+    
+    glm::vec2  _camScaling;
+    glm::vec3  _up;
+    glm::mat4  _transform;
+    glm::mat4  _projectorMatrix;
 
-	//sequenceloading
-	std::string _sequenceSource;
-	std::string _sequenceType;
-	bool _foundSequence;
+    //sequenceloading
+    std::string _sequenceSource;
+    std::string _sequenceType;
+    bool _foundSequence;
 
-	// spice
-	std::string _instrumentID;
-	std::string _projectorID;
-	std::string _projecteeID;
+    // spice
+    std::string _instrumentID;
+    std::string _projectorID;
+    std::string _projecteeID;
     SpiceManager::AberrationCorrection _aberration;
     std::vector<std::string> _potentialTargets; // @TODO copy-n-paste from renderablefov
 
 
-	float _fovy;
-	float _aspectRatio;
-	float _nearPlane;
-	float _farPlane;
+    float _fovy;
+    float _aspectRatio;
+    float _nearPlane;
+    float _farPlane;
 
-	glm::dmat3 _stateMatrix;
-	glm::dmat3 _instrumentMatrix;
-	glm::vec3  _boresight;
+    glm::dmat3 _stateMatrix;
+    glm::dmat3 _instrumentMatrix;
+    glm::vec3  _boresight;
 
-	double _time;
-	double _previousTime;
-	double _previousCapture;
-	double lightTime;
+    double _time;
+    double _previousTime;
+    double _previousCapture;
+    double lightTime;
 
-	std::vector<Image> _imageTimes;
-	int _sequenceID;
+    std::vector<Image> _imageTimes;
+    int _sequenceID;
 
-	std::string _target;
-	std::string _frame;
-	std::string _defaultProjImage;
-	std::string _clearingImage;
-	std::string _next;
+    std::string _target;
+    std::string _frame;
+    std::string _defaultProjImage;
+    std::string _clearingImage;
+    std::string _next;
 
-	bool _capture;
+    bool _capture;
 
-	// FBO stuff
-	GLuint _fboID;
-	GLuint _quad;
-	GLuint _vertexPositionBuffer;
+    // FBO stuff
+    GLuint _fboID;
+    GLuint _quad;
+    GLuint _vertexPositionBuffer;
 
-	std::queue<Image> imageQueue;
+    std::queue<Image> imageQueue;
 };
 }  // namespace openspace
 
diff --git a/modules/newhorizons/rendering/renderableshadowcylinder.cpp b/modules/newhorizons/rendering/renderableshadowcylinder.cpp
index 0df082bec9..21c85c2523 100644
--- a/modules/newhorizons/rendering/renderableshadowcylinder.cpp
+++ b/modules/newhorizons/rendering/renderableshadowcylinder.cpp
@@ -37,73 +37,73 @@
 
 
 namespace {
-	const std::string _loggerCat      = "RenderablePlane";
-	const std::string _keyType        = "TerminatorType";
-	const std::string _keyLightSource = "LightSource";
-	const std::string _keyObserver    = "Observer";
-	const std::string _keyBody        = "Body";
-	const std::string _keyBodyFrame   = "BodyFrame";
-	const std::string _keyMainFrame   = "MainFrame";
-	const std::string _keyAberration  = "Aberration";
+    const std::string _loggerCat      = "RenderablePlane";
+    const std::string _keyType        = "TerminatorType";
+    const std::string _keyLightSource = "LightSource";
+    const std::string _keyObserver    = "Observer";
+    const std::string _keyBody        = "Body";
+    const std::string _keyBodyFrame   = "BodyFrame";
+    const std::string _keyMainFrame   = "MainFrame";
+    const std::string _keyAberration  = "Aberration";
 }
 
 namespace openspace {
-	RenderableShadowCylinder::RenderableShadowCylinder(const ghoul::Dictionary& dictionary)
-	: Renderable(dictionary)
-	, _numberOfPoints("amountOfPoints", "Points", 190, 1, 300)
-	, _shadowLength("shadowLength", "Shadow Length", 0.1, 0.0, 0.5)
+    RenderableShadowCylinder::RenderableShadowCylinder(const ghoul::Dictionary& dictionary)
+    : Renderable(dictionary)
+    , _numberOfPoints("amountOfPoints", "Points", 190, 1, 300)
+    , _shadowLength("shadowLength", "Shadow Length", 0.1, 0.0, 0.5)
     , _shadowColor("shadowColor", "Shadow Color",
                    glm::vec4(1.f, 1.f, 1.f, 0.25f), glm::vec4(0.f), glm::vec4(1.f))
-	, _shader(nullptr)
-	, _vao(0)
-	, _vbo(0)
+    , _shader(nullptr)
+    , _vao(0)
+    , _vbo(0)
 {
-	addProperty(_numberOfPoints);
-	addProperty(_shadowLength);
+    addProperty(_numberOfPoints);
+    addProperty(_shadowLength);
     addProperty(_shadowColor);
 
-	bool success = dictionary.getValue(_keyType, _terminatorType);
-	ghoul_assert(success, "");
-	success = dictionary.getValue(_keyLightSource, _lightSource);
-	ghoul_assert(success, "");
-	success = dictionary.getValue(_keyObserver, _observer);
-	ghoul_assert(success, "");
-	success = dictionary.getValue(_keyBody, _body);
-	ghoul_assert(success, "");
-	success = dictionary.getValue(_keyBodyFrame, _bodyFrame);
-	ghoul_assert(success, "");
-	success = dictionary.getValue(_keyMainFrame, _mainFrame);
-	ghoul_assert(success, "");
+    bool success = dictionary.getValue(_keyType, _terminatorType);
+    ghoul_assert(success, "");
+    success = dictionary.getValue(_keyLightSource, _lightSource);
+    ghoul_assert(success, "");
+    success = dictionary.getValue(_keyObserver, _observer);
+    ghoul_assert(success, "");
+    success = dictionary.getValue(_keyBody, _body);
+    ghoul_assert(success, "");
+    success = dictionary.getValue(_keyBodyFrame, _bodyFrame);
+    ghoul_assert(success, "");
+    success = dictionary.getValue(_keyMainFrame, _mainFrame);
+    ghoul_assert(success, "");
     std::string a = "NONE";
-	success = dictionary.getValue(_keyAberration, a);
+    success = dictionary.getValue(_keyAberration, a);
     _aberration = SpiceManager::AberrationCorrection(a);
-	ghoul_assert(success, "");
+    ghoul_assert(success, "");
 }
 
 RenderableShadowCylinder::~RenderableShadowCylinder() {
 }
 
 bool RenderableShadowCylinder::isReady() const {
-	bool ready = true;
-	if (!_shader)
-		ready &= false;
-	return ready;
+    bool ready = true;
+    if (!_shader)
+        ready &= false;
+    return ready;
 }
 
 bool RenderableShadowCylinder::initialize() {
-	glGenVertexArrays(1, &_vao); // generate array
-	glGenBuffers(1, &_vbo); // generate buffer
+    glGenVertexArrays(1, &_vao); // generate array
+    glGenBuffers(1, &_vbo); // generate buffer
 
-	bool completeSuccess = true;
+    bool completeSuccess = true;
 
     RenderEngine& renderEngine = OsEng.renderEngine();
     _shader = renderEngine.buildRenderProgram("ShadowProgram",
         "${MODULE_NEWHORIZONS}/shaders/terminatorshadow_vs.glsl",
         "${MODULE_NEWHORIZONS}/shaders/terminatorshadow_fs.glsl");
 
-	if (!_shader)
-		return false;
-	return completeSuccess;
+    if (!_shader)
+        return false;
+    return completeSuccess;
 }
 
 bool RenderableShadowCylinder::deinitialize() {
@@ -113,65 +113,65 @@ bool RenderableShadowCylinder::deinitialize() {
         _shader = nullptr;
     }
 
-	glDeleteVertexArrays(1, &_vao);
-	_vao = 0;
-	glDeleteBuffers(1, &_vbo);
-	_vbo = 0;
+    glDeleteVertexArrays(1, &_vao);
+    _vao = 0;
+    glDeleteBuffers(1, &_vbo);
+    _vbo = 0;
 
-	return true;
+    return true;
 }
 
 void RenderableShadowCylinder::render(const RenderData& data){
-	glm::mat4 _transform = glm::mat4(1.0);
-	for (int i = 0; i < 3; i++){
-		for (int j = 0; j < 3; j++){
-			_transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
-		}
-	}
+    glm::mat4 _transform = glm::mat4(1.0);
+    for (int i = 0; i < 3; i++){
+        for (int j = 0; j < 3; j++){
+            _transform[i][j] = static_cast<float>(_stateMatrix[i][j]);
+        }
+    }
 
     glDepthMask(false);
-	// Activate shader
-	_shader->activate();
+    // Activate shader
+    _shader->activate();
 
-	_shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
-	_shader->setUniform("ModelTransform", _transform);
+    _shader->setUniform("ViewProjection", data.camera.viewProjectionMatrix());
+    _shader->setUniform("ModelTransform", _transform);
     _shader->setUniform("shadowColor", _shadowColor);
-	setPscUniforms(*_shader.get(), data.camera, data.position);
-	
-	glBindVertexArray(_vao);
-	glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(_vertices.size()));
-	glBindVertexArray(0);
+    setPscUniforms(*_shader.get(), data.camera, data.position);
+    
+    glBindVertexArray(_vao);
+    glDrawArrays(GL_TRIANGLE_STRIP, 0, static_cast<GLsizei>(_vertices.size()));
+    glBindVertexArray(0);
 
-	_shader->deactivate();
+    _shader->deactivate();
 
     glDepthMask(true);
 }
 
 void RenderableShadowCylinder::update(const UpdateData& data) {
     _stateMatrix = SpiceManager::ref().positionTransformMatrix(_bodyFrame, _mainFrame, data.time);
-	_time = data.time;
-	if (_shader->isDirty())
-		_shader->rebuildFromFile();
-	createCylinder();
+    _time = data.time;
+    if (_shader->isDirty())
+        _shader->rebuildFromFile();
+    createCylinder();
 }
 
 glm::vec4 psc_addition(glm::vec4 v1, glm::vec4 v2) {
-	float k = 10.f;
-	float ds = v2.w - v1.w;
-	if (ds >= 0) {
-		float p = pow(k, -ds);
-		return glm::vec4(v1.x*p + v2.x, v1.y*p + v2.y, v1.z*p + v2.z, v2.w);
-	}
-	else {
-		float p = pow(k, ds);
-		return glm::vec4(v1.x + v2.x*p, v1.y + v2.y*p, v1.z + v2.z*p, v1.w);
-	}
+    float k = 10.f;
+    float ds = v2.w - v1.w;
+    if (ds >= 0) {
+        float p = pow(k, -ds);
+        return glm::vec4(v1.x*p + v2.x, v1.y*p + v2.y, v1.z*p + v2.z, v2.w);
+    }
+    else {
+        float p = pow(k, ds);
+        return glm::vec4(v1.x + v2.x*p, v1.y + v2.y*p, v1.z + v2.z*p, v1.w);
+    }
 }
 
 void RenderableShadowCylinder::createCylinder() {
-	double targetEpoch;
-	glm::dvec3 observerPosition;
-	std::vector<psc> terminatorPoints;
+    double targetEpoch;
+    glm::dvec3 observerPosition;
+    std::vector<psc> terminatorPoints;
     SpiceManager::TerminatorType t = SpiceManager::terminatorTypeFromString(_terminatorType);
 //    if (_terminatorType == "UMBRAL")
 //        t = SpiceManager::TerminatorType::Umbral;
@@ -191,34 +191,34 @@ void RenderableShadowCylinder::createCylinder() {
         terminatorPoints.push_back(psc);
     }
     
-	double lt;
+    double lt;
     glm::dvec3 vecLightSource =
         SpiceManager::ref().targetPosition(_body, _lightSource, _mainFrame, _aberration, _time, lt);
 
     glm::dmat3 _stateMatrix = glm::inverse(SpiceManager::ref().positionTransformMatrix(_bodyFrame, _mainFrame, _time));
 
-	vecLightSource = _stateMatrix * vecLightSource;
+    vecLightSource = _stateMatrix * vecLightSource;
 
-	vecLightSource *= _shadowLength;
-	_vertices.clear();
+    vecLightSource *= _shadowLength;
+    _vertices.clear();
 
-	psc endpoint = psc::CreatePowerScaledCoordinate(vecLightSource.x, vecLightSource.y, vecLightSource.z);
-	for (auto v : terminatorPoints){
-		_vertices.push_back(CylinderVBOLayout(v[0], v[1], v[2], v[3]));
-		glm::vec4 f = psc_addition(v.vec4(), endpoint.vec4());
-		_vertices.push_back(CylinderVBOLayout(f[0], f[1], f[2], f[3]));
-	}
-	_vertices.push_back(_vertices[0]);
-	_vertices.push_back(_vertices[1]);
+    psc endpoint = psc::CreatePowerScaledCoordinate(vecLightSource.x, vecLightSource.y, vecLightSource.z);
+    for (auto v : terminatorPoints){
+        _vertices.push_back(CylinderVBOLayout(v[0], v[1], v[2], v[3]));
+        glm::vec4 f = psc_addition(v.vec4(), endpoint.vec4());
+        _vertices.push_back(CylinderVBOLayout(f[0], f[1], f[2], f[3]));
+    }
+    _vertices.push_back(_vertices[0]);
+    _vertices.push_back(_vertices[1]);
 
-	glBindVertexArray(_vao); // bind array
-	glBindBuffer(GL_ARRAY_BUFFER, _vbo); // bind buffer
-	glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(CylinderVBOLayout), NULL, GL_DYNAMIC_DRAW); // orphaning the buffer, sending NULL data.
-	glBufferSubData(GL_ARRAY_BUFFER, 0, _vertices.size() * sizeof(CylinderVBOLayout), &_vertices[0]);
+    glBindVertexArray(_vao); // bind array
+    glBindBuffer(GL_ARRAY_BUFFER, _vbo); // bind buffer
+    glBufferData(GL_ARRAY_BUFFER, _vertices.size() * sizeof(CylinderVBOLayout), NULL, GL_DYNAMIC_DRAW); // orphaning the buffer, sending NULL data.
+    glBufferSubData(GL_ARRAY_BUFFER, 0, _vertices.size() * sizeof(CylinderVBOLayout), &_vertices[0]);
 
-	glEnableVertexAttribArray(0);
-	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
-	glBindVertexArray(0);
+    glEnableVertexAttribArray(0);
+    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
+    glBindVertexArray(0);
 }
 
 } // namespace openspace
diff --git a/modules/newhorizons/rendering/renderableshadowcylinder.h b/modules/newhorizons/rendering/renderableshadowcylinder.h
index 044579ac28..59b1f0ff5f 100644
--- a/modules/newhorizons/rendering/renderableshadowcylinder.h
+++ b/modules/newhorizons/rendering/renderableshadowcylinder.h
@@ -33,66 +33,66 @@
 #include <openspace/util/spicemanager.h>
 
 namespace ghoul {
-	namespace filesystem {
-		class File;
-	}
-	namespace opengl {
-		class ProgramObject;
-		class Texture;
-	}
+    namespace filesystem {
+        class File;
+    }
+    namespace opengl {
+        class ProgramObject;
+        class Texture;
+    }
 }
 
 namespace openspace {
-	struct LinePoint;
-	class RenderableShadowCylinder : public Renderable {
+    struct LinePoint;
+    class RenderableShadowCylinder : public Renderable {
 
-	public:
-		RenderableShadowCylinder(const ghoul::Dictionary& dictionary);
-		~RenderableShadowCylinder();
+    public:
+        RenderableShadowCylinder(const ghoul::Dictionary& dictionary);
+        ~RenderableShadowCylinder();
 
-		bool initialize() override;
-		bool deinitialize() override;
+        bool initialize() override;
+        bool deinitialize() override;
 
-		bool isReady() const override;
+        bool isReady() const override;
 
-		void render(const RenderData& data) override;
-		void update(const UpdateData& data) override;
+        void render(const RenderData& data) override;
+        void update(const UpdateData& data) override;
 
-	private:
-		struct CylinderVBOLayout {
-			CylinderVBOLayout(double a1, double a2, double a3, double a4){
-				x = a1;
-				y = a2;
-				z = a3;
-				e = a4;
-			}
-			float x, y, z, e;
-		};
+    private:
+        struct CylinderVBOLayout {
+            CylinderVBOLayout(double a1, double a2, double a3, double a4){
+                x = a1;
+                y = a2;
+                z = a3;
+                e = a4;
+            }
+            float x, y, z, e;
+        };
 
-		void createCylinder();
-		properties::IntProperty _numberOfPoints;
-		properties::FloatProperty _shadowLength;
+        void createCylinder();
+        properties::IntProperty _numberOfPoints;
+        properties::FloatProperty _shadowLength;
         properties::Vec4Property _shadowColor;
 
         std::unique_ptr<ghoul::opengl::ProgramObject> _shader;
-		
-		glm::dmat3 _stateMatrix;
+        
+        glm::dmat3 _stateMatrix;
 
-		GLuint _vao;
-		GLuint _vbo;
+        GLuint _vao;
+        GLuint _vbo;
 
-		std::vector<CylinderVBOLayout> _vertices;
+        std::vector<CylinderVBOLayout> _vertices;
 
-		std::string _terminatorType;
-		std::string _lightSource;
-		std::string _observer;
-		std::string _body;
-		std::string _bodyFrame;
-		std::string _mainFrame;
+        std::string _terminatorType;
+        std::string _lightSource;
+        std::string _observer;
+        std::string _body;
+        std::string _bodyFrame;
+        std::string _mainFrame;
         SpiceManager::AberrationCorrection _aberration;
-		
-		double _time;
-	};
+        
+        double _time;
+    };
 
 } // namespace openspace
 #endif // RENDERABLESHADOWCYLINDER_H_
diff --git a/modules/newhorizons/rendering/simplespheregeometryprojection.cpp b/modules/newhorizons/rendering/simplespheregeometryprojection.cpp
index 69c41a5fe6..965aa44846 100644
--- a/modules/newhorizons/rendering/simplespheregeometryprojection.cpp
+++ b/modules/newhorizons/rendering/simplespheregeometryprojection.cpp
@@ -42,48 +42,48 @@ namespace planetgeometryprojection {
 
 SimpleSphereGeometryProjection::SimpleSphereGeometryProjection(const ghoul::Dictionary& dictionary)
     : PlanetGeometryProjection()
-	, _realRadius("radius", "Radius", glm::vec4(1.f, 1.f, 1.f, 0.f), glm::vec4(-10.f, -10.f, -10.f, -20.f),
-				glm::vec4(10.f, 10.f, 10.f, 20.f))
+    , _realRadius("radius", "Radius", glm::vec4(1.f, 1.f, 1.f, 0.f), glm::vec4(-10.f, -10.f, -10.f, -20.f),
+                glm::vec4(10.f, 10.f, 10.f, 20.f))
     , _segments("segments", "Segments", 20, 1, 1000)
     , _planet(nullptr)
 {
-	using constants::simplespheregeometryprojection::keyRadius;
-	using constants::simplespheregeometryprojection::keySegments;
+    using constants::simplespheregeometryprojection::keyRadius;
+    using constants::simplespheregeometryprojection::keySegments;
 
-	// The name is passed down from the SceneGraphNode
+    // The name is passed down from the SceneGraphNode
     bool success = dictionary.getValue(SceneGraphNode::KeyName, _name);
-	assert(success);
+    assert(success);
 
-	// removing "Projection"-suffix from name for SPICE compability, TODO: better solution @AA
-	if(_name.find("Projection"))
-		_name = _name.substr(0, _name.size() - 10); 
+    // removing "Projection"-suffix from name for SPICE compability, TODO: better solution @AA
+    if(_name.find("Projection"))
+        _name = _name.substr(0, _name.size() - 10); 
 
     glm::vec4 radius;
-	success = dictionary.getValue(keyRadius, _modRadius);
-	if (!success) {
-		LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
+    success = dictionary.getValue(keyRadius, _modRadius);
+    if (!success) {
+        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                            << keyRadius << "'");
-	}
-	else {
-		radius[0] = _modRadius[0];
-		radius[1] = _modRadius[0];
-		radius[2] = _modRadius[0];
-		radius[3] = _modRadius[1];
-		_realRadius = radius;
-	}
+    }
+    else {
+        radius[0] = _modRadius[0];
+        radius[1] = _modRadius[0];
+        radius[2] = _modRadius[0];
+        radius[3] = _modRadius[1];
+        _realRadius = radius;
+    }
     double segments;
     success = dictionary.getValue(keySegments, segments);
-	if (!success) {
-		LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
+    if (!success) {
+        LERROR("SimpleSphereGeometry of '" << _name << "' did not provide a key '"
                                            << keySegments << "'");
-	}
-	else
-		_segments = static_cast<int>(segments);
+    }
+    else
+        _segments = static_cast<int>(segments);
 
-	addProperty(_realRadius);
-	//_realRadius.onChange(std::bind(&SimpleSphereGeometryProjection::createSphere, this));
+    addProperty(_realRadius);
+    //_realRadius.onChange(std::bind(&SimpleSphereGeometryProjection::createSphere, this));
     addProperty(_segments);
-	_segments.onChange(std::bind(&SimpleSphereGeometryProjection::createSphere, this));
+    _segments.onChange(std::bind(&SimpleSphereGeometryProjection::createSphere, this));
 }
 
 SimpleSphereGeometryProjection::~SimpleSphereGeometryProjection()
@@ -92,10 +92,10 @@ SimpleSphereGeometryProjection::~SimpleSphereGeometryProjection()
 
 bool SimpleSphereGeometryProjection::initialize(RenderablePlanetProjection* parent)
 {
-	bool success = PlanetGeometryProjection::initialize(parent);
+    bool success = PlanetGeometryProjection::initialize(parent);
     createSphere();
 
-	//need to have this accessible in planetgeometryprojection for now  -- Michal
+    //need to have this accessible in planetgeometryprojection for now  -- Michal
     return success;
 }
 
@@ -118,8 +118,8 @@ void SimpleSphereGeometryProjection::createSphere()
     _parent->setBoundingSphere(planetSize);
 
     delete _planet;
-	_planet = new PowerScaledSphere(_realRadius, _segments, _name);
-	_planet->initialize();
+    _planet = new PowerScaledSphere(_realRadius, _segments, _name);
+    _planet->initialize();
 }
 
 }  // namespace planetgeometry
diff --git a/modules/newhorizons/rendering/simplespheregeometryprojection.h b/modules/newhorizons/rendering/simplespheregeometryprojection.h
index 8c5d91fe4e..8907ed0739 100644
--- a/modules/newhorizons/rendering/simplespheregeometryprojection.h
+++ b/modules/newhorizons/rendering/simplespheregeometryprojection.h
@@ -38,21 +38,21 @@ namespace planetgeometryprojection {
 
 class SimpleSphereGeometryProjection : public PlanetGeometryProjection {
 public:
-	SimpleSphereGeometryProjection(const ghoul::Dictionary& dictionary);
-	~SimpleSphereGeometryProjection();
+    SimpleSphereGeometryProjection(const ghoul::Dictionary& dictionary);
+    ~SimpleSphereGeometryProjection();
 
 
-	bool initialize(RenderablePlanetProjection* parent) override;
+    bool initialize(RenderablePlanetProjection* parent) override;
     void deinitialize() override;
     void render() override;
 
 private:
     void createSphere();
 
-	glm::vec2 _modRadius;
-	properties::Vec4Property _realRadius;
+    glm::vec2 _modRadius;
+    properties::Vec4Property _realRadius;
     properties::IntProperty _segments;
-	std::string _name;
+    std::string _name;
 
     PowerScaledSphere* _planet;
 };
diff --git a/modules/newhorizons/rendering/writeToTexture.h b/modules/newhorizons/rendering/writeToTexture.h
index 6d2948a09b..cd0e584f60 100644
--- a/modules/newhorizons/rendering/writeToTexture.h
+++ b/modules/newhorizons/rendering/writeToTexture.h
@@ -49,7 +49,7 @@ public:
     bool initialize() override;
     bool deinitialize() override;
 
-	void render(const RenderData& data) override;
+    void render(const RenderData& data) override;
     void update(const UpdateData& data) override;
 
 protected:
@@ -61,9 +61,9 @@ private:
     ghoul::opengl::Texture* _texture;
     planetgeometry::PlanetGeometry* _geometry;
 
-	glm::dmat3 _stateMatrix;
+    glm::dmat3 _stateMatrix;
 
-	std::string _target;
+    std::string _target;
 };
 
 }  // namespace openspace
diff --git a/modules/newhorizons/shaders/crawlingline_fs.glsl b/modules/newhorizons/shaders/crawlingline_fs.glsl
index 0d9f273637..a01baaf749 100644
--- a/modules/newhorizons/shaders/crawlingline_fs.glsl
+++ b/modules/newhorizons/shaders/crawlingline_fs.glsl
@@ -34,10 +34,10 @@ in vec4 vs_color;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	vec4 diffuse = vs_color;
-	float depth = pscDepth(position);
-	diffuse.a = _alpha;
+    vec4 position = vs_position;
+    vec4 diffuse = vs_color;
+    float depth = pscDepth(position);
+    diffuse.a = _alpha;
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/newhorizons/shaders/crawlingline_vs.glsl b/modules/newhorizons/shaders/crawlingline_vs.glsl
index 90d009da8d..d5e5b1b681 100644
--- a/modules/newhorizons/shaders/crawlingline_vs.glsl
+++ b/modules/newhorizons/shaders/crawlingline_vs.glsl
@@ -38,19 +38,19 @@ const int targetId = 1;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vs_position = in_position;
-	vec4 tmp = in_position;
-	int id = gl_VertexID;
-	
-	vec3 black = vec3(0.0);
+    vs_position = in_position;
+    vec4 tmp = in_position;
+    int id = gl_VertexID;
+    
+    vec3 black = vec3(0.0);
 
-	if(id == targetId)
-		vs_color.xyz = black;
-	else
-		vs_color.xyz = color;
-		
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    if(id == targetId)
+        vs_color.xyz = black;
+    else
+        vs_color.xyz = color;
+        
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/newhorizons/shaders/fov_fs.glsl b/modules/newhorizons/shaders/fov_fs.glsl
index b8a8b6b9be..8df343f683 100644
--- a/modules/newhorizons/shaders/fov_fs.glsl
+++ b/modules/newhorizons/shaders/fov_fs.glsl
@@ -36,15 +36,15 @@ in vec4 vs_point_velocity;
 
 Fragment getFragment() {
 
-	vec4 position = vs_point_position;
-	float depth = pscDepth(position);
-	
-	// set the depth
-	//gl_FragDepth = depth;
+    vec4 position = vs_point_position;
+    float depth = pscDepth(position);
+    
+    // set the depth
+    //gl_FragDepth = depth;
 
-	//float l = length(vs_point_velocity);
-	
-	vec4 diffuse = vs_point_velocity;
+    //float l = length(vs_point_velocity);
+    
+    vec4 diffuse = vs_point_velocity;
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/newhorizons/shaders/fov_vs.glsl b/modules/newhorizons/shaders/fov_vs.glsl
index 8c4158d6cd..31841d408e 100644
--- a/modules/newhorizons/shaders/fov_vs.glsl
+++ b/modules/newhorizons/shaders/fov_vs.glsl
@@ -41,38 +41,38 @@ out vec4 vs_point_velocity;
 
 void main()
 {
-	vs_point_velocity = in_point_velocity;
+    vs_point_velocity = in_point_velocity;
 
-	vec4 tmp = in_point_position;
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_point_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vec4 tmp = in_point_position;
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_point_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 /*
-	//vs_point_position = objpos;
+    //vs_point_position = objpos;
 
-	// rotate and scale vertex with model transform and add the translation
-	vec3 local_vertex_pos = mat3(ModelTransform) * in_point_position.xyz;
-	//vec4 lvp = ModelTransform * in_point_position;
+    // rotate and scale vertex with model transform and add the translation
+    vec3 local_vertex_pos = mat3(ModelTransform) * in_point_position.xyz;
+    //vec4 lvp = ModelTransform * in_point_position;
 
-	// PSC addition; local vertex position and the object power scaled world position
-	vs_point_position = psc_addition(vec4(local_vertex_pos,in_point_position.w),objpos);
-	//vs_point_position = psc_addition(lvp,objpos);
-	
-	// PSC addition; rotated and viewscaled vertex and the cmaeras negative position
-	vs_point_position = psc_addition(vs_point_position,vec4(-campos.xyz,campos.w));
-	
-	// rotate the camera
-	local_vertex_pos =  mat3(camrot) * vs_point_position.xyz;
-	vs_point_position = vec4(local_vertex_pos, vs_point_position.w);
-	//vs_point_position =  camrot* vs_point_position;
+    // PSC addition; local vertex position and the object power scaled world position
+    vs_point_position = psc_addition(vec4(local_vertex_pos,in_point_position.w),objpos);
+    //vs_point_position = psc_addition(lvp,objpos);
+    
+    // PSC addition; rotated and viewscaled vertex and the cmaeras negative position
+    vs_point_position = psc_addition(vs_point_position,vec4(-campos.xyz,campos.w));
+    
+    // rotate the camera
+    local_vertex_pos =  mat3(camrot) * vs_point_position.xyz;
+    vs_point_position = vec4(local_vertex_pos, vs_point_position.w);
+    //vs_point_position =  camrot* vs_point_position;
 
-	// project using the rescaled coordinates,
-	//vec4 vs_point_position_rescaled = psc_scaling(vs_point_position, scaling);
-	vec4 vs_point_position_rescaled = psc_to_meter(vs_point_position, scaling);
-	//vs_point_position = vs_point_position_rescaled;
+    // project using the rescaled coordinates,
+    //vec4 vs_point_position_rescaled = psc_scaling(vs_point_position, scaling);
+    vec4 vs_point_position_rescaled = psc_to_meter(vs_point_position, scaling);
+    //vs_point_position = vs_point_position_rescaled;
 
-	// project the position to view space
-	gl_Position =  ViewProjection * vs_point_position_rescaled;
-	*/
+    // project the position to view space
+    gl_Position =  ViewProjection * vs_point_position_rescaled;
+    */
 }
\ No newline at end of file
diff --git a/modules/newhorizons/shaders/modelShader_fs.glsl b/modules/newhorizons/shaders/modelShader_fs.glsl
index 33577b0ffb..b0f338ffee 100644
--- a/modules/newhorizons/shaders/modelShader_fs.glsl
+++ b/modules/newhorizons/shaders/modelShader_fs.glsl
@@ -43,46 +43,46 @@ uniform vec3 sun_pos;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse = texture(currentTexture, vs_st);
-	
-	// directional lighting
-	vec3 origin = vec3(0.0);
-	vec4 spec = vec4(0.0);
-	
-	vec3 n = normalize(vs_normal.xyz);
-	vec3 e = normalize(camdir);
-	vec3 l_pos = sun_pos;
-	vec3 l_dir = normalize(l_pos-objpos.xyz);
-	float intensity = 1;
-	
-	if (_performShading) {
-		float terminatorBright = 0.4;
-		intensity = min(max(5*dot(n,l_dir), terminatorBright), 1);
-	}
-	
-	float shine = 0.0001;
-	vec4 specular = vec4(0.1);
-	vec4 ambient = vec4(0.f,0.f,0.f,1);
-	 //Specular
-	if (intensity > 0.f) {
-		vec3 h = normalize(l_dir + e);
-		float intSpec = max(dot(h,n),0.0);
-		spec = specular * pow(intSpec, shine);
-	}
-	
-	vec4 projTexColor = textureProj(projectedTexture, ProjTexCoord);
-	vec4 shaded = max(intensity * diffuse, ambient);
-	if (ProjTexCoord[0] > 0.0 || ProjTexCoord[1] > 0.0 ||
-		ProjTexCoord[0] < ProjTexCoord[2] || 
-		ProjTexCoord[1] < ProjTexCoord[2]) {
-		diffuse = shaded;
-	} else if (dot(n, boresight) < 0 && projTexColor.w != 0) {// frontfacing
-		diffuse = projTexColor;
-	} else {
-		diffuse = shaded;
-	}
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse = texture(currentTexture, vs_st);
+    
+    // directional lighting
+    vec3 origin = vec3(0.0);
+    vec4 spec = vec4(0.0);
+    
+    vec3 n = normalize(vs_normal.xyz);
+    vec3 e = normalize(camdir);
+    vec3 l_pos = sun_pos;
+    vec3 l_dir = normalize(l_pos-objpos.xyz);
+    float intensity = 1;
+    
+    if (_performShading) {
+        float terminatorBright = 0.4;
+        intensity = min(max(5*dot(n,l_dir), terminatorBright), 1);
+    }
+    
+    float shine = 0.0001;
+    vec4 specular = vec4(0.1);
+    vec4 ambient = vec4(0.f,0.f,0.f,1);
+     //Specular
+    if (intensity > 0.f) {
+        vec3 h = normalize(l_dir + e);
+        float intSpec = max(dot(h,n),0.0);
+        spec = specular * pow(intSpec, shine);
+    }
+    
+    vec4 projTexColor = textureProj(projectedTexture, ProjTexCoord);
+    vec4 shaded = max(intensity * diffuse, ambient);
+    if (ProjTexCoord[0] > 0.0 || ProjTexCoord[1] > 0.0 ||
+        ProjTexCoord[0] < ProjTexCoord[2] || 
+        ProjTexCoord[1] < ProjTexCoord[2]) {
+        diffuse = shaded;
+    } else if (dot(n, boresight) < 0 && projTexColor.w != 0) {// frontfacing
+        diffuse = projTexColor;
+    } else {
+        diffuse = shaded;
+    }
 
     Fragment frag;
     frag.color = diffuse;
diff --git a/modules/newhorizons/shaders/modelShader_vs.glsl b/modules/newhorizons/shaders/modelShader_vs.glsl
index 4f047a8587..74eacac727 100644
--- a/modules/newhorizons/shaders/modelShader_vs.glsl
+++ b/modules/newhorizons/shaders/modelShader_vs.glsl
@@ -48,16 +48,16 @@ void main() {
     vec4 pos = in_position;
     pos.w += _magnification;
 
-	vs_st = in_st;
-	vs_position = pos;
-	vec4 tmp    = pos;
-	
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
+    vs_st = in_st;
+    vs_position = pos;
+    vec4 tmp    = pos;
+    
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
 
-	vec4 raw_pos = psc_to_meter(pos, scaling);
-	ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    vec4 raw_pos = psc_to_meter(pos, scaling);
+    ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
diff --git a/modules/newhorizons/shaders/projectionPass_fs.glsl b/modules/newhorizons/shaders/projectionPass_fs.glsl
index 0d52346019..bc3ce2fc38 100644
--- a/modules/newhorizons/shaders/projectionPass_fs.glsl
+++ b/modules/newhorizons/shaders/projectionPass_fs.glsl
@@ -43,7 +43,7 @@ out vec4 color;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 bool inRange(float x, float a, float b) {
-	return (x >= a && x <= b);
+    return (x >= a && x <= b);
 } 
 
 void main() {
@@ -60,9 +60,9 @@ void main() {
   projected.y = 1 - projected.y; 
   
   if((inRange(projected.x, 0, 1) && inRange(projected.y, 0, 1)) && (dot(n, boresight) < 0)) {
-		color = texture(projectTexture, projected.xy);
+        color = texture(projectTexture, projected.xy);
   } else {
-		color = texture(currentTexture, uv);
+        color = texture(currentTexture, uv);
   }
 
 }
\ No newline at end of file
diff --git a/modules/newhorizons/shaders/projectionPass_vs.glsl b/modules/newhorizons/shaders/projectionPass_vs.glsl
index 09b67bc359..0fed1ba6ee 100644
--- a/modules/newhorizons/shaders/projectionPass_vs.glsl
+++ b/modules/newhorizons/shaders/projectionPass_vs.glsl
@@ -42,20 +42,20 @@ out vec4 vs_normal;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vs_position  = in_position;
-	
-	vec4 tmp    = in_position;
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
+    vs_position  = in_position;
+    
+    vec4 tmp    = in_position;
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
 
-	vec4 raw_pos = psc_to_meter(in_position, _scaling);
-	ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
-	
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	
-	//match clipping plane
-	vec2 texco = (in_st * 2) - 1; 
-	vs_uv = texco;
-	gl_Position = vec4(texco, 0.0, 1.0);
+    vec4 raw_pos = psc_to_meter(in_position, _scaling);
+    ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
+    
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    
+    //match clipping plane
+    vec2 texco = (in_st * 2) - 1; 
+    vs_uv = texco;
+    gl_Position = vec4(texco, 0.0, 1.0);
 
 }
diff --git a/modules/newhorizons/shaders/projectiveTexture_fs.glsl b/modules/newhorizons/shaders/projectiveTexture_fs.glsl
index 61a922ab0a..d48d951316 100644
--- a/modules/newhorizons/shaders/projectiveTexture_fs.glsl
+++ b/modules/newhorizons/shaders/projectiveTexture_fs.glsl
@@ -43,39 +43,39 @@ uniform vec3 sun_pos;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse = texture(texture1, vs_st);
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse = texture(texture1, vs_st);
 
-	// directional lighting
-	vec3 origin = vec3(0.0);
-	vec4 spec = vec4(0.0);
-	
-	vec3 n = normalize(vs_normal.xyz);
-	//vec3 e = normalize(camdir);
-	vec3 l_pos = sun_pos; // sun.
-	vec3 l_dir = normalize(l_pos-objpos.xyz);
-	float terminatorBright = 0.4;
-	float intensity = min(max(5*dot(n,l_dir), terminatorBright), 1);
-	
-	float shine = 0.0001;
+    // directional lighting
+    vec3 origin = vec3(0.0);
+    vec4 spec = vec4(0.0);
+    
+    vec3 n = normalize(vs_normal.xyz);
+    //vec3 e = normalize(camdir);
+    vec3 l_pos = sun_pos; // sun.
+    vec3 l_dir = normalize(l_pos-objpos.xyz);
+    float terminatorBright = 0.4;
+    float intensity = min(max(5*dot(n,l_dir), terminatorBright), 1);
+    
+    float shine = 0.0001;
 
-	vec4 specular = vec4(0.1);
-	vec4 ambient = vec4(0.f,0.f,0.f,1);
-	/* Specular
-	if(intensity > 0.f){
-		// halfway vector
-		vec3 h = normalize(l_dir + e);
-		// specular factor
-		float intSpec = max(dot(h,n),0.0);
-		spec = specular * pow(intSpec, shine);
-	}
-	*/
-	//diffuse = max(intensity * diffuse, ambient);
-	
-	// PROJECTIVE TEXTURE
-	vec4 projTexColor = textureProj(texture2, ProjTexCoord);
-	vec4 shaded = max(intensity * diffuse, ambient);
+    vec4 specular = vec4(0.1);
+    vec4 ambient = vec4(0.f,0.f,0.f,1);
+    /* Specular
+    if(intensity > 0.f){
+        // halfway vector
+        vec3 h = normalize(l_dir + e);
+        // specular factor
+        float intSpec = max(dot(h,n),0.0);
+        spec = specular * pow(intSpec, shine);
+    }
+    */
+    //diffuse = max(intensity * diffuse, ambient);
+    
+    // PROJECTIVE TEXTURE
+    vec4 projTexColor = textureProj(texture2, ProjTexCoord);
+    vec4 shaded = max(intensity * diffuse, ambient);
     if (ProjTexCoord[0] > 0.0 ||
         ProjTexCoord[1] > 0.0 ||
         ProjTexCoord[0] < ProjTexCoord[2] ||
diff --git a/modules/newhorizons/shaders/projectiveTexture_vs.glsl b/modules/newhorizons/shaders/projectiveTexture_vs.glsl
index de6a755682..b2d83a5982 100644
--- a/modules/newhorizons/shaders/projectiveTexture_vs.glsl
+++ b/modules/newhorizons/shaders/projectiveTexture_vs.glsl
@@ -47,24 +47,24 @@ out float s;
 out vec4 ProjTexCoord;
 #include "PowerScaling/powerScaling_vs.hglsl"
 void main(){
-	// Radius = 0.71492 *10^8; 
-	// set variables
-	vs_st = in_st;
-	//vs_stp = in_position.xyz;
-	vs_position = in_position;
-	vec4 tmp    = in_position;
-	
-	// this is wrong for the normal. 
-	// The normal transform is the transposed inverse of the model transform
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
+    // Radius = 0.71492 *10^8; 
+    // set variables
+    vs_st = in_st;
+    //vs_stp = in_position.xyz;
+    vs_position = in_position;
+    vec4 tmp    = in_position;
+    
+    // this is wrong for the normal. 
+    // The normal transform is the transposed inverse of the model transform
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
 
-	vec4 raw_pos = psc_to_meter(in_position, scaling);
-	ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
+    vec4 raw_pos = psc_to_meter(in_position, scaling);
+    ProjTexCoord = ProjectorMatrix * ModelTransform * raw_pos;
 
-	position = ViewProjection * position;
+    position = ViewProjection * position;
 
-	gl_Position =  z_normalization(position);
+    gl_Position =  z_normalization(position);
 }
diff --git a/modules/newhorizons/shaders/terminatorshadow_fs.glsl b/modules/newhorizons/shaders/terminatorshadow_fs.glsl
index b840641734..ca3301e649 100644
--- a/modules/newhorizons/shaders/terminatorshadow_fs.glsl
+++ b/modules/newhorizons/shaders/terminatorshadow_fs.glsl
@@ -37,7 +37,7 @@ in vec4 vs_color;
 Fragment getFragment() {
     vec4 position = vs_point_position;
     float depth = pscDepth(position);
-	
+    
     Fragment frag;
     frag.color = vs_color;
     frag.depth = depth;
diff --git a/modules/newhorizons/shaders/terminatorshadow_vs.glsl b/modules/newhorizons/shaders/terminatorshadow_vs.glsl
index 1ef34780d1..a944a28691 100644
--- a/modules/newhorizons/shaders/terminatorshadow_vs.glsl
+++ b/modules/newhorizons/shaders/terminatorshadow_vs.glsl
@@ -43,19 +43,19 @@ uniform vec4 shadowColor;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	//float id = float(gl_VertexID) / float(nVertices * lineFade);
-	//fade = 1.0 - id;
+    //float id = float(gl_VertexID) / float(nVertices * lineFade);
+    //fade = 1.0 - id;
 
-	if(mod(gl_VertexID,2) == 0.f){
-		vs_color = shadowColor;
-	}else{
-		vs_color = vec4(0);
-	}
-	
-	vec4 tmp = in_point_position;
-	//tmp = psc_to_meter(tmp, vec2(1,0.f));
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_point_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    if(mod(gl_VertexID,2) == 0.f){
+        vs_color = shadowColor;
+    }else{
+        vs_color = vec4(0);
+    }
+    
+    vec4 tmp = in_point_position;
+    //tmp = psc_to_meter(tmp, vec2(1,0.f));
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_point_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/modules/newhorizons/util/decoder.cpp b/modules/newhorizons/util/decoder.cpp
index a0ccd162b4..8e373ef0f8 100644
--- a/modules/newhorizons/util/decoder.cpp
+++ b/modules/newhorizons/util/decoder.cpp
@@ -34,9 +34,9 @@ namespace openspace {
 
 Decoder* Decoder::createFromDictionary(const ghoul::Dictionary& dictionary, const std::string type)
 {
-	ghoul::TemplateFactory<Decoder>* factory
-		= FactoryManager::ref().factory<Decoder>();
-	Decoder* result = factory->create(type, dictionary);
+    ghoul::TemplateFactory<Decoder>* factory
+        = FactoryManager::ref().factory<Decoder>();
+    Decoder* result = factory->create(type, dictionary);
 
     if (result == nullptr) {
         LERROR("Failed creating Payload object of type '" << type << "'");
diff --git a/modules/newhorizons/util/decoder.h b/modules/newhorizons/util/decoder.h
index a4cebe7d5c..99592f0f07 100644
--- a/modules/newhorizons/util/decoder.h
+++ b/modules/newhorizons/util/decoder.h
@@ -32,14 +32,14 @@ namespace openspace {
 
 class Decoder {
 public:
-	static Decoder* createFromDictionary(const ghoul::Dictionary& dictionary, const std::string type);
+    static Decoder* createFromDictionary(const ghoul::Dictionary& dictionary, const std::string type);
 
-	Decoder(const ghoul::Dictionary& dictionary);
-	virtual ~Decoder();
-	virtual std::string getDecoderType() = 0;
-	virtual std::vector<std::string> getTranslation() = 0;
+    Decoder(const ghoul::Dictionary& dictionary);
+    virtual ~Decoder();
+    virtual std::string getDecoderType() = 0;
+    virtual std::vector<std::string> getTranslation() = 0;
 protected:
-	Decoder();
+    Decoder();
 };
 
 }  // namespace openspace
diff --git a/modules/newhorizons/util/hongkangparser.cpp b/modules/newhorizons/util/hongkangparser.cpp
index 1baffe9e16..ca32d28388 100644
--- a/modules/newhorizons/util/hongkangparser.cpp
+++ b/modules/newhorizons/util/hongkangparser.cpp
@@ -36,66 +36,66 @@
 
 
 namespace {
-	const std::string _loggerCat = "HongKangParser";
-	const std::string keyTranslation = "DataInputTranslation";
+    const std::string _loggerCat = "HongKangParser";
+    const std::string keyTranslation = "DataInputTranslation";
 
     const std::string PlaybookIdentifierName = "HongKang";
 }
 
 namespace openspace {
 HongKangParser::HongKangParser(std::string name, const std::string& fileName,
-		                       std::string spacecraft,
-							   ghoul::Dictionary translationDictionary,
-		                       std::vector<std::string> potentialTargets)
+                               std::string spacecraft,
+                               ghoul::Dictionary translationDictionary,
+                               std::vector<std::string> potentialTargets)
     : _name(std::move(name))
     , _defaultCaptureImage(absPath("${OPENSPACE_DATA}/scene/common/textures/placeholder.png"))
 {
-	_fileName          = fileName;
-	_spacecraft        = spacecraft;
-	_potentialTargets  = potentialTargets;
-	
-	//get the different instrument types
-	const std::vector<std::string>& decoders = translationDictionary.keys();
-	//for each decoder (assuming might have more if hong makes changes)
-	for (int i = 0; i < decoders.size(); i++){
-		//create dictionary containing all {playbookKeys , spice IDs}
-		if (decoders[i] == "Instrument"){
-			ghoul::Dictionary typeDictionary;
-			translationDictionary.getValue(decoders[i], typeDictionary);
-			//for each playbook call -> create a Decoder object
-			const std::vector<std::string>& keys = typeDictionary.keys();
-			//std::string abort = decoders[i] + "." + keyStopCommand;
-			for (int j = 0; j < keys.size(); j++){
-				std::string currentKey = decoders[i] + "." + keys[j];
-				
-				ghoul::Dictionary decoderDictionary;
-				translationDictionary.getValue(currentKey, decoderDictionary);
+    _fileName          = fileName;
+    _spacecraft        = spacecraft;
+    _potentialTargets  = potentialTargets;
+    
+    //get the different instrument types
+    const std::vector<std::string>& decoders = translationDictionary.keys();
+    //for each decoder (assuming might have more if hong makes changes)
+    for (int i = 0; i < decoders.size(); i++){
+        //create dictionary containing all {playbookKeys , spice IDs}
+        if (decoders[i] == "Instrument"){
+            ghoul::Dictionary typeDictionary;
+            translationDictionary.getValue(decoders[i], typeDictionary);
+            //for each playbook call -> create a Decoder object
+            const std::vector<std::string>& keys = typeDictionary.keys();
+            //std::string abort = decoders[i] + "." + keyStopCommand;
+            for (int j = 0; j < keys.size(); j++){
+                std::string currentKey = decoders[i] + "." + keys[j];
+                
+                ghoul::Dictionary decoderDictionary;
+                translationDictionary.getValue(currentKey, decoderDictionary);
 
-				Decoder *decoder = Decoder::createFromDictionary(decoderDictionary, decoders[i]);
-				//insert decoder to map - this will be used in the parser to determine
-				//behavioral characteristics of each instrument
-				_fileTranslation[keys[j]] = decoder;
-			}
-		}
-		//Hong's playbook needs _only_ instrument translation though.
-	}
+                Decoder *decoder = Decoder::createFromDictionary(decoderDictionary, decoders[i]);
+                //insert decoder to map - this will be used in the parser to determine
+                //behavioral characteristics of each instrument
+                _fileTranslation[keys[j]] = decoder;
+            }
+        }
+        //Hong's playbook needs _only_ instrument translation though.
+    }
 }
 
 void HongKangParser::findPlaybookSpecifiedTarget(std::string line, std::string& target){
-	//remembto add this lua later... 
-	std::vector<std::string> ptarg = _potentialTargets;
-	for (auto p : ptarg){
-		// loop over all targets and determine from 4th col which target this instrument points to
-		std::transform(line.begin(), line.end(), line.begin(), toupper);
-		if (line.find(p) != std::string::npos){
-			target = p;
-			break;
-		}
-		else{
-		// not found - we set void until we have more info. 
-			target = "VOID";
-		}
-	}
+    //remembto add this lua later... 
+    std::vector<std::string> ptarg = _potentialTargets;
+    for (auto p : ptarg){
+        // loop over all targets and determine from 4th col which target this instrument points to
+        std::transform(line.begin(), line.end(), line.begin(), toupper);
+        if (line.find(p) != std::string::npos){
+            target = p;
+            break;
+        }
+        else{
+        // not found - we set void until we have more info. 
+            target = "VOID";
+        }
+    }
 }
 
 void HongKangParser::writeUTCEventFile(const Image image){
@@ -114,153 +114,153 @@ void HongKangParser::writeUTCEventFile(const Image image){
 }
 
 bool HongKangParser::create(){
-	//check input for errors. 
-	int tmp;
+    //check input for errors. 
+    int tmp;
     bool hasObserver = SpiceManager::ref().hasNaifId(_spacecraft);
     tmp = SpiceManager::ref().naifId(_spacecraft);
-	if (!hasObserver){
-		LERROR("SPICE navigation system has no pooled observer: '" << _spacecraft << "' in kernel" <<
-			   "Please check that all necessary kernels are loaded"<<
-			   "along with correct modfile definition.");
-		return hasObserver;
-	}
-	if (_potentialTargets.size() == 0){
-		LERROR("In order to find targeting from event file user has to provide list of potential targets "
-			   << "please check modfile");
-	}
+    if (!hasObserver){
+        LERROR("SPICE navigation system has no pooled observer: '" << _spacecraft << "' in kernel" <<
+               "Please check that all necessary kernels are loaded"<<
+               "along with correct modfile definition.");
+        return hasObserver;
+    }
+    if (_potentialTargets.size() == 0){
+        LERROR("In order to find targeting from event file user has to provide list of potential targets "
+               << "please check modfile");
+    }
 
-	_eventsAsUTCFile.open("utcEvents.txt");
+    _eventsAsUTCFile.open("utcEvents.txt");
 
-	if (size_t position = _fileName.find_last_of(".") + 1){
-		if (position != std::string::npos){
-			std::string extension = ghoul::filesystem::File(_fileName).fileExtension();
+    if (size_t position = _fileName.find_last_of(".") + 1){
+        if (position != std::string::npos){
+            std::string extension = ghoul::filesystem::File(_fileName).fileExtension();
 
-			if (extension == "txt") {// Hong Kang. pre-parsed playbook
-				LINFO("Using Preparsed Playbook V9H");
-				std::ifstream file(_fileName , std::ios::binary);
-				if (!file.good()){
-					LERROR("Failed to open event file '" << _fileName << "'");
-					return false;
-				}
+            if (extension == "txt") {// Hong Kang. pre-parsed playbook
+                LINFO("Using Preparsed Playbook V9H");
+                std::ifstream file(_fileName , std::ios::binary);
+                if (!file.good()){
+                    LERROR("Failed to open event file '" << _fileName << "'");
+                    return false;
+                }
 
-				std::string line = "";
-				double shutter = 0.01;
+                std::string line = "";
+                double shutter = 0.01;
 
-				std::string previousTarget;
+                std::string previousTarget;
 
-				std::string previousCamera;
-				std::string previousScanner;
+                std::string previousCamera;
+                std::string previousScanner;
 
-				TimeRange cameraRange;
-				TimeRange scanRange;
+                TimeRange cameraRange;
+                TimeRange scanRange;
 
-				std::vector<std::string> scannerSpiceID;
-				std::vector<std::string> cameraSpiceID;
+                std::vector<std::string> scannerSpiceID;
+                std::vector<std::string> cameraSpiceID;
 
-				double capture_start = -1;
-				double capture_stop = -1;
-				double scan_start = -1;
-				double scan_stop = -1;
+                double capture_start = -1;
+                double capture_stop = -1;
+                double scan_start = -1;
+                double scan_stop = -1;
 
-				std::string cameraTarget  = "VOID";
-				std::string scannerTarget = "VOID";
+                std::string cameraTarget  = "VOID";
+                std::string scannerTarget = "VOID";
 
-				while (!file.eof()){
-					std::getline(file, line);
-					
-					std::string event = line.substr(0, line.find_first_of(" ")); 
+                while (!file.eof()){
+                    std::getline(file, line);
+                    
+                    std::string event = line.substr(0, line.find_first_of(" ")); 
 
-					auto it = _fileTranslation.find(event);
-					bool foundEvent = (it != _fileTranslation.end());
+                    auto it = _fileTranslation.find(event);
+                    bool foundEvent = (it != _fileTranslation.end());
 
-					std::string met = line.substr(25, 9);
-					double time = getETfromMet(met);
+                    std::string met = line.substr(25, 9);
+                    double time = getETfromMet(met);
 
-					Image image;
-					
-					if (foundEvent){
-						//store the time, this is used for getNextCaptureTime() 
-						_captureProgression.push_back(time);
-						
-						if (it->second->getDecoderType() == "CAMERA"){
-							if (capture_start == -1){
-								//encountered new camera sequence- store start time
-								capture_start = time;
-								previousCamera = it->first;
-							}
-							//always store individual image for camera
-							cameraSpiceID = it->second->getTranslation();
-							//rely on playboook mdl column to determine target
-							findPlaybookSpecifiedTarget(line, cameraTarget);
+                    Image image;
+                    
+                    if (foundEvent){
+                        //store the time, this is used for getNextCaptureTime() 
+                        _captureProgression.push_back(time);
+                        
+                        if (it->second->getDecoderType() == "CAMERA"){
+                            if (capture_start == -1){
+                                //encountered new camera sequence- store start time
+                                capture_start = time;
+                                previousCamera = it->first;
+                            }
+                            //always store individual image for camera
+                            cameraSpiceID = it->second->getTranslation();
+                            //rely on playboook mdl column to determine target
+                            findPlaybookSpecifiedTarget(line, cameraTarget);
 
-							//fill image
-							createImage(image, time, time + shutter, cameraSpiceID, cameraTarget, _defaultCaptureImage);
-							writeUTCEventFile(image);
-							//IFF spaccraft has decided to switch target, store in target map (used for: 'next observation focus')
-							if (previousTarget != image.target){
-								previousTarget = image.target;
-								std::pair<double, std::string> v_target = std::make_pair(time, image.target);
-								_targetTimes.push_back(v_target);
-							}
+                            //fill image
+                            createImage(image, time, time + shutter, cameraSpiceID, cameraTarget, _defaultCaptureImage);
+                            writeUTCEventFile(image);
+                            //IFF spaccraft has decided to switch target, store in target map (used for: 'next observation focus')
+                            if (previousTarget != image.target){
+                                previousTarget = image.target;
+                                std::pair<double, std::string> v_target = std::make_pair(time, image.target);
+                                _targetTimes.push_back(v_target);
+                            }
 
-							//store actual image in map. All targets get _only_ their corresp. subset.
-							_subsetMap[image.target]._subset.push_back(image);
-							//compute and store the range for each subset 
-							_subsetMap[image.target]._range.setRange(time);
-						}
-						if (it->second->getDecoderType() == "SCANNER"){ // SCANNER START 
-							scan_start = time;
+                            //store actual image in map. All targets get _only_ their corresp. subset.
+                            _subsetMap[image.target]._subset.push_back(image);
+                            //compute and store the range for each subset 
+                            _subsetMap[image.target]._range.setRange(time);
+                        }
+                        if (it->second->getDecoderType() == "SCANNER"){ // SCANNER START 
+                            scan_start = time;
 
-							InstrumentDecoder* scanner = static_cast<InstrumentDecoder*>(it->second);
-							std::string endNominal = scanner->getStopCommand();
+                            InstrumentDecoder* scanner = static_cast<InstrumentDecoder*>(it->second);
+                            std::string endNominal = scanner->getStopCommand();
 
-							// store current position in file
+                            // store current position in file
                             std::streampos len = file.tellg();
-							std::string linePeek;
-							bool foundstop = false;
-							while (!file.eof() && !foundstop){
-								//continue grabbing next line until we find what we need
-								getline(file, linePeek);
-								if (linePeek.find(endNominal) != std::string::npos){
-									foundstop = true;
+                            std::string linePeek;
+                            bool foundstop = false;
+                            while (!file.eof() && !foundstop){
+                                //continue grabbing next line until we find what we need
+                                getline(file, linePeek);
+                                if (linePeek.find(endNominal) != std::string::npos){
+                                    foundstop = true;
 
-									met = linePeek.substr(25, 9);
-									scan_stop = getETfromMet(met);
-									findPlaybookSpecifiedTarget(line, scannerTarget);
-									scannerSpiceID = it->second->getTranslation();
+                                    met = linePeek.substr(25, 9);
+                                    scan_stop = getETfromMet(met);
+                                    findPlaybookSpecifiedTarget(line, scannerTarget);
+                                    scannerSpiceID = it->second->getTranslation();
 
-									scanRange._min = scan_start;
-									scanRange._max = scan_stop;
-									_instrumentTimes.push_back(std::make_pair(it->first, scanRange));
+                                    scanRange._min = scan_start;
+                                    scanRange._max = scan_stop;
+                                    _instrumentTimes.push_back(std::make_pair(it->first, scanRange));
 
-									//store individual image
-									createImage(image, scan_start, scan_stop, scannerSpiceID, scannerTarget, _defaultCaptureImage);
-									writeUTCEventFile(image);
+                                    //store individual image
+                                    createImage(image, scan_start, scan_stop, scannerSpiceID, scannerTarget, _defaultCaptureImage);
+                                    writeUTCEventFile(image);
 
-									_subsetMap[image.target]._subset.push_back(image);
-									_subsetMap[image.target]._range.setRange(scan_start);
-								}
-							}
-							//go back to stored position in file
-							file.seekg(len, std::ios_base::beg);
-						}
-					}
-					else{ // we have reached the end of a scan or consecutive capture sequence!
-						if (capture_start != -1){
-							//end of capture sequence for camera, store end time of this sequence
-							capture_stop = time;
-							cameraRange._min = capture_start;
-							cameraRange._max = capture_stop;
-							_instrumentTimes.push_back(std::make_pair(previousCamera, cameraRange));
+                                    _subsetMap[image.target]._subset.push_back(image);
+                                    _subsetMap[image.target]._range.setRange(scan_start);
+                                }
+                            }
+                            //go back to stored position in file
+                            file.seekg(len, std::ios_base::beg);
+                        }
+                    }
+                    else{ // we have reached the end of a scan or consecutive capture sequence!
+                        if (capture_start != -1){
+                            //end of capture sequence for camera, store end time of this sequence
+                            capture_stop = time;
+                            cameraRange._min = capture_start;
+                            cameraRange._max = capture_stop;
+                            _instrumentTimes.push_back(std::make_pair(previousCamera, cameraRange));
 
-							capture_start = -1;
-						}
-					}
-					_eventsAsUTCFile << std::endl;
-				}
-			}
-		}
-	}
+                            capture_start = -1;
+                        }
+                    }
+                    _eventsAsUTCFile << std::endl;
+                }
+            }
+        }
+    }
 
 
     sendPlaybookInformation(PlaybookIdentifierName);
@@ -268,88 +268,88 @@ bool HongKangParser::create(){
 }
 
 bool HongKangParser::augmentWithSpice(Image& image,
-	                                  std::string spacecraft, 
-									  std::vector<std::string> payload, 
-									  std::vector<std::string> potentialTargets){
-	image.target = "VOID";
-	// we have (?) to cast to int, unfortunately
+                                      std::string spacecraft, 
+                                      std::vector<std::string> payload, 
+                                      std::vector<std::string> potentialTargets){
+    image.target = "VOID";
+    // we have (?) to cast to int, unfortunately
     // Why? --abock
-	// because: old comment --m
-	int exposureTime = image.stopTime - image.startTime;
-	if (exposureTime == 0)
+    // because: old comment --m
+    int exposureTime = image.stopTime - image.startTime;
+    if (exposureTime == 0)
         exposureTime = 1;
 
-	for (int i = 0; i < potentialTargets.size(); i++){
-		bool success = false;
-		bool _withinFOV = false;
-		for (int j = 0; j < image.activeInstruments.size(); j++){
-			double time = image.startTime;
-			for (int k = 0; k < exposureTime; k++){
-				time += k;
-				_withinFOV = SpiceManager::ref().isTargetInFieldOfView(
+    for (int i = 0; i < potentialTargets.size(); i++){
+        bool success = false;
+        bool _withinFOV = false;
+        for (int j = 0; j < image.activeInstruments.size(); j++){
+            double time = image.startTime;
+            for (int k = 0; k < exposureTime; k++){
+                time += k;
+                _withinFOV = SpiceManager::ref().isTargetInFieldOfView(
                                                                        potentialTargets[i],
                                                                        spacecraft,
-					image.activeInstruments[j],
+                    image.activeInstruments[j],
                                                                        SpiceManager::FieldOfViewMethod::Ellipsoid,
                                                                        {},
-					time
-					);
-				if (_withinFOV){
-					image.target = potentialTargets[i];
-					_withinFOV = false;
-				}
-			}
-		}
-	}
-	return false;
+                    time
+                    );
+                if (_withinFOV){
+                    image.target = potentialTargets[i];
+                    _withinFOV = false;
+                }
+            }
+        }
+    }
+    return false;
 }
 
 void HongKangParser::createImage(Image& image, double startTime, double stopTime, std::vector<std::string> instr, std::string targ, std::string path) {
-	image.startTime = startTime;
-	image.stopTime = stopTime;
-	image.path = path;
-	for (int i = 0; i < instr.size(); i++){
-		image.activeInstruments.push_back(instr[i]);
-	}
-	image.target = targ;
-	image.projected = false;
+    image.startTime = startTime;
+    image.stopTime = stopTime;
+    image.path = path;
+    for (int i = 0; i < instr.size(); i++){
+        image.activeInstruments.push_back(instr[i]);
+    }
+    image.target = targ;
+    image.projected = false;
 }
 
 double HongKangParser::getETfromMet(std::string line){
-	std::string::size_type sz;
-	return getETfromMet(std::stod(line, &sz));
+    std::string::size_type sz;
+    return getETfromMet(std::stod(line, &sz));
 }
 
 double HongKangParser::getETfromMet(double met){
-	double diff;
+    double diff;
     double referenceET =
         SpiceManager::ref().ephemerisTimeFromDate("2015-07-14T11:50:00.00");
     double et = referenceET;
 
-	//_metRef += 3; // MET reference time is off by 3 sec? 
+    //_metRef += 3; // MET reference time is off by 3 sec? 
 
     diff = std::abs(met - _metRef);
-	if (met > _metRef){
-		et = referenceET + diff;
-	} else if (met < _metRef){
-		et = referenceET - diff;
-	}
-	return et;
+    if (met > _metRef){
+        et = referenceET + diff;
+    } else if (met < _metRef){
+        et = referenceET - diff;
+    }
+    return et;
 }
 
 
 double HongKangParser::getMetFromET(double et){
-	double met;
+    double met;
     double referenceET =
         SpiceManager::ref().ephemerisTimeFromDate("2015-07-14T11:50:00.00");
 
-	if (et >= referenceET){
-		met = _metRef + (et - referenceET);
-	}else{
-		met = _metRef - (referenceET - et);
-	}
+    if (et >= referenceET){
+        met = _metRef + (et - referenceET);
+    }else{
+        met = _metRef - (referenceET - et);
+    }
 
-	return met;
+    return met;
 }
 
 
diff --git a/modules/newhorizons/util/hongkangparser.h b/modules/newhorizons/util/hongkangparser.h
index 891c0a69d8..c7a055b55c 100644
--- a/modules/newhorizons/util/hongkangparser.h
+++ b/modules/newhorizons/util/hongkangparser.h
@@ -37,44 +37,44 @@ namespace openspace {
 
 class HongKangParser : public SequenceParser {
 public:
-	HongKangParser();
-	HongKangParser(std::string name, const std::string& fileName,
-			        std::string spacecraft,
-					ghoul::Dictionary dictionary,
-			        std::vector<std::string> potentialTargets);
+    HongKangParser();
+    HongKangParser(std::string name, const std::string& fileName,
+                    std::string spacecraft,
+                    ghoul::Dictionary dictionary,
+                    std::vector<std::string> potentialTargets);
 
-	bool create() override;
-	void findPlaybookSpecifiedTarget(std::string line, std::string& target);
-	virtual std::map<std::string, Decoder*> getTranslation(){ return _fileTranslation; };
+    bool create() override;
+    void findPlaybookSpecifiedTarget(std::string line, std::string& target);
+    virtual std::map<std::string, Decoder*> getTranslation(){ return _fileTranslation; };
 
-	void writeUTCEventFile(const Image image);
+    void writeUTCEventFile(const Image image);
 
 private:
-	double getMetFromET(double et);
-	double getETfromMet(std::string timestr);
-	double getETfromMet(double met);
+    double getMetFromET(double et);
+    double getETfromMet(std::string timestr);
+    double getETfromMet(double met);
 
-	void createImage(Image& image,
-			            double startTime,
-			            double stopTime,
-			            std::vector<std::string> instr,
-			            std::string targ,
-			            std::string pot);
+    void createImage(Image& image,
+                        double startTime,
+                        double stopTime,
+                        std::vector<std::string> instr,
+                        std::string targ,
+                        std::string pot);
 
-	bool augmentWithSpice(Image& image, 
-			                std::string spacecraft, 
-							std::vector<std::string> payload, 
-							std::vector<std::string> potentialTargets);
+    bool augmentWithSpice(Image& image, 
+                            std::string spacecraft, 
+                            std::vector<std::string> payload, 
+                            std::vector<std::string> potentialTargets);
 
-	std::string _defaultCaptureImage;
-	double _metRef = 299180517;
+    std::string _defaultCaptureImage;
+    double _metRef = 299180517;
 
     std::string _name;
-	std::string _fileName;
-	std::string _spacecraft;
-	std::map<std::string, Decoder*> _fileTranslation;
-	std::vector<std::string> _potentialTargets;
-	std::ofstream _eventsAsUTCFile;
+    std::string _fileName;
+    std::string _spacecraft;
+    std::map<std::string, Decoder*> _fileTranslation;
+    std::vector<std::string> _potentialTargets;
+    std::ofstream _eventsAsUTCFile;
 };
 
 }
diff --git a/modules/newhorizons/util/imagesequencer.cpp b/modules/newhorizons/util/imagesequencer.cpp
index 5c5a96c7e8..57ba88d127 100644
--- a/modules/newhorizons/util/imagesequencer.cpp
+++ b/modules/newhorizons/util/imagesequencer.cpp
@@ -242,7 +242,7 @@ bool ImageSequencer::getImagePaths(std::vector<Image>& captures,
         auto compareTime = [](const Image &a,
                               const Image &b)->bool{
             return a.startTime < b.startTime;
-        };		
+        };        
         // for readability we store the iterators
         auto begin = _subsetMap[projectee]._subset.begin(); 
         auto end   = _subsetMap[projectee]._subset.end();
@@ -320,14 +320,14 @@ void ImageSequencer::runSequenceParser(SequenceParser* parser){
                 std::vector<Image> &destination = _subsetMap[key]._subset; // imagery
 
                 // simple search function
-                double min = 10;				
+                double min = 10;                
                 auto findMin = [&](std::vector<Image> &vector)->double{
                     for (int i = 1; i < vector.size(); i++){
                         double e = abs(vector[i].startTime - vector[i - 1].startTime);
                         if (e < min){
                             min = e;
                         }
-                    }	
+                    }    
                     return min;
                 };
                 
diff --git a/modules/newhorizons/util/imagesequencer.h b/modules/newhorizons/util/imagesequencer.h
index d34e1ebd79..4f9cccbed3 100644
--- a/modules/newhorizons/util/imagesequencer.h
+++ b/modules/newhorizons/util/imagesequencer.h
@@ -78,7 +78,7 @@ public:
     /**
      * Updates sequencer with current <code>time</code>. This is used internally for keeping
      * track of both current simulation time and the time of the previously rendered frame.  
-     */	
+     */    
     void updateSequencer(double time);
     /**
     * Runs parser and recieves the datastructures filled by it. 
diff --git a/modules/newhorizons/util/instrumentdecoder.cpp b/modules/newhorizons/util/instrumentdecoder.cpp
index b0eb6283cb..4758209284 100644
--- a/modules/newhorizons/util/instrumentdecoder.cpp
+++ b/modules/newhorizons/util/instrumentdecoder.cpp
@@ -29,49 +29,49 @@
 
 namespace {
     const std::string _loggerCat  = "InstrumentDecoder";
-	const std::string keyDetector = "DetectorType";
-	const std::string keySpice    = "Spice";
-	const std::string keyStopCommand = "StopCommand";
+    const std::string keyDetector = "DetectorType";
+    const std::string keySpice    = "Spice";
+    const std::string keyStopCommand = "StopCommand";
 }
 
 namespace openspace {
    
 InstrumentDecoder::InstrumentDecoder(const ghoul::Dictionary& dictionary)
 {
-	bool success = dictionary.getValue(keyDetector, _type);
-	ghoul_assert(success, "Instrument has not provided detector type");
-	for_each(_type.begin(), _type.end(), [](char& in){ in = ::toupper(in); });
+    bool success = dictionary.getValue(keyDetector, _type);
+    ghoul_assert(success, "Instrument has not provided detector type");
+    for_each(_type.begin(), _type.end(), [](char& in){ in = ::toupper(in); });
 
-	if (!dictionary.hasKeyAndValue<std::string>(keyStopCommand) && _type == "SCANNER"){
-		LWARNING("Scanner must provide stop command, please check mod file.");
-	}else{
-		dictionary.getValue(keyStopCommand, _stopCommand);
-	}
+    if (!dictionary.hasKeyAndValue<std::string>(keyStopCommand) && _type == "SCANNER"){
+        LWARNING("Scanner must provide stop command, please check mod file.");
+    }else{
+        dictionary.getValue(keyStopCommand, _stopCommand);
+    }
 
-	std::vector<std::string> spice;
-	ghoul::Dictionary spiceDictionary;
-	success = dictionary.getValue(keySpice, spiceDictionary);
-	ghoul_assert(success, "Instrument did not provide spice ids");
+    std::vector<std::string> spice;
+    ghoul::Dictionary spiceDictionary;
+    success = dictionary.getValue(keySpice, spiceDictionary);
+    ghoul_assert(success, "Instrument did not provide spice ids");
 
 
-	_spiceIDs.resize(spiceDictionary.size());
-	for (int i = 0; i < _spiceIDs.size(); ++i) {
-		std::string id;
-		spiceDictionary.getValue(std::to_string(i + 1), id);
-		_spiceIDs[i] = id;
-	}
+    _spiceIDs.resize(spiceDictionary.size());
+    for (int i = 0; i < _spiceIDs.size(); ++i) {
+        std::string id;
+        spiceDictionary.getValue(std::to_string(i + 1), id);
+        _spiceIDs[i] = id;
+    }
 }
 
 std::string InstrumentDecoder::getStopCommand(){
-	return _stopCommand;
+    return _stopCommand;
 }
 
 std::string InstrumentDecoder::getDecoderType(){
-	return _type;
+    return _type;
 }
 
 std::vector<std::string> InstrumentDecoder::getTranslation(){
-	return _spiceIDs;
+    return _spiceIDs;
 }
 
 } // namespace openspace
\ No newline at end of file
diff --git a/modules/newhorizons/util/instrumentdecoder.h b/modules/newhorizons/util/instrumentdecoder.h
index 80f753bc94..1f4a22482e 100644
--- a/modules/newhorizons/util/instrumentdecoder.h
+++ b/modules/newhorizons/util/instrumentdecoder.h
@@ -33,14 +33,14 @@ namespace openspace {
     
 class InstrumentDecoder : public Decoder {
 public:
-	InstrumentDecoder(const ghoul::Dictionary& dictionary);
-	virtual std::string getDecoderType();
-	virtual std::vector<std::string> getTranslation();
-	std::string getStopCommand();
+    InstrumentDecoder(const ghoul::Dictionary& dictionary);
+    virtual std::string getDecoderType();
+    virtual std::vector<std::string> getTranslation();
+    std::string getStopCommand();
 private:
-	std::string _type;
-	std::string _stopCommand;
-	std::vector<std::string> _spiceIDs;
+    std::string _type;
+    std::string _stopCommand;
+    std::vector<std::string> _spiceIDs;
 };
     
 } // namespace openspace
diff --git a/modules/newhorizons/util/labelparser.cpp b/modules/newhorizons/util/labelparser.cpp
index e50f6b6dfa..4fad1e3e54 100644
--- a/modules/newhorizons/util/labelparser.cpp
+++ b/modules/newhorizons/util/labelparser.cpp
@@ -107,11 +107,11 @@ std::string LabelParser::decode(std::string line){
             std::string toTranslate = line.substr(value);
             
             //if (_fileTranslation.find(toTranslate) == _fileTranslation.end()) {
-            //	// not found
-            //	_badDecoding = true;
-            //	LERROR("Could not fins '" << toTranslate << "' in translation map." <<
-            //		   "\nPlease check label files");
-            //	return "";
+            //    // not found
+            //    _badDecoding = true;
+            //    LERROR("Could not fins '" << toTranslate << "' in translation map." <<
+            //           "\nPlease check label files");
+            //    return "";
             //}
             return _fileTranslation[toTranslate]->getTranslation()[0]; //lbls always 1:1 -> single value return
 
@@ -155,7 +155,7 @@ bool LabelParser::create() {
             if (position != std::string::npos){
                 ghoul::filesystem::File currentFile(path);
                 std::string extension = currentFile.fileExtension();
-                if (extension == "lbl" || extension == "LBL"){ // discovered header file 		
+                if (extension == "lbl" || extension == "LBL"){ // discovered header file         
                     std::ifstream file(currentFile.path());
 
                     if (!file.good()){
@@ -199,10 +199,10 @@ bool LabelParser::create() {
                             _detectorType = decode(line);
                             count++; 
                         }
-                    //	if (_badDecoding){
-                    //		LERROR("Please examine file: '" << currentFile.path() << "'");
-                    //		return false;
-                    //	}
+                    //    if (_badDecoding){
+                    //        LERROR("Please examine file: '" << currentFile.path() << "'");
+                    //        return false;
+                    //    }
 
                         if (read == "START_TIME"){
                             std::string start = line.substr(line.find("=") + 2);
@@ -280,27 +280,27 @@ bool LabelParser::create() {
     for (auto target : _subsetMap){
         _instrumentTimes.push_back(std::make_pair(lblName, _subsetMap[target.first]._range));
 
-    //	std::string min, max;
-    //	SpiceManager::ref().getDateFromET(target.second._range._min, min);
-    //	SpiceManager::ref().getDateFromET(target.second._range._max, max);
+    //    std::string min, max;
+    //    SpiceManager::ref().getDateFromET(target.second._range._min, min);
+    //    SpiceManager::ref().getDateFromET(target.second._range._max, max);
 
-    //	myfile << std::endl;
-    //	for (auto image : target.second._subset){
-    //		std::string time_beg;
-    //		std::string time_end;
-    //		SpiceManager::ref().getDateFromET(image.startTime, time_beg);
-    //		SpiceManager::ref().getDateFromET(image.stopTime, time_end);
+    //    myfile << std::endl;
+    //    for (auto image : target.second._subset){
+    //        std::string time_beg;
+    //        std::string time_end;
+    //        SpiceManager::ref().getDateFromET(image.startTime, time_beg);
+    //        SpiceManager::ref().getDateFromET(image.stopTime, time_end);
 
-    //		myfile << std::fixed
-    //			<< " "   << time_beg
-    //			<< "-->" << time_end
-    //			<< " [ " << image.startTime
-    //			<< " ] "   << image.target << std::setw(10);
-    //		for (auto instrument : image.activeInstruments){
-    //			myfile << " " << instrument;
-    //		}
-    //		myfile << std::endl;
-    //	}
+    //        myfile << std::fixed
+    //            << " "   << time_beg
+    //            << "-->" << time_end
+    //            << " [ " << image.startTime
+    //            << " ] "   << image.target << std::setw(10);
+    //        for (auto instrument : image.activeInstruments){
+    //            myfile << " " << instrument;
+    //        }
+    //        myfile << std::endl;
+    //    }
     }
     sendPlaybookInformation(PlaybookIdentifierName);
     return true;
diff --git a/modules/newhorizons/util/labelparser.h b/modules/newhorizons/util/labelparser.h
index f1163944d9..6944930ff4 100644
--- a/modules/newhorizons/util/labelparser.h
+++ b/modules/newhorizons/util/labelparser.h
@@ -35,46 +35,46 @@
 namespace openspace {
 class LabelParser : public SequenceParser{
 public:
-	LabelParser();
-	LabelParser(std::string name,
+    LabelParser();
+    LabelParser(std::string name,
                 const std::string& fileName,
-				ghoul::Dictionary translationDictionary);
+                ghoul::Dictionary translationDictionary);
 
-	bool create() override;
+    bool create() override;
 
-	// temporary need to figure this out
-	std::map<std::string, Decoder*> getTranslation(){ return _fileTranslation; };
+    // temporary need to figure this out
+    std::map<std::string, Decoder*> getTranslation(){ return _fileTranslation; };
 
 private:
-	void createImage(Image& image,
-			            double startTime,
-			            double stopTime,
-			            std::vector<std::string> instr,
-			            std::string targ,
-			            std::string path);
+    void createImage(Image& image,
+                        double startTime,
+                        double stopTime,
+                        std::vector<std::string> instr,
+                        std::string targ,
+                        std::string path);
 
-	std::string decode(std::string line);
-	std::string encode(std::string line);
+    std::string decode(std::string line);
+    std::string encode(std::string line);
 
-	bool augmentWithSpice(Image& image, 
-			                std::string spacecraft, 
-							std::vector<std::string> payload, 
-							std::vector<std::string> potentialTargets);
-		
+    bool augmentWithSpice(Image& image, 
+                            std::string spacecraft, 
+                            std::vector<std::string> payload, 
+                            std::vector<std::string> potentialTargets);
+        
     std::string _name;
-	std::string _fileName;
-	std::string _spacecraft;
-	std::map<std::string, Decoder*> _fileTranslation;
-	std::vector<std::string> _specsOfInterest;
+    std::string _fileName;
+    std::string _spacecraft;
+    std::map<std::string, Decoder*> _fileTranslation;
+    std::vector<std::string> _specsOfInterest;
 
-	std::string _target;
-	std::string _instrumentID;
-	std::string _instrumentHostID;
-	std::string _detectorType;
-	std::string _sequenceID;
-	double _startTime;
-	double _stopTime;
-	bool _badDecoding;
+    std::string _target;
+    std::string _instrumentID;
+    std::string _instrumentHostID;
+    std::string _detectorType;
+    std::string _sequenceID;
+    double _startTime;
+    double _stopTime;
+    bool _badDecoding;
 };
 }
 #endif //__LABELPARSER_H__
\ No newline at end of file
diff --git a/modules/newhorizons/util/scannerdecoder.cpp b/modules/newhorizons/util/scannerdecoder.cpp
index ffea44c6d6..fdb836c620 100644
--- a/modules/newhorizons/util/scannerdecoder.cpp
+++ b/modules/newhorizons/util/scannerdecoder.cpp
@@ -32,22 +32,22 @@ namespace openspace {
    
 ScannerDecoder::ScannerDecoder(const ghoul::Dictionary& dictionary) : _type("SCANNER")
 {
-	std::string value;
-	for (int k = 0; k < dictionary.size(); k++){
-		dictionary.getValue(std::to_string(k + 1), value);
-		_spiceIDs.push_back(value);
-	}
+    std::string value;
+    for (int k = 0; k < dictionary.size(); k++){
+        dictionary.getValue(std::to_string(k + 1), value);
+        _spiceIDs.push_back(value);
+    }
 }
 std::string ScannerDecoder::getDecoderType(){
-	return _type;
+    return _type;
 }
 
 std::vector<std::string> ScannerDecoder::getSpiceIDs(){
-	return _spiceIDs;
+    return _spiceIDs;
 }
 
 void ScannerDecoder::setStopCommand(std::string stopCommand){
-	_abort = stopCommand;
+    _abort = stopCommand;
 }
 
 } // namespace openspace
\ No newline at end of file
diff --git a/modules/newhorizons/util/scannerdecoder.h b/modules/newhorizons/util/scannerdecoder.h
index 38ff073c00..0a2b11f2a4 100644
--- a/modules/newhorizons/util/scannerdecoder.h
+++ b/modules/newhorizons/util/scannerdecoder.h
@@ -33,14 +33,14 @@ namespace openspace {
 class ScannerDecoder : public Decoder {
 public:
     ScannerDecoder(const ghoul::Dictionary& dictionary);
-	virtual std::string getDecoderType();
-	virtual std::vector<std::string> getSpiceIDs();
+    virtual std::string getDecoderType();
+    virtual std::vector<std::string> getSpiceIDs();
     std::string getStopCommand();
-	void setStopCommand(std::string stopCommand);
+    void setStopCommand(std::string stopCommand);
 private:
-	std::string _type;
-	std::string _abort;
-	std::vector<std::string> _spiceIDs;
+    std::string _type;
+    std::string _abort;
+    std::vector<std::string> _spiceIDs;
 };
     
 } // namespace openspace
diff --git a/modules/newhorizons/util/sequenceparser.cpp b/modules/newhorizons/util/sequenceparser.cpp
index 05ea011cf9..01715d5f10 100644
--- a/modules/newhorizons/util/sequenceparser.cpp
+++ b/modules/newhorizons/util/sequenceparser.cpp
@@ -31,8 +31,8 @@
 #include <ghoul/logging/logmanager.h>
 
 namespace {
-	const std::string _loggerCat = "SequenceParser";
-	const std::string keyTranslation = "DataInputTranslation";
+    const std::string _loggerCat = "SequenceParser";
+    const std::string keyTranslation = "DataInputTranslation";
 
     const std::string PlaybookIdentifierName = "Playbook";
 }
diff --git a/modules/newhorizons/util/sequenceparser.h b/modules/newhorizons/util/sequenceparser.h
index 5f0e9779cd..9bb1606393 100644
--- a/modules/newhorizons/util/sequenceparser.h
+++ b/modules/newhorizons/util/sequenceparser.h
@@ -68,11 +68,11 @@ struct ImageSubset {
 class SequenceParser {
 public:
     virtual bool create() = 0;
-	virtual std::map<std::string, ImageSubset> getSubsetMap() final;
-	virtual std::vector<std::pair<std::string, TimeRange>> getIstrumentTimes() final;
-	virtual std::vector<std::pair<double, std::string>> getTargetTimes() final;
-	virtual std::map<std::string, Decoder*> getTranslation() = 0;
-	virtual std::vector<double> getCaptureProgression() final;
+    virtual std::map<std::string, ImageSubset> getSubsetMap() final;
+    virtual std::vector<std::pair<std::string, TimeRange>> getIstrumentTimes() final;
+    virtual std::vector<std::pair<double, std::string>> getTargetTimes() final;
+    virtual std::map<std::string, Decoder*> getTranslation() = 0;
+    virtual std::vector<double> getCaptureProgression() final;
 
 protected:
     void sendPlaybookInformation(const std::string& name);
diff --git a/modules/newhorizons/util/targetdecoder.cpp b/modules/newhorizons/util/targetdecoder.cpp
index 6dcedfe6ef..05f1253699 100644
--- a/modules/newhorizons/util/targetdecoder.cpp
+++ b/modules/newhorizons/util/targetdecoder.cpp
@@ -32,20 +32,20 @@ namespace openspace {
 
 TargetDecoder::TargetDecoder(const ghoul::Dictionary& dictionary) :_type("TARGET")
 {
-	_names.resize(dictionary.size());
-	for (int i = 0; i < _names.size(); ++i) {
-		std::string readMe;
-		dictionary.getValue(std::to_string(i + 1), readMe);
-		_names[i] = readMe;
-	}
+    _names.resize(dictionary.size());
+    for (int i = 0; i < _names.size(); ++i) {
+        std::string readMe;
+        dictionary.getValue(std::to_string(i + 1), readMe);
+        _names[i] = readMe;
+    }
 }
 
 std::string TargetDecoder::getDecoderType(){
-	return _type;
+    return _type;
 }
 
 std::vector<std::string> TargetDecoder::getTranslation(){
-	return _names;
+    return _names;
 }
 
 } // namespace openspace
\ No newline at end of file
diff --git a/modules/newhorizons/util/targetdecoder.h b/modules/newhorizons/util/targetdecoder.h
index 69e9fd8519..ea58c8af9b 100644
--- a/modules/newhorizons/util/targetdecoder.h
+++ b/modules/newhorizons/util/targetdecoder.h
@@ -33,12 +33,12 @@ namespace openspace {
     
 class TargetDecoder : public Decoder {
 public:
-	TargetDecoder(const ghoul::Dictionary& dictionary);
-	virtual std::string getDecoderType();
-	virtual std::vector<std::string> getTranslation();
+    TargetDecoder(const ghoul::Dictionary& dictionary);
+    virtual std::string getDecoderType();
+    virtual std::vector<std::string> getTranslation();
 private:
-	std::string _type;
-	std::vector<std::string> _names;
+    std::string _type;
+    std::vector<std::string> _names;
 };
     
 } // namespace openspace
diff --git a/modules/onscreengui/include/gui.h b/modules/onscreengui/include/gui.h
index ee3144ceb8..1628a36c62 100644
--- a/modules/onscreengui/include/gui.h
+++ b/modules/onscreengui/include/gui.h
@@ -40,42 +40,42 @@ namespace gui {
 
 class GUI {
 public:
-	GUI();
+    GUI();
     ~GUI();
 
-	bool isEnabled() const;
-	void setEnabled(bool enabled);
+    bool isEnabled() const;
+    void setEnabled(bool enabled);
 
-	void initialize();
-	void deinitialize();
+    void initialize();
+    void deinitialize();
 
-	void initializeGL();
-	void deinitializeGL();
+    void initializeGL();
+    void deinitializeGL();
 
     bool mouseButtonCallback(MouseButton button, MouseAction action);
-//	bool mouseButtonCallback(int key, int action);
-	bool mouseWheelCallback(double position);
+//    bool mouseButtonCallback(int key, int action);
+    bool mouseWheelCallback(double position);
     bool keyCallback(Key key, KeyModifier modifier, KeyAction action);
-//	bool keyCallback(int key, int action);
-	bool charCallback(unsigned int character, KeyModifier modifier);
+//    bool keyCallback(int key, int action);
+    bool charCallback(unsigned int character, KeyModifier modifier);
 
-	void startFrame(float deltaTime, const glm::vec2& windowSize, const glm::vec2& mousePos, uint32_t mouseButtons);
-	void endFrame();
+    void startFrame(float deltaTime, const glm::vec2& windowSize, const glm::vec2& mousePos, uint32_t mouseButtons);
+    void endFrame();
 
-	void renderMainWindow();
+    void renderMainWindow();
 
-	static openspace::scripting::ScriptEngine::LuaLibrary luaLibrary();
+    static openspace::scripting::ScriptEngine::LuaLibrary luaLibrary();
 
 //protected:
     GuiHelpComponent _help;
     GuiOriginComponent _origin;
-	GuiPerformanceComponent _performance;
-	GuiPropertyComponent _property;
+    GuiPerformanceComponent _performance;
+    GuiPropertyComponent _property;
     GuiTimeComponent _time;
 
-	bool _isEnabled;
+    bool _isEnabled;
 
-	bool _showHelp;
+    bool _showHelp;
 };
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guicomponent.h b/modules/onscreengui/include/guicomponent.h
index d372275dd6..d59830b14e 100644
--- a/modules/onscreengui/include/guicomponent.h
+++ b/modules/onscreengui/include/guicomponent.h
@@ -35,40 +35,40 @@ class GUI;
  */
 class GuiComponent {
 public:
-	friend class GUI;
+    friend class GUI;
 
-	/**
-	 * Returns if this component is enabled, that is, if it is currently active and
-	 * visible on the screen.
-	 * \return <code>true</code> if this component is enabled, <code>false</code>
-	 * otherwise
-	 */
-	bool isEnabled() const;
+    /**
+     * Returns if this component is enabled, that is, if it is currently active and
+     * visible on the screen.
+     * \return <code>true</code> if this component is enabled, <code>false</code>
+     * otherwise
+     */
+    bool isEnabled() const;
 
-	/**
-	 * Sets if this component is enabled, that is, if it is currently active and visible
-	 * on the screen.
-	 * \param enabled The new enabled status of this component
-	 */
-	void setEnabled(bool enabled);
+    /**
+     * Sets if this component is enabled, that is, if it is currently active and visible
+     * on the screen.
+     * \param enabled The new enabled status of this component
+     */
+    void setEnabled(bool enabled);
 
-	/// Initializes the component with everything that does not require an OpenGL context
-	virtual void initialize();
-	/// Initializes the component with everything that requires an OpenGL context
-	virtual void initializeGL();
+    /// Initializes the component with everything that does not require an OpenGL context
+    virtual void initialize();
+    /// Initializes the component with everything that requires an OpenGL context
+    virtual void initializeGL();
 
-	/// Deinitializes the component with things that do not require an OpenGL context
-	virtual void deinitialize();
-	
-	/// Deinitializes the component with things that require an OpenGL context
-	virtual void deinitializeGL();
+    /// Deinitializes the component with things that do not require an OpenGL context
+    virtual void deinitialize();
+    
+    /// Deinitializes the component with things that require an OpenGL context
+    virtual void deinitializeGL();
 
-	/// Renders the individual subcomponents to the screen
-	virtual void render() = 0;
+    /// Renders the individual subcomponents to the screen
+    virtual void render() = 0;
 
 protected:
-	/// <code>true</code> if this component is enabled and visible on the screen
-	bool _isEnabled = false;
+    /// <code>true</code> if this component is enabled and visible on the screen
+    bool _isEnabled = false;
 };
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guihelpcomponent.h b/modules/onscreengui/include/guihelpcomponent.h
index 9da7750612..dcaf9284d8 100644
--- a/modules/onscreengui/include/guihelpcomponent.h
+++ b/modules/onscreengui/include/guihelpcomponent.h
@@ -32,7 +32,7 @@ namespace gui {
 
 class GuiHelpComponent : public GuiComponent {
 public:
-	void render();
+    void render();
 };
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guiorigincomponent.h b/modules/onscreengui/include/guiorigincomponent.h
index 9dbf06f5e4..d3507acaf4 100644
--- a/modules/onscreengui/include/guiorigincomponent.h
+++ b/modules/onscreengui/include/guiorigincomponent.h
@@ -39,42 +39,42 @@ public:
 //
 //class GuiPropertyComponent : public GuiComponent {
 //public:
-//	//void registerProperty(const std::string& propertyDescription);
+//    //void registerProperty(const std::string& propertyDescription);
 //    void registerProperty(properties::Property* prop);
-//	void render();
+//    void render();
 //
 //protected:
-//	enum class PropertyType {
-//		BoolProperty = 0,
-//		IntProperty,
-//		FloatProperty,
-//		Vec2Property,
-//		Vec3Property,
-//		StringProperty,
-//		OptionProperty,
-//		SelectionProperty,
-//		TriggerProperty,
-//		InvalidPropertyType
-//	};
+//    enum class PropertyType {
+//        BoolProperty = 0,
+//        IntProperty,
+//        FloatProperty,
+//        Vec2Property,
+//        Vec3Property,
+//        StringProperty,
+//        OptionProperty,
+//        SelectionProperty,
+//        TriggerProperty,
+//        InvalidPropertyType
+//    };
 //
-//	struct PropertyInfo {
-//		PropertyType type;
-//		std::string identifier;
-//		std::string name;
-//		std::string group;
-//	};
-//	typedef std::string PropertyOwner;
+//    struct PropertyInfo {
+//        PropertyType type;
+//        std::string identifier;
+//        std::string name;
+//        std::string group;
+//    };
+//    typedef std::string PropertyOwner;
 //
-//	struct Property {
-//		PropertyOwner owner;
-//		std::vector<PropertyInfo> properties;
-//	};
+//    struct Property {
+//        PropertyOwner owner;
+//        std::vector<PropertyInfo> properties;
+//    };
 //
-//	void handleProperty(const ghoul::Dictionary& value);
+//    void handleProperty(const ghoul::Dictionary& value);
 //
-//	PropertyType toPropertyType(const std::string& name) const;
+//    PropertyType toPropertyType(const std::string& name) const;
 //
-//	void renderProperty(const PropertyInfo& info) const;
+//    void renderProperty(const PropertyInfo& info) const;
 //
 //    std::set<properties::Property*> _boolProperties;
 //    std::set<properties::Property*> _intProperties;
@@ -88,7 +88,7 @@ public:
 //    std::set<properties::Property*> _triggerProperties;
 //    std::map<std::string, std::vector<properties::Property*>> _propertiesByOwner;
 //
-//	//std::vector<Property> _properties;
+//    //std::vector<Property> _properties;
 //};
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guiperformancecomponent.h b/modules/onscreengui/include/guiperformancecomponent.h
index d3c23cabef..e2f31f9f45 100644
--- a/modules/onscreengui/include/guiperformancecomponent.h
+++ b/modules/onscreengui/include/guiperformancecomponent.h
@@ -28,7 +28,7 @@
 #include <modules/onscreengui/include/guicomponent.h>
 
 namespace ghoul {
-	class SharedMemory;
+    class SharedMemory;
 }
 
 namespace openspace {
@@ -36,14 +36,14 @@ namespace gui {
 
 class GuiPerformanceComponent : public GuiComponent {
 public:
-	void initialize();
-	void deinitialize();
+    void initialize();
+    void deinitialize();
 
-	void render();
+    void render();
 
 protected:
-	ghoul::SharedMemory* _performanceMemory = nullptr;
-	float _minMaxValues[2];
+    ghoul::SharedMemory* _performanceMemory = nullptr;
+    float _minMaxValues[2];
 };
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guipropertycomponent.h b/modules/onscreengui/include/guipropertycomponent.h
index 8a54c0c591..1dbb99b8ed 100644
--- a/modules/onscreengui/include/guipropertycomponent.h
+++ b/modules/onscreengui/include/guipropertycomponent.h
@@ -42,42 +42,42 @@ namespace gui {
 
 class GuiPropertyComponent : public GuiComponent {
 public:
-	//void registerProperty(const std::string& propertyDescription);
+    //void registerProperty(const std::string& propertyDescription);
     void registerProperty(properties::Property* prop);
-	void render();
+    void render();
 
 protected:
-	enum class PropertyType {
-		BoolProperty = 0,
-		IntProperty,
-		FloatProperty,
-		Vec2Property,
-		Vec3Property,
-		StringProperty,
-		OptionProperty,
-		SelectionProperty,
-		TriggerProperty,
-		InvalidPropertyType
-	};
+    enum class PropertyType {
+        BoolProperty = 0,
+        IntProperty,
+        FloatProperty,
+        Vec2Property,
+        Vec3Property,
+        StringProperty,
+        OptionProperty,
+        SelectionProperty,
+        TriggerProperty,
+        InvalidPropertyType
+    };
 
-	struct PropertyInfo {
-		PropertyType type;
-		std::string identifier;
-		std::string name;
-		std::string group;
-	};
-	typedef std::string PropertyOwner;
+    struct PropertyInfo {
+        PropertyType type;
+        std::string identifier;
+        std::string name;
+        std::string group;
+    };
+    typedef std::string PropertyOwner;
 
-	struct Property {
-		PropertyOwner owner;
-		std::vector<PropertyInfo> properties;
-	};
+    struct Property {
+        PropertyOwner owner;
+        std::vector<PropertyInfo> properties;
+    };
 
-	void handleProperty(const ghoul::Dictionary& value);
+    void handleProperty(const ghoul::Dictionary& value);
 
-	PropertyType toPropertyType(const std::string& name) const;
+    PropertyType toPropertyType(const std::string& name) const;
 
-	void renderProperty(const PropertyInfo& info) const;
+    void renderProperty(const PropertyInfo& info) const;
 
     std::set<properties::Property*> _boolProperties;
     std::set<properties::Property*> _intProperties;
@@ -91,7 +91,7 @@ protected:
     std::set<properties::Property*> _triggerProperties;
     std::map<std::string, std::vector<properties::Property*>> _propertiesByOwner;
 
-	//std::vector<Property> _properties;
+    //std::vector<Property> _properties;
 };
 
 } // namespace gui
diff --git a/modules/onscreengui/include/guitimecomponent.h b/modules/onscreengui/include/guitimecomponent.h
index 0a7ccb6665..4d6f5d1f4e 100644
--- a/modules/onscreengui/include/guitimecomponent.h
+++ b/modules/onscreengui/include/guitimecomponent.h
@@ -39,42 +39,42 @@ public:
 //
 //class GuiPropertyComponent : public GuiComponent {
 //public:
-//	//void registerProperty(const std::string& propertyDescription);
+//    //void registerProperty(const std::string& propertyDescription);
 //    void registerProperty(properties::Property* prop);
-//	void render();
+//    void render();
 //
 //protected:
-//	enum class PropertyType {
-//		BoolProperty = 0,
-//		IntProperty,
-//		FloatProperty,
-//		Vec2Property,
-//		Vec3Property,
-//		StringProperty,
-//		OptionProperty,
-//		SelectionProperty,
-//		TriggerProperty,
-//		InvalidPropertyType
-//	};
+//    enum class PropertyType {
+//        BoolProperty = 0,
+//        IntProperty,
+//        FloatProperty,
+//        Vec2Property,
+//        Vec3Property,
+//        StringProperty,
+//        OptionProperty,
+//        SelectionProperty,
+//        TriggerProperty,
+//        InvalidPropertyType
+//    };
 //
-//	struct PropertyInfo {
-//		PropertyType type;
-//		std::string identifier;
-//		std::string name;
-//		std::string group;
-//	};
-//	typedef std::string PropertyOwner;
+//    struct PropertyInfo {
+//        PropertyType type;
+//        std::string identifier;
+//        std::string name;
+//        std::string group;
+//    };
+//    typedef std::string PropertyOwner;
 //
-//	struct Property {
-//		PropertyOwner owner;
-//		std::vector<PropertyInfo> properties;
-//	};
+//    struct Property {
+//        PropertyOwner owner;
+//        std::vector<PropertyInfo> properties;
+//    };
 //
-//	void handleProperty(const ghoul::Dictionary& value);
+//    void handleProperty(const ghoul::Dictionary& value);
 //
-//	PropertyType toPropertyType(const std::string& name) const;
+//    PropertyType toPropertyType(const std::string& name) const;
 //
-//	void renderProperty(const PropertyInfo& info) const;
+//    void renderProperty(const PropertyInfo& info) const;
 //
 //    std::set<properties::Property*> _boolProperties;
 //    std::set<properties::Property*> _intProperties;
@@ -88,7 +88,7 @@ public:
 //    std::set<properties::Property*> _triggerProperties;
 //    std::map<std::string, std::vector<properties::Property*>> _propertiesByOwner;
 //
-//	//std::vector<Property> _properties;
+//    //std::vector<Property> _properties;
 //};
 
 } // namespace gui
diff --git a/modules/onscreengui/src/gui.cpp b/modules/onscreengui/src/gui.cpp
index 66b0926580..2847934aa1 100644
--- a/modules/onscreengui/src/gui.cpp
+++ b/modules/onscreengui/src/gui.cpp
@@ -42,213 +42,213 @@
 #include <imgui.h>
 
 namespace {
-	const std::string _loggerCat = "GUI";
-	const std::string configurationFile = "imgui.ini";
-	const ImVec2 size = ImVec2(350, 500);
+    const std::string _loggerCat = "GUI";
+    const std::string configurationFile = "imgui.ini";
+    const ImVec2 size = ImVec2(350, 500);
 
-	GLuint fontTex = 0;
-	GLint positionLocation = 0;
-	GLint uvLocation = 0;
-	GLint colorLocation = 0;
-	size_t vboMaxSize = 20000;
-	GLuint vao = 0;
-	GLuint vbo = 0;
+    GLuint fontTex = 0;
+    GLint positionLocation = 0;
+    GLint uvLocation = 0;
+    GLint colorLocation = 0;
+    size_t vboMaxSize = 20000;
+    GLuint vao = 0;
+    GLuint vbo = 0;
     std::unique_ptr<ghoul::opengl::ProgramObject> _program;
 
-	static void ImImpl_RenderDrawLists(ImDrawList** const commandLists, int nCommandLists) {
-		if (nCommandLists == 0)
-			return;
+    static void ImImpl_RenderDrawLists(ImDrawList** const commandLists, int nCommandLists) {
+        if (nCommandLists == 0)
+            return;
 
-		// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
-		glEnable(GL_BLEND);
-		glBlendEquation(GL_FUNC_ADD);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-		glDisable(GL_CULL_FACE);
-		glDisable(GL_DEPTH_TEST);
-		glEnable(GL_SCISSOR_TEST);
+        // Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
+        glEnable(GL_BLEND);
+        glBlendEquation(GL_FUNC_ADD);
+        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        glDisable(GL_CULL_FACE);
+        glDisable(GL_DEPTH_TEST);
+        glEnable(GL_SCISSOR_TEST);
 
-		ghoul::opengl::TextureUnit unit;
-		unit.activate();
-		glBindTexture(GL_TEXTURE_2D, fontTex);
+        ghoul::opengl::TextureUnit unit;
+        unit.activate();
+        glBindTexture(GL_TEXTURE_2D, fontTex);
 
-		// Setup orthographic projection matrix
-		const float width = ImGui::GetIO().DisplaySize.x;
-		const float height = ImGui::GetIO().DisplaySize.y;
-		const glm::mat4 ortho(
-			2.f / width, 0.0f, 0.0f, 0.0f,
-			0.0f, 2.0f / -height, 0.0f, 0.0f,
-			0.0f, 0.0f, -1.0f, 0.0f,
-			-1.0f, 1.0f, 0.0f, 1.0f
-		);
-		_program->activate();
-		_program->setUniform("tex", unit);
-		_program->setUniform("ortho", ortho);
+        // Setup orthographic projection matrix
+        const float width = ImGui::GetIO().DisplaySize.x;
+        const float height = ImGui::GetIO().DisplaySize.y;
+        const glm::mat4 ortho(
+            2.f / width, 0.0f, 0.0f, 0.0f,
+            0.0f, 2.0f / -height, 0.0f, 0.0f,
+            0.0f, 0.0f, -1.0f, 0.0f,
+            -1.0f, 1.0f, 0.0f, 1.0f
+        );
+        _program->activate();
+        _program->setUniform("tex", unit);
+        _program->setUniform("ortho", ortho);
 
-		// Grow our buffer according to what we need
-		size_t total_vtx_count = 0;
-		for (int n = 0; n < nCommandLists; n++)
-			total_vtx_count += commandLists[n]->vtx_buffer.size();
-		glBindBuffer(GL_ARRAY_BUFFER, vbo);
-		// @BUGFIX @HACK  The imgui crashes on complex scenes without the * 2 ---abock
-		size_t neededBufferSize = total_vtx_count * sizeof(ImDrawVert) * 2;
-		if (neededBufferSize > vboMaxSize) {
-			vboMaxSize = neededBufferSize + 5000;  // Grow buffer
-			glBufferData(GL_ARRAY_BUFFER, neededBufferSize, NULL, GL_STREAM_DRAW);
-		}
+        // Grow our buffer according to what we need
+        size_t total_vtx_count = 0;
+        for (int n = 0; n < nCommandLists; n++)
+            total_vtx_count += commandLists[n]->vtx_buffer.size();
+        glBindBuffer(GL_ARRAY_BUFFER, vbo);
+        // @BUGFIX @HACK  The imgui crashes on complex scenes without the * 2 ---abock
+        size_t neededBufferSize = total_vtx_count * sizeof(ImDrawVert) * 2;
+        if (neededBufferSize > vboMaxSize) {
+            vboMaxSize = neededBufferSize + 5000;  // Grow buffer
+            glBufferData(GL_ARRAY_BUFFER, neededBufferSize, NULL, GL_STREAM_DRAW);
+        }
 
-		// Copy and convert all vertices into a single contiguous buffer
-		unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
-		if (!buffer_data)
-			return;
-		for (int n = 0; n < nCommandLists; ++n) {
-			const ImDrawList* cmd_list = commandLists[n];
-			memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
-			buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
-		}
-		glUnmapBuffer(GL_ARRAY_BUFFER);
-		glBindBuffer(GL_ARRAY_BUFFER, 0);
-		glBindVertexArray(vao);
+        // Copy and convert all vertices into a single contiguous buffer
+        unsigned char* buffer_data = (unsigned char*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
+        if (!buffer_data)
+            return;
+        for (int n = 0; n < nCommandLists; ++n) {
+            const ImDrawList* cmd_list = commandLists[n];
+            memcpy(buffer_data, &cmd_list->vtx_buffer[0], cmd_list->vtx_buffer.size() * sizeof(ImDrawVert));
+            buffer_data += cmd_list->vtx_buffer.size() * sizeof(ImDrawVert);
+        }
+        glUnmapBuffer(GL_ARRAY_BUFFER);
+        glBindBuffer(GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(vao);
 
-		int cmd_offset = 0;
-		for (int n = 0; n < nCommandLists; ++n) {
-			const ImDrawList* cmd_list = commandLists[n];
-			int vtx_offset = cmd_offset;
-			for (auto pcmd : cmd_list->commands) {
-				glScissor((int)pcmd.clip_rect.x, (int)(height - pcmd.clip_rect.w), (int)(pcmd.clip_rect.z - pcmd.clip_rect.x), (int)(pcmd.clip_rect.w - pcmd.clip_rect.y));
-				glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd.vtx_count);
-				vtx_offset += pcmd.vtx_count;
-			}
-			cmd_offset = vtx_offset;
-		}
+        int cmd_offset = 0;
+        for (int n = 0; n < nCommandLists; ++n) {
+            const ImDrawList* cmd_list = commandLists[n];
+            int vtx_offset = cmd_offset;
+            for (auto pcmd : cmd_list->commands) {
+                glScissor((int)pcmd.clip_rect.x, (int)(height - pcmd.clip_rect.w), (int)(pcmd.clip_rect.z - pcmd.clip_rect.x), (int)(pcmd.clip_rect.w - pcmd.clip_rect.y));
+                glDrawArrays(GL_TRIANGLES, vtx_offset, pcmd.vtx_count);
+                vtx_offset += pcmd.vtx_count;
+            }
+            cmd_offset = vtx_offset;
+        }
 
-		glBindVertexArray(0);
-		_program->deactivate();
-		glDisable(GL_SCISSOR_TEST);
-		glBindTexture(GL_TEXTURE_2D, 0);
-	}
+        glBindVertexArray(0);
+        _program->deactivate();
+        glDisable(GL_SCISSOR_TEST);
+        glBindTexture(GL_TEXTURE_2D, 0);
+    }
 }
 
 namespace openspace {
 namespace gui {
 
 GUI::GUI() 
-	: _isEnabled(false)
-	, _showHelp(false)
+    : _isEnabled(false)
+    , _showHelp(false)
 {
 }
 
 GUI::~GUI() {
-	ImGui::Shutdown();
+    ImGui::Shutdown();
 }
 
 bool GUI::isEnabled() const {
-	return _isEnabled;
+    return _isEnabled;
 }
 
 void GUI::setEnabled(bool enabled) {
-	_isEnabled = enabled;
+    _isEnabled = enabled;
 }
 
 void GUI::initialize() {
-	std::string cachedFile = FileSys.cacheManager()->cachedFilename(
+    std::string cachedFile = FileSys.cacheManager()->cachedFilename(
         configurationFile, "", ghoul::filesystem::CacheManager::Persistent::Yes
     );
 
-	char* buffer = new char[cachedFile.size() + 1];
+    char* buffer = new char[cachedFile.size() + 1];
 
 #ifdef WIN32
-	strcpy_s(buffer, cachedFile.size() + 1, cachedFile.c_str());
+    strcpy_s(buffer, cachedFile.size() + 1, cachedFile.c_str());
 #else
-	strcpy(buffer, cachedFile.c_str());
+    strcpy(buffer, cachedFile.c_str());
 #endif
 
-	ImGuiIO& io = ImGui::GetIO();
-	io.IniFilename = buffer;
-	//io.IniSavingRate = 5.f;
-	io.DeltaTime = 1.f / 60.f;
-	//io.PixelCenterOffset = 0.5f;
+    ImGuiIO& io = ImGui::GetIO();
+    io.IniFilename = buffer;
+    //io.IniSavingRate = 5.f;
+    io.DeltaTime = 1.f / 60.f;
+    //io.PixelCenterOffset = 0.5f;
     io.KeyMap[ImGuiKey_Tab] = static_cast<int>(Key::Tab);
     io.KeyMap[ImGuiKey_LeftArrow] = static_cast<int>(Key::Left);
-	io.KeyMap[ImGuiKey_RightArrow] = static_cast<int>(Key::Right);
-	io.KeyMap[ImGuiKey_UpArrow] = static_cast<int>(Key::Up);
-	io.KeyMap[ImGuiKey_DownArrow] = static_cast<int>(Key::Down);
-	io.KeyMap[ImGuiKey_Home] = static_cast<int>(Key::Home);
-	io.KeyMap[ImGuiKey_End] = static_cast<int>(Key::End);
-	io.KeyMap[ImGuiKey_Delete] = static_cast<int>(Key::Delete);
-	io.KeyMap[ImGuiKey_Backspace] = static_cast<int>(Key::BackSpace);
-	io.KeyMap[ImGuiKey_Enter] = static_cast<int>(Key::Enter);
-	io.KeyMap[ImGuiKey_Escape] = static_cast<int>(Key::Escape);
-	io.KeyMap[ImGuiKey_A] = static_cast<int>(Key::A);
-	io.KeyMap[ImGuiKey_C] = static_cast<int>(Key::C);
-	io.KeyMap[ImGuiKey_V] = static_cast<int>(Key::V);
-	io.KeyMap[ImGuiKey_X] = static_cast<int>(Key::X);
-	io.KeyMap[ImGuiKey_Y] = static_cast<int>(Key::Y);
-	io.KeyMap[ImGuiKey_Z] = static_cast<int>(Key::Z);
+    io.KeyMap[ImGuiKey_RightArrow] = static_cast<int>(Key::Right);
+    io.KeyMap[ImGuiKey_UpArrow] = static_cast<int>(Key::Up);
+    io.KeyMap[ImGuiKey_DownArrow] = static_cast<int>(Key::Down);
+    io.KeyMap[ImGuiKey_Home] = static_cast<int>(Key::Home);
+    io.KeyMap[ImGuiKey_End] = static_cast<int>(Key::End);
+    io.KeyMap[ImGuiKey_Delete] = static_cast<int>(Key::Delete);
+    io.KeyMap[ImGuiKey_Backspace] = static_cast<int>(Key::BackSpace);
+    io.KeyMap[ImGuiKey_Enter] = static_cast<int>(Key::Enter);
+    io.KeyMap[ImGuiKey_Escape] = static_cast<int>(Key::Escape);
+    io.KeyMap[ImGuiKey_A] = static_cast<int>(Key::A);
+    io.KeyMap[ImGuiKey_C] = static_cast<int>(Key::C);
+    io.KeyMap[ImGuiKey_V] = static_cast<int>(Key::V);
+    io.KeyMap[ImGuiKey_X] = static_cast<int>(Key::X);
+    io.KeyMap[ImGuiKey_Y] = static_cast<int>(Key::Y);
+    io.KeyMap[ImGuiKey_Z] = static_cast<int>(Key::Z);
 
-	io.RenderDrawListsFn = ImImpl_RenderDrawLists;
-	//io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; // @TODO implement? ---abock
-	//io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; // @TODO implement? ---abock
+    io.RenderDrawListsFn = ImImpl_RenderDrawLists;
+    //io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; // @TODO implement? ---abock
+    //io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; // @TODO implement? ---abock
 
-	_property.initialize();
-	_performance.initialize();
-	_help.initialize();
+    _property.initialize();
+    _performance.initialize();
+    _help.initialize();
 }
 
 void GUI::initializeGL() {
-	_program = ghoul::opengl::ProgramObject::Build(
+    _program = ghoul::opengl::ProgramObject::Build(
         "GUI",
-		"${MODULE_ONSCREENGUI}/shaders/gui_vs.glsl",
+        "${MODULE_ONSCREENGUI}/shaders/gui_vs.glsl",
         "${MODULE_ONSCREENGUI}/shaders/gui_fs.glsl"
     );
     if (!_program)
         return;
 
-	positionLocation = glGetAttribLocation(*_program, "in_position");
-	uvLocation = glGetAttribLocation(*_program, "in_uv");
-	colorLocation = glGetAttribLocation(*_program, "in_color");
+    positionLocation = glGetAttribLocation(*_program, "in_position");
+    uvLocation = glGetAttribLocation(*_program, "in_uv");
+    colorLocation = glGetAttribLocation(*_program, "in_color");
     
     glGenTextures(1, &fontTex);
-	glBindTexture(GL_TEXTURE_2D, fontTex);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	unsigned char* png_data;
-	int tex_x, tex_y;
+    glBindTexture(GL_TEXTURE_2D, fontTex);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    unsigned char* png_data;
+    int tex_x, tex_y;
     ImGui::GetIO().Fonts->GetTexDataAsRGBA32(&png_data, &tex_x, &tex_y);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_x, tex_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, png_data);
-	//stbi_image_free(tex_data);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, tex_x, tex_y, 0, GL_RGBA, GL_UNSIGNED_BYTE, png_data);
+    //stbi_image_free(tex_data);
 
-	glGenBuffers(1, &vbo);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo);
-	glBufferData(GL_ARRAY_BUFFER, vboMaxSize, NULL, GL_DYNAMIC_DRAW);
+    glGenBuffers(1, &vbo);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glBufferData(GL_ARRAY_BUFFER, vboMaxSize, NULL, GL_DYNAMIC_DRAW);
 
-	glGenVertexArrays(1, &vao);
-	glBindVertexArray(vao);
-	glBindBuffer(GL_ARRAY_BUFFER, vbo);
-	glEnableVertexAttribArray(positionLocation);
-	glEnableVertexAttribArray(uvLocation);
-	glEnableVertexAttribArray(colorLocation);
+    glGenVertexArrays(1, &vao);
+    glBindVertexArray(vao);
+    glBindBuffer(GL_ARRAY_BUFFER, vbo);
+    glEnableVertexAttribArray(positionLocation);
+    glEnableVertexAttribArray(uvLocation);
+    glEnableVertexAttribArray(colorLocation);
 
-	glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, pos));
-	glVertexAttribPointer(uvLocation, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, uv));
-	glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, col));
-	glBindVertexArray(0);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glVertexAttribPointer(positionLocation, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, pos));
+    glVertexAttribPointer(uvLocation, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, uv));
+    glVertexAttribPointer(colorLocation, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), (GLvoid*)offsetof(ImDrawVert, col));
+    glBindVertexArray(0);
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
     
 
-	_property.initializeGL();
-	_performance.initializeGL();
-	_help.initializeGL();
+    _property.initializeGL();
+    _performance.initializeGL();
+    _help.initializeGL();
 }
 
 void GUI::deinitializeGL() {
-	_program = nullptr;
+    _program = nullptr;
 
     glDeleteVertexArrays(1, &vao);
-	glDeleteBuffers(1, &vbo);
+    glDeleteBuffers(1, &vbo);
 
-	_property.deinitializeGL();
-	_performance.deinitializeGL();
-	_help.deinitializeGL();
+    _property.deinitializeGL();
+    _performance.deinitializeGL();
+    _help.deinitializeGL();
 }
 
 void GUI::startFrame(float deltaTime, const glm::vec2& windowSize,
@@ -256,54 +256,54 @@ void GUI::startFrame(float deltaTime, const glm::vec2& windowSize,
                      uint32_t mouseButtonsPressed)
 {
     
-	ImGuiIO& io = ImGui::GetIO();
-	io.DisplaySize = ImVec2(windowSize.x, windowSize.y);
-	io.DeltaTime = deltaTime;
+    ImGuiIO& io = ImGui::GetIO();
+    io.DisplaySize = ImVec2(windowSize.x, windowSize.y);
+    io.DeltaTime = deltaTime;
 #ifdef __APPLE__
     io.MousePos = ImVec2(mousePos.x * 2, mousePos.y * 2);
 #else
     io.MousePos = ImVec2(mousePos.x, mousePos.y);
 #endif
     io.MouseDown[0] = mouseButtonsPressed & (1 << 0);
-	io.MouseDown[1] = mouseButtonsPressed & (1 << 1);
+    io.MouseDown[1] = mouseButtonsPressed & (1 << 1);
 
-	ImGui::NewFrame();
+    ImGui::NewFrame();
 }
 
 void GUI::endFrame() {
-	renderMainWindow();
+    renderMainWindow();
 
-	if (_property.isEnabled())
-		_property.render();
-	if (_performance.isEnabled())
-		_performance.render();
-	if (_help.isEnabled())
-		_help.render();
+    if (_property.isEnabled())
+        _property.render();
+    if (_performance.isEnabled())
+        _performance.render();
+    if (_help.isEnabled())
+        _help.render();
 
-	ImGui::Render();
+    ImGui::Render();
 }
 
 bool GUI::mouseButtonCallback(MouseButton button, MouseAction action) {
 //bool GUI::mouseButtonCallback(int key, int action) {
-	ImGuiIO& io = ImGui::GetIO();
-	bool consumeEvent = io.WantCaptureMouse;
-	return consumeEvent;
+    ImGuiIO& io = ImGui::GetIO();
+    bool consumeEvent = io.WantCaptureMouse;
+    return consumeEvent;
 }
 
 bool GUI::mouseWheelCallback(double position) {
-	ImGuiIO& io = ImGui::GetIO();
-	bool consumeEvent = io.WantCaptureMouse;
-	if (consumeEvent)
-		io.MouseWheel = static_cast<float>(position);
+    ImGuiIO& io = ImGui::GetIO();
+    bool consumeEvent = io.WantCaptureMouse;
+    if (consumeEvent)
+        io.MouseWheel = static_cast<float>(position);
 
-	return consumeEvent;
+    return consumeEvent;
 }
 
 bool GUI::keyCallback(Key key, KeyModifier modifier, KeyAction action) {
 //bool GUI::keyCallback(int key, int action) {
-	ImGuiIO& io = ImGui::GetIO();
-	bool consumeEvent = io.WantCaptureKeyboard;
-	if (consumeEvent) {
+    ImGuiIO& io = ImGui::GetIO();
+    bool consumeEvent = io.WantCaptureKeyboard;
+    if (consumeEvent) {
         int keyIndex = static_cast<int>(key);
         if (keyIndex < 0)
             LERROR("Pressed key of index '" << keyIndex << "' was negative");
@@ -313,68 +313,68 @@ bool GUI::keyCallback(Key key, KeyModifier modifier, KeyAction action) {
             if (action == KeyAction::Release)
                 io.KeysDown[keyIndex] = false;
         }
-	}
-	return consumeEvent;
+    }
+    return consumeEvent;
 }
 
 bool GUI::charCallback(unsigned int character, KeyModifier modifier) {
-	ImGuiIO& io = ImGui::GetIO();
-	bool consumeEvent = io.WantCaptureKeyboard;
+    ImGuiIO& io = ImGui::GetIO();
+    bool consumeEvent = io.WantCaptureKeyboard;
 
-	if (consumeEvent)
-		io.AddInputCharacter((unsigned short)character);
+    if (consumeEvent)
+        io.AddInputCharacter((unsigned short)character);
 
-	return consumeEvent;
+    return consumeEvent;
 }
 
 //void GUI::registerProperty(properties::Property* prop) {
-//	using namespace properties;
+//    using namespace properties;
 //
-//	std::string className = prop->className();
+//    std::string className = prop->className();
 //
-//	if (className == "BoolProperty")
-//		_boolProperties.insert(prop);
-//	else if (className == "IntProperty")
-//		_intProperties.insert(prop);
-//	else if (className == "FloatProperty")
-//		_floatProperties.insert(prop);
-//	else if (className == "StringProperty")
-//		_stringProperties.insert(prop);
-//	else if (className == "Vec2Property")
-//		_vec2Properties.insert(prop);
-//	else if (className == "Vec3Property")
-//		_vec3Properties.insert(prop);
-//	else if (className == "Vec4Property")
-//		_vec4Properties.insert(prop);
-//	else if (className == "OptionProperty")
-//		_optionProperty.insert(prop);
-//	else if (className == "TriggerProperty")
-//		_triggerProperty.insert(prop);
-//	else if (className == "SelectionProperty")
-//		_selectionProperty.insert(prop);
-//	else {
-//		LWARNING("Class name '" << className << "' not handled in GUI generation");
-//		return;
-//	}
+//    if (className == "BoolProperty")
+//        _boolProperties.insert(prop);
+//    else if (className == "IntProperty")
+//        _intProperties.insert(prop);
+//    else if (className == "FloatProperty")
+//        _floatProperties.insert(prop);
+//    else if (className == "StringProperty")
+//        _stringProperties.insert(prop);
+//    else if (className == "Vec2Property")
+//        _vec2Properties.insert(prop);
+//    else if (className == "Vec3Property")
+//        _vec3Properties.insert(prop);
+//    else if (className == "Vec4Property")
+//        _vec4Properties.insert(prop);
+//    else if (className == "OptionProperty")
+//        _optionProperty.insert(prop);
+//    else if (className == "TriggerProperty")
+//        _triggerProperty.insert(prop);
+//    else if (className == "SelectionProperty")
+//        _selectionProperty.insert(prop);
+//    else {
+//        LWARNING("Class name '" << className << "' not handled in GUI generation");
+//        return;
+//    }
 //
-//	std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
-//	size_t pos = fullyQualifiedId.find('.');
-//	std::string owner = fullyQualifiedId.substr(0, pos);
+//    std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
+//    size_t pos = fullyQualifiedId.find('.');
+//    std::string owner = fullyQualifiedId.substr(0, pos);
 //
-//	auto it =_propertiesByOwner.find(owner);
-//	if (it == _propertiesByOwner.end())
-//		_propertiesByOwner[owner] = { prop };
-//	else
-//		it->second.push_back(prop);
+//    auto it =_propertiesByOwner.find(owner);
+//    if (it == _propertiesByOwner.end())
+//        _propertiesByOwner[owner] = { prop };
+//    else
+//        it->second.push_back(prop);
 //
 //}
 
 //>>>>>>> develop
 void GUI::renderMainWindow() {
-	ImGui::Begin("OpenSpace GUI", nullptr);
+    ImGui::Begin("OpenSpace GUI", nullptr);
 
-	ImGui::Checkbox("Properties", &_property._isEnabled);
-	ImGui::Checkbox("Performance", &_performance._isEnabled);
+    ImGui::Checkbox("Properties", &_property._isEnabled);
+    ImGui::Checkbox("Performance", &_performance._isEnabled);
     _origin.render();
     _time.render();
 
@@ -393,137 +393,137 @@ void GUI::renderMainWindow() {
     if (to67P)
         OsEng.scriptEngine().queueScript("openspace.setPropertyValue('Interaction.coordinateSystem', '67P');");
 
-	ImGui::Checkbox("Help", &_help._isEnabled);
+    ImGui::Checkbox("Help", &_help._isEnabled);
 
-	ImGui::End();
+    ImGui::End();
 }
 
 //<<<<<<< HEAD
 namespace {
 //=======
 //void GUI::renderPropertyWindow() {
-//	using namespace properties;
+//    using namespace properties;
 //
-//	ImGui::Begin("Properties", &_showPropertyWindow, size, 0.5f);
+//    ImGui::Begin("Properties", &_showPropertyWindow, size, 0.5f);
 //
-//	//ImGui::ShowUserGuide();
-//	ImGui::Spacing();
+//    //ImGui::ShowUserGuide();
+//    ImGui::Spacing();
 //
-//	for (const auto& p : _propertiesByOwner) {
-//		if (ImGui::CollapsingHeader(p.first.c_str())) {
-//			for (properties::Property* prop : p.second) {
-//				if (_boolProperties.find(prop) != _boolProperties.end()) {
-//					renderBoolProperty(prop, p.first);
-//					continue;
-//				}
+//    for (const auto& p : _propertiesByOwner) {
+//        if (ImGui::CollapsingHeader(p.first.c_str())) {
+//            for (properties::Property* prop : p.second) {
+//                if (_boolProperties.find(prop) != _boolProperties.end()) {
+//                    renderBoolProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_intProperties.find(prop) != _intProperties.end()) {
-//					renderIntProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_intProperties.find(prop) != _intProperties.end()) {
+//                    renderIntProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_floatProperties.find(prop) != _floatProperties.end()) {
-//					renderFloatProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_floatProperties.find(prop) != _floatProperties.end()) {
+//                    renderFloatProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_vec2Properties.find(prop) != _vec2Properties.end()) {
-//					renderVec2Property(prop, p.first);
-//					continue;
-//				}
+//                if (_vec2Properties.find(prop) != _vec2Properties.end()) {
+//                    renderVec2Property(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_vec3Properties.find(prop) != _vec3Properties.end()) {
-//					renderVec3Property(prop, p.first);
-//					continue;
-//				}
+//                if (_vec3Properties.find(prop) != _vec3Properties.end()) {
+//                    renderVec3Property(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_vec4Properties.find(prop) != _vec4Properties.end()) {
-//					renderVec4Property(prop, p.first);
-//					continue;
-//				}
+//                if (_vec4Properties.find(prop) != _vec4Properties.end()) {
+//                    renderVec4Property(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_optionProperty.find(prop) != _optionProperty.end()) {
-//					renderOptionProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_optionProperty.find(prop) != _optionProperty.end()) {
+//                    renderOptionProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_triggerProperty.find(prop) != _triggerProperty.end()) {
-//					renderTriggerProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_triggerProperty.find(prop) != _triggerProperty.end()) {
+//                    renderTriggerProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_selectionProperty.find(prop) != _selectionProperty.end()) {
-//					renderSelectionProperty(prop, p.first);
-//					continue;
-//				}
-//			}
-//		}
-//	}
+//                if (_selectionProperty.find(prop) != _selectionProperty.end()) {
+//                    renderSelectionProperty(prop, p.first);
+//                    continue;
+//                }
+//            }
+//        }
+//    }
 //
-//	ImGui::End();
+//    ImGui::End();
 //}
 //
 //void GUI::renderPerformanceWindow() {
-//	// Copy and paste from renderengine.cpp::storePerformanceMeasurements method
-//	const int8_t Version = 0;
-//	const int nValues = 250;
-//	const int lengthName = 256;
-//	const int maxValues = 50;
+//    // Copy and paste from renderengine.cpp::storePerformanceMeasurements method
+//    const int8_t Version = 0;
+//    const int nValues = 250;
+//    const int lengthName = 256;
+//    const int maxValues = 50;
 //
-//	struct PerformanceLayout {
-//		int8_t version;
-//		int32_t nValuesPerEntry;
-//		int32_t nEntries;
-//		int32_t maxNameLength;
-//		int32_t maxEntries;
+//    struct PerformanceLayout {
+//        int8_t version;
+//        int32_t nValuesPerEntry;
+//        int32_t nEntries;
+//        int32_t maxNameLength;
+//        int32_t maxEntries;
 //
-//		struct PerformanceLayoutEntry {
-//			char name[lengthName];
-//			float renderTime[nValues];
-//			float updateRenderable[nValues];
-//			float updateEphemeris[nValues];
+//        struct PerformanceLayoutEntry {
+//            char name[lengthName];
+//            float renderTime[nValues];
+//            float updateRenderable[nValues];
+//            float updateEphemeris[nValues];
 //
-//			int32_t currentRenderTime;
-//			int32_t currentUpdateRenderable;
-//			int32_t currentUpdateEphemeris;
-//		};
+//            int32_t currentRenderTime;
+//            int32_t currentUpdateRenderable;
+//            int32_t currentUpdateEphemeris;
+//        };
 //
-//		PerformanceLayoutEntry entries[maxValues];
-//	};
+//        PerformanceLayoutEntry entries[maxValues];
+//    };
 //
-//	ImGui::Begin("Performance", &_showPerformanceWindow);
-//	if (OsEng.renderEngine()->doesPerformanceMeasurements() &&
-//			ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
-//	{
-//		ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
-//		_minMaxValues[1] = std::max(_minMaxValues[0], _minMaxValues[1]);
+//    ImGui::Begin("Performance", &_showPerformanceWindow);
+//    if (OsEng.renderEngine()->doesPerformanceMeasurements() &&
+//            ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
+//    {
+//        ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
+//        _minMaxValues[1] = std::max(_minMaxValues[0], _minMaxValues[1]);
 //
-//		if (!_performanceMemory)
-//			_performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
+//        if (!_performanceMemory)
+//            _performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
 //
-//		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
+//        PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
 //
-//		for (int i = 0; i < layout->nEntries; ++i) {
-//			const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
+//        for (int i = 0; i < layout->nEntries; ++i) {
+//            const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
 //
-//			if (ImGui::CollapsingHeader(entry.name)) {
-//				std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
-//				ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//            if (ImGui::CollapsingHeader(entry.name)) {
+//                std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
+//                ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
 //
-//				std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
-//				ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
-//				
-//				std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
-//				ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
-//			}
-//		}
-//	}
-//	else {
-//		ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
-//						   "'openspace.setPerformanceMeasurement(true)'");
-//	}
+//                std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
+//                ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//                
+//                std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
+//                ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//            }
+//        }
+//    }
+//    else {
+//        ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
+//                           "'openspace.setPerformanceMeasurement(true)'");
+//    }
 //
-//	ImGui::End();
+//    ImGui::End();
 //}
 //
 //namespace  {
@@ -535,12 +535,12 @@ namespace {
  * Shows the GUI
  */
 int show(lua_State* L) {
-	int nArguments = lua_gettop(L);
-	if (nArguments != 0)
-		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
+    int nArguments = lua_gettop(L);
+    if (nArguments != 0)
+        return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui().setEnabled(true);
-	return 0;
+    OsEng.gui().setEnabled(true);
+    return 0;
 }
 
 /**
@@ -549,12 +549,12 @@ int show(lua_State* L) {
  * Hides the console
  */
 int hide(lua_State* L) {
-	int nArguments = lua_gettop(L);
-	if (nArguments != 0)
-		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
+    int nArguments = lua_gettop(L);
+    if (nArguments != 0)
+        return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui().setEnabled(false);
-	return 0;
+    OsEng.gui().setEnabled(false);
+    return 0;
 }
 
 /**
@@ -563,40 +563,40 @@ int hide(lua_State* L) {
  * Toggles the console
  */
 int toggle(lua_State* L) {
-	int nArguments = lua_gettop(L);
-	if (nArguments != 0)
-		return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
+    int nArguments = lua_gettop(L);
+    if (nArguments != 0)
+        return luaL_error(L, "Expected %i arguments, got %i", 0, nArguments);
 
-	OsEng.gui().setEnabled(!OsEng.gui().isEnabled());
-	return 0;
+    OsEng.gui().setEnabled(!OsEng.gui().isEnabled());
+    return 0;
 }
 
 }
 
 scripting::ScriptEngine::LuaLibrary GUI::luaLibrary() {
-	return {
-		"gui",
-		{
-			{
-				"show",
-				&show,
-				"",
-				"Shows the console"
-			},
-			{
-				"hide",
-				&hide,
-				"",
-				"Hides the console"
-			},
-			{
-				"toggle",
-				&toggle,
-				"",
-				"Toggles the console"
-			}
-		}
-	};
+    return {
+        "gui",
+        {
+            {
+                "show",
+                &show,
+                "",
+                "Shows the console"
+            },
+            {
+                "hide",
+                &hide,
+                "",
+                "Hides the console"
+            },
+            {
+                "toggle",
+                &toggle,
+                "",
+                "Toggles the console"
+            }
+        }
+    };
 }
 
 
@@ -645,80 +645,80 @@ scripting::ScriptEngine::LuaLibrary GUI::luaLibrary() {
 //#include <stb_image.h>
 //
 //namespace {
-//	const std::string _loggerCat = "GUI";
-//	const std::string configurationFile = "imgui.ini";
+//    const std::string _loggerCat = "GUI";
+//    const std::string configurationFile = "imgui.ini";
 //
 //
 //namespace openspace {
-//	namespace gui {
+//    namespace gui {
 //
 //GUI::GUI()
-//	: _isEnabled(false)
-//	, _showPropertyWindow(false)
-//	, _showHelp(false)
-//	, _performanceMemory(nullptr)
+//    : _isEnabled(false)
+//    , _showPropertyWindow(false)
+//    , _showHelp(false)
+//    , _performanceMemory(nullptr)
 //{
-//	_minMaxValues[0] = 100.f;
-//	_minMaxValues[1] = 1000.f;
+//    _minMaxValues[0] = 100.f;
+//    _minMaxValues[1] = 1000.f;
 //}
 //
 //GUI::~GUI() {
-//	delete _performanceMemory;
-//	ImGui::Shutdown();
+//    delete _performanceMemory;
+//    ImGui::Shutdown();
 //}
 //
 //bool GUI::isEnabled() const {
-//	return _isEnabled;
+//    return _isEnabled;
 //}
 //
 //void GUI::setEnabled(bool enabled) {
-//	_isEnabled = enabled;
+//    _isEnabled = enabled;
 //}
 //
 //void GUI::initialize() {
-//	std::string cachedFile;
-//	FileSys.cacheManager()->getCachedFile(configurationFile, "", cachedFile, true);
+//    std::string cachedFile;
+//    FileSys.cacheManager()->getCachedFile(configurationFile, "", cachedFile, true);
 //
-//	char* buffer = new char[cachedFile.size() + 1];
+//    char* buffer = new char[cachedFile.size() + 1];
 //
 //#ifdef WIN32
-//	strcpy_s(buffer, cachedFile.size() + 1, cachedFile.c_str());
+//    strcpy_s(buffer, cachedFile.size() + 1, cachedFile.c_str());
 //#else
-//	strcpy(buffer, cachedFile.c_str());
+//    strcpy(buffer, cachedFile.c_str());
 //#endif
 //
-//	ImGuiIO& io = ImGui::GetIO();
-//	io.IniFilename = buffer;
-//	//io.IniSavingRate = 5.f;
-//	io.DeltaTime = 1.f / 60.f;
-//	io.PixelCenterOffset = 0.5f;
-//	io.KeyMap[ImGuiKey_Tab] = SGCT_KEY_TAB;                       // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
-//	io.KeyMap[ImGuiKey_LeftArrow] = SGCT_KEY_LEFT;
-//	io.KeyMap[ImGuiKey_RightArrow] = SGCT_KEY_RIGHT;
-//	io.KeyMap[ImGuiKey_UpArrow] = SGCT_KEY_UP;
-//	io.KeyMap[ImGuiKey_DownArrow] = SGCT_KEY_DOWN;
-//	io.KeyMap[ImGuiKey_Home] = SGCT_KEY_HOME;
-//	io.KeyMap[ImGuiKey_End] = SGCT_KEY_END;
-//	io.KeyMap[ImGuiKey_Delete] = SGCT_KEY_DELETE;
-//	io.KeyMap[ImGuiKey_Backspace] = SGCT_KEY_BACKSPACE;
-//	io.KeyMap[ImGuiKey_Enter] = SGCT_KEY_ENTER;
-//	io.KeyMap[ImGuiKey_Escape] = SGCT_KEY_ESCAPE;
-//	io.KeyMap[ImGuiKey_A] = SGCT_KEY_A;
-//	io.KeyMap[ImGuiKey_C] = SGCT_KEY_C;
-//	io.KeyMap[ImGuiKey_V] = SGCT_KEY_V;
-//	io.KeyMap[ImGuiKey_X] = SGCT_KEY_X;
-//	io.KeyMap[ImGuiKey_Y] = SGCT_KEY_Y;
-//	io.KeyMap[ImGuiKey_Z] = SGCT_KEY_Z;
+//    ImGuiIO& io = ImGui::GetIO();
+//    io.IniFilename = buffer;
+//    //io.IniSavingRate = 5.f;
+//    io.DeltaTime = 1.f / 60.f;
+//    io.PixelCenterOffset = 0.5f;
+//    io.KeyMap[ImGuiKey_Tab] = SGCT_KEY_TAB;                       // Keyboard mapping. ImGui will use those indices to peek into the io.KeyDown[] array.
+//    io.KeyMap[ImGuiKey_LeftArrow] = SGCT_KEY_LEFT;
+//    io.KeyMap[ImGuiKey_RightArrow] = SGCT_KEY_RIGHT;
+//    io.KeyMap[ImGuiKey_UpArrow] = SGCT_KEY_UP;
+//    io.KeyMap[ImGuiKey_DownArrow] = SGCT_KEY_DOWN;
+//    io.KeyMap[ImGuiKey_Home] = SGCT_KEY_HOME;
+//    io.KeyMap[ImGuiKey_End] = SGCT_KEY_END;
+//    io.KeyMap[ImGuiKey_Delete] = SGCT_KEY_DELETE;
+//    io.KeyMap[ImGuiKey_Backspace] = SGCT_KEY_BACKSPACE;
+//    io.KeyMap[ImGuiKey_Enter] = SGCT_KEY_ENTER;
+//    io.KeyMap[ImGuiKey_Escape] = SGCT_KEY_ESCAPE;
+//    io.KeyMap[ImGuiKey_A] = SGCT_KEY_A;
+//    io.KeyMap[ImGuiKey_C] = SGCT_KEY_C;
+//    io.KeyMap[ImGuiKey_V] = SGCT_KEY_V;
+//    io.KeyMap[ImGuiKey_X] = SGCT_KEY_X;
+//    io.KeyMap[ImGuiKey_Y] = SGCT_KEY_Y;
+//    io.KeyMap[ImGuiKey_Z] = SGCT_KEY_Z;
 //
-//	io.RenderDrawListsFn = ImImpl_RenderDrawLists;
-//	//io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; // @TODO implement? ---abock
-//	//io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; // @TODO implement? ---abock
+//    io.RenderDrawListsFn = ImImpl_RenderDrawLists;
+//    //io.SetClipboardTextFn = ImImpl_SetClipboardTextFn; // @TODO implement? ---abock
+//    //io.GetClipboardTextFn = ImImpl_GetClipboardTextFn; // @TODO implement? ---abock
 //}
 //
 //void GUI::initializeGL() {
-//	_program = ghoul::opengl::ProgramObject::Build("GUI",
-//		"${SHADERS}/gui_vs.glsl", "${SHADERS}/gui_fs.glsl");
-//		
+//    _program = ghoul::opengl::ProgramObject::Build("GUI",
+//        "${SHADERS}/gui_vs.glsl", "${SHADERS}/gui_fs.glsl");
+//        
 //    positionLocation = glGetAttribLocation(*_program, "in_position");
 //    uvLocation = glGetAttribLocation(*_program, "in_uv");
 //    colorLocation = glGetAttribLocation(*_program, "in_color");
@@ -754,252 +754,252 @@ scripting::ScriptEngine::LuaLibrary GUI::luaLibrary() {
 //}
 //
 //void GUI::deinitializeGL() {
-//	if(_program)
-//		delete _program;
-//	_program = nullptr;
+//    if(_program)
+//        delete _program;
+//    _program = nullptr;
 //
-//	if (vao) glDeleteVertexArrays(1, &vao);
+//    if (vao) glDeleteVertexArrays(1, &vao);
 //    if (vbo) glDeleteBuffers(1, &vbo);
 //}
 //
 //void GUI::startFrame(float deltaTime,
-//				const glm::vec2& windowSize,
-//				 const glm::vec2& mousePos,
-//				 bool mouseButtonsPressed[2])
+//                const glm::vec2& windowSize,
+//                 const glm::vec2& mousePos,
+//                 bool mouseButtonsPressed[2])
 //{
-//	ImGuiIO& io = ImGui::GetIO();
-//	io.DisplaySize = ImVec2(windowSize.x, windowSize.y);
-//	io.DeltaTime = deltaTime;
-//	io.MousePos = ImVec2(mousePos.x, mousePos.y);
-//	io.MouseDown[0] = mouseButtonsPressed[0];
-//	io.MouseDown[1] = mouseButtonsPressed[1];
+//    ImGuiIO& io = ImGui::GetIO();
+//    io.DisplaySize = ImVec2(windowSize.x, windowSize.y);
+//    io.DeltaTime = deltaTime;
+//    io.MousePos = ImVec2(mousePos.x, mousePos.y);
+//    io.MouseDown[0] = mouseButtonsPressed[0];
+//    io.MouseDown[1] = mouseButtonsPressed[1];
 //
-//	ImGui::NewFrame();
+//    ImGui::NewFrame();
 //}
 //
 //void GUI::endFrame() {
-//	static bool show = true;
-//	//ImGui::ShowTestWindow(&show);
-//	renderMainWindow();
-//	if (_showPropertyWindow)
-//		renderPropertyWindow();
-//	if (_showPerformanceWindow)
-//		renderPerformanceWindow();
+//    static bool show = true;
+//    //ImGui::ShowTestWindow(&show);
+//    renderMainWindow();
+//    if (_showPropertyWindow)
+//        renderPropertyWindow();
+//    if (_showPerformanceWindow)
+//        renderPerformanceWindow();
 //
-//	ImGui::Render();
+//    ImGui::Render();
 //}
 //
 //bool GUI::mouseButtonCallback(int key, int action) {
-//	ImGuiIO& io = ImGui::GetIO();
-//	bool consumeEvent = io.WantCaptureMouse;
-//	return consumeEvent;
+//    ImGuiIO& io = ImGui::GetIO();
+//    bool consumeEvent = io.WantCaptureMouse;
+//    return consumeEvent;
 //}
 //
 //bool GUI::mouseWheelCallback(int position) {
-//	ImGuiIO& io = ImGui::GetIO();
-//	bool consumeEvent = io.WantCaptureMouse;
-//	if (consumeEvent)
-//		io.MouseWheel = static_cast<float>(position);
+//    ImGuiIO& io = ImGui::GetIO();
+//    bool consumeEvent = io.WantCaptureMouse;
+//    if (consumeEvent)
+//        io.MouseWheel = static_cast<float>(position);
 //
-//	return consumeEvent;
+//    return consumeEvent;
 //}
 //
 //bool GUI::keyCallback(int key, int action) {
-//	ImGuiIO& io = ImGui::GetIO();
-//	bool consumeEvent = io.WantCaptureKeyboard;
-//	if (consumeEvent) {
-//		if (action == SGCT_PRESS)
-//			io.KeysDown[key] = true;
-//		if (action == SGCT_RELEASE)
-//			io.KeysDown[key] = false;
-//	}
-//	return consumeEvent;
+//    ImGuiIO& io = ImGui::GetIO();
+//    bool consumeEvent = io.WantCaptureKeyboard;
+//    if (consumeEvent) {
+//        if (action == SGCT_PRESS)
+//            io.KeysDown[key] = true;
+//        if (action == SGCT_RELEASE)
+//            io.KeysDown[key] = false;
+//    }
+//    return consumeEvent;
 //}
 //
 //bool GUI::charCallback(unsigned int character) {
-//	ImGuiIO& io = ImGui::GetIO();
-//	bool consumeEvent = io.WantCaptureKeyboard;
+//    ImGuiIO& io = ImGui::GetIO();
+//    bool consumeEvent = io.WantCaptureKeyboard;
 //
-//	if (consumeEvent)
-//		io.AddInputCharacter((unsigned short)character);
+//    if (consumeEvent)
+//        io.AddInputCharacter((unsigned short)character);
 //
-//	return consumeEvent;
+//    return consumeEvent;
 //}
 //
 //void GUI::registerProperty(properties::Property* prop) {
-//	using namespace openspace::properties;
+//    using namespace openspace::properties;
 //
-//	std::string className = prop->className();
+//    std::string className = prop->className();
 //
-//	if (className == "BoolProperty")
-//		_boolProperties.insert(prop);
-//	else if (className == "IntProperty")
-//		_intProperties.insert(prop);
-//	else if (className == "FloatProperty")
-//		_floatProperties.insert(prop);
-//	else if (className == "StringProperty")
-//		_stringProperties.insert(prop);
-//	else if (className == "Vec2Property")
-//		_vec2Properties.insert(prop);
-//	else if (className == "Vec3Property")
-//		_vec3Properties.insert(prop);
-//	else if (className == "OptionProperty")
-//		_optionProperty.insert(prop);
-//	else if (className == "TriggerProperty")
-//		_triggerProperty.insert(prop);
-//	else if (className == "SelectionProperty")
-//		_selectionProperty.insert(prop);
-//	else {
-//		LWARNING("Class name '" << className << "' not handled in GUI generation");
-//		return;
-//	}
+//    if (className == "BoolProperty")
+//        _boolProperties.insert(prop);
+//    else if (className == "IntProperty")
+//        _intProperties.insert(prop);
+//    else if (className == "FloatProperty")
+//        _floatProperties.insert(prop);
+//    else if (className == "StringProperty")
+//        _stringProperties.insert(prop);
+//    else if (className == "Vec2Property")
+//        _vec2Properties.insert(prop);
+//    else if (className == "Vec3Property")
+//        _vec3Properties.insert(prop);
+//    else if (className == "OptionProperty")
+//        _optionProperty.insert(prop);
+//    else if (className == "TriggerProperty")
+//        _triggerProperty.insert(prop);
+//    else if (className == "SelectionProperty")
+//        _selectionProperty.insert(prop);
+//    else {
+//        LWARNING("Class name '" << className << "' not handled in GUI generation");
+//        return;
+//    }
 //
-//	std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
-//	size_t pos = fullyQualifiedId.find('.');
-//	std::string owner = fullyQualifiedId.substr(0, pos);
+//    std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
+//    size_t pos = fullyQualifiedId.find('.');
+//    std::string owner = fullyQualifiedId.substr(0, pos);
 //
-//	auto it =_propertiesByOwner.find(owner);
-//	if (it == _propertiesByOwner.end())
-//		_propertiesByOwner[owner] = { prop };
-//	else
-//		it->second.push_back(prop);
+//    auto it =_propertiesByOwner.find(owner);
+//    if (it == _propertiesByOwner.end())
+//        _propertiesByOwner[owner] = { prop };
+//    else
+//        it->second.push_back(prop);
 //
 //}
 //
 //void GUI::renderMainWindow() {
-//	ImGui::Begin("OpenSpace GUI", nullptr);
+//    ImGui::Begin("OpenSpace GUI", nullptr);
 //
-//	ImGui::Checkbox("Properties", &_showPropertyWindow);
-//	ImGui::Checkbox("Performance", &_showPerformanceWindow);
-//	ImGui::Checkbox("Help", &_showHelp);
+//    ImGui::Checkbox("Properties", &_showPropertyWindow);
+//    ImGui::Checkbox("Performance", &_showPerformanceWindow);
+//    ImGui::Checkbox("Help", &_showHelp);
 //
-//	if (_showHelp) {
-//		ImGui::Separator();
-//		ImGui::ShowUserGuide();
-//		ImGui::ShowTestWindow();
-//	}
+//    if (_showHelp) {
+//        ImGui::Separator();
+//        ImGui::ShowUserGuide();
+//        ImGui::ShowTestWindow();
+//    }
 //
-//	ImGui::End();
+//    ImGui::End();
 //}
 //
 //void GUI::renderPropertyWindow() {
-//	using namespace properties;
+//    using namespace properties;
 //
-//	ImGui::Begin("Properties", &_showPropertyWindow, size, 0.5f);
+//    ImGui::Begin("Properties", &_showPropertyWindow, size, 0.5f);
 //
-//	//ImGui::ShowUserGuide();
-//	ImGui::Spacing();
+//    //ImGui::ShowUserGuide();
+//    ImGui::Spacing();
 //
-//	for (const auto& p : _propertiesByOwner) {
-//		if (ImGui::CollapsingHeader(p.first.c_str())) {
-//			for (properties::Property* prop : p.second) {
-//				if (_boolProperties.find(prop) != _boolProperties.end()) {
-//					renderBoolProperty(prop, p.first);
-//					continue;
-//				}
+//    for (const auto& p : _propertiesByOwner) {
+//        if (ImGui::CollapsingHeader(p.first.c_str())) {
+//            for (properties::Property* prop : p.second) {
+//                if (_boolProperties.find(prop) != _boolProperties.end()) {
+//                    renderBoolProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_intProperties.find(prop) != _intProperties.end()) {
-//					renderIntProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_intProperties.find(prop) != _intProperties.end()) {
+//                    renderIntProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_floatProperties.find(prop) != _floatProperties.end()) {
-//					renderFloatProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_floatProperties.find(prop) != _floatProperties.end()) {
+//                    renderFloatProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_vec2Properties.find(prop) != _vec2Properties.end()) {
-//					renderVec2Property(prop, p.first);
-//					continue;
-//				}
+//                if (_vec2Properties.find(prop) != _vec2Properties.end()) {
+//                    renderVec2Property(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_vec3Properties.find(prop) != _vec3Properties.end()) {
-//					renderVec3Property(prop, p.first);
-//					continue;
-//				}
+//                if (_vec3Properties.find(prop) != _vec3Properties.end()) {
+//                    renderVec3Property(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_optionProperty.find(prop) != _optionProperty.end()) {
-//					renderOptionProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_optionProperty.find(prop) != _optionProperty.end()) {
+//                    renderOptionProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_triggerProperty.find(prop) != _triggerProperty.end()) {
-//					renderTriggerProperty(prop, p.first);
-//					continue;
-//				}
+//                if (_triggerProperty.find(prop) != _triggerProperty.end()) {
+//                    renderTriggerProperty(prop, p.first);
+//                    continue;
+//                }
 //
-//				if (_selectionProperty.find(prop) != _selectionProperty.end()) {
-//					renderSelectionProperty(prop, p.first);
-//					continue;
-//				}
-//			}
-//		}
-//	}
+//                if (_selectionProperty.find(prop) != _selectionProperty.end()) {
+//                    renderSelectionProperty(prop, p.first);
+//                    continue;
+//                }
+//            }
+//        }
+//    }
 //
-//	ImGui::End();
+//    ImGui::End();
 //}
 //
 //void GUI::renderPerformanceWindow() {
-//	// Copy and paste from renderengine.cpp::storePerformanceMeasurements method
-//	const int8_t Version = 0;
-//	const int nValues = 250;
-//	const int lengthName = 256;
-//	const int maxValues = 50;
+//    // Copy and paste from renderengine.cpp::storePerformanceMeasurements method
+//    const int8_t Version = 0;
+//    const int nValues = 250;
+//    const int lengthName = 256;
+//    const int maxValues = 50;
 //
-//	struct PerformanceLayout {
-//		int8_t version;
-//		int32_t nValuesPerEntry;
-//		int32_t nEntries;
-//		int32_t maxNameLength;
-//		int32_t maxEntries;
+//    struct PerformanceLayout {
+//        int8_t version;
+//        int32_t nValuesPerEntry;
+//        int32_t nEntries;
+//        int32_t maxNameLength;
+//        int32_t maxEntries;
 //
-//		struct PerformanceLayoutEntry {
-//			char name[lengthName];
-//			float renderTime[nValues];
-//			float updateRenderable[nValues];
-//			float updateEphemeris[nValues];
+//        struct PerformanceLayoutEntry {
+//            char name[lengthName];
+//            float renderTime[nValues];
+//            float updateRenderable[nValues];
+//            float updateEphemeris[nValues];
 //
-//			int32_t currentRenderTime;
-//			int32_t currentUpdateRenderable;
-//			int32_t currentUpdateEphemeris;
-//		};
+//            int32_t currentRenderTime;
+//            int32_t currentUpdateRenderable;
+//            int32_t currentUpdateEphemeris;
+//        };
 //
-//		PerformanceLayoutEntry entries[maxValues];
-//	};
+//        PerformanceLayoutEntry entries[maxValues];
+//    };
 //
-//	ImGui::Begin("Performance", &_showPerformanceWindow);
-//	if (OsEng.renderEngine().doesPerformanceMeasurements() &&
-//			ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
-//	{
-//		ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
-//		_minMaxValues[1] = std::max(_minMaxValues[0], _minMaxValues[1]);
+//    ImGui::Begin("Performance", &_showPerformanceWindow);
+//    if (OsEng.renderEngine().doesPerformanceMeasurements() &&
+//            ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
+//    {
+//        ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
+//        _minMaxValues[1] = std::max(_minMaxValues[0], _minMaxValues[1]);
 //
-//		if (!_performanceMemory)
-//			_performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
+//        if (!_performanceMemory)
+//            _performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
 //
-//		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
+//        PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(_performanceMemory->pointer());
 //
-//		for (int i = 0; i < layout->nEntries; ++i) {
-//			const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
+//        for (int i = 0; i < layout->nEntries; ++i) {
+//            const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
 //
-//			if (ImGui::CollapsingHeader(entry.name)) {
-//				std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
-//				ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//            if (ImGui::CollapsingHeader(entry.name)) {
+//                std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
+//                ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
 //
-//				std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
-//				ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
-//				
-//				std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
-//				ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
-//			}
-//		}
-//	}
-//	else {
-//		ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
-//						   "'openspace.setPerformanceMeasurement(true)'");
-//	}
+//                std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
+//                ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//                
+//                std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
+//                ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+//            }
+//        }
+//    }
+//    else {
+//        ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
+//                           "'openspace.setPerformanceMeasurement(true)'");
+//    }
 //
-//	ImGui::End();
+//    ImGui::End();
 //}
 //
 //
diff --git a/modules/onscreengui/src/guicomponent.cpp b/modules/onscreengui/src/guicomponent.cpp
index 01925b4c19..afd9b5ab6a 100644
--- a/modules/onscreengui/src/guicomponent.cpp
+++ b/modules/onscreengui/src/guicomponent.cpp
@@ -28,11 +28,11 @@ namespace openspace {
 namespace gui {
 
 bool GuiComponent::isEnabled() const {
-	return _isEnabled;
+    return _isEnabled;
 }
 
 void GuiComponent::setEnabled(bool enabled) {
-	_isEnabled = enabled;
+    _isEnabled = enabled;
 }
 
 void GuiComponent::initialize() {}
diff --git a/modules/onscreengui/src/guihelpcomponent.cpp b/modules/onscreengui/src/guihelpcomponent.cpp
index e3392e13df..4530891a18 100644
--- a/modules/onscreengui/src/guihelpcomponent.cpp
+++ b/modules/onscreengui/src/guihelpcomponent.cpp
@@ -27,16 +27,16 @@
 #include "imgui.h"
 
 namespace {
-	const ImVec2 size = ImVec2(350, 500);
+    const ImVec2 size = ImVec2(350, 500);
 }
 
 namespace openspace {
 namespace gui {
 
 void GuiHelpComponent::render() {
-	ImGui::Begin("Help", &_isEnabled, size, 0.5f);
-	ImGui::ShowUserGuide();
-	ImGui::End();
+    ImGui::Begin("Help", &_isEnabled, size, 0.5f);
+    ImGui::ShowUserGuide();
+    ImGui::End();
 }
 
 } // gui
diff --git a/modules/onscreengui/src/guiorigincomponent.cpp b/modules/onscreengui/src/guiorigincomponent.cpp
index 19381bc4c6..9a0f72564a 100644
--- a/modules/onscreengui/src/guiorigincomponent.cpp
+++ b/modules/onscreengui/src/guiorigincomponent.cpp
@@ -32,7 +32,7 @@
 #include "imgui.h"
 
 namespace {
-	const std::string _loggerCat = "GuiOriginComponent";
+    const std::string _loggerCat = "GuiOriginComponent";
 }
 
 namespace openspace {
@@ -128,55 +128,55 @@ void GuiOriginComponent::render() {
  //       }
  //   }
 
-	//ImGui::End();
+    //ImGui::End();
 //}
 //
 //GuiPropertyComponent::PropertyType GuiPropertyComponent::toPropertyType(
-//	const std::string& name) const
+//    const std::string& name) const
 //{
-//	if (name == "BoolProperty")
-//		return PropertyType::BoolProperty;
-//	if (name == "IntProperty")
-//		return PropertyType::IntProperty;
-//	if (name == "FloatProperty")
-//		return PropertyType::FloatProperty;
-//	if (name == "Vec2Property")
-//		return PropertyType::Vec2Property;
-//	if (name == "Vec3Property")
-//		return PropertyType::Vec3Property;
-//	if (name == "StringProperty")
-//		return PropertyType::StringProperty;
-//	if (name == "OptionProperty")
-//		return PropertyType::OptionProperty;
-//	if (name == "SelectionProperty")
-//		return PropertyType::SelectionProperty;
-//	if (name == "TriggerProperty")
-//		return PropertyType::TriggerProperty;
+//    if (name == "BoolProperty")
+//        return PropertyType::BoolProperty;
+//    if (name == "IntProperty")
+//        return PropertyType::IntProperty;
+//    if (name == "FloatProperty")
+//        return PropertyType::FloatProperty;
+//    if (name == "Vec2Property")
+//        return PropertyType::Vec2Property;
+//    if (name == "Vec3Property")
+//        return PropertyType::Vec3Property;
+//    if (name == "StringProperty")
+//        return PropertyType::StringProperty;
+//    if (name == "OptionProperty")
+//        return PropertyType::OptionProperty;
+//    if (name == "SelectionProperty")
+//        return PropertyType::SelectionProperty;
+//    if (name == "TriggerProperty")
+//        return PropertyType::TriggerProperty;
 //
-//	LWARNING("Unsupported property type '" << name << "'");
-//	return PropertyType::InvalidPropertyType;
+//    LWARNING("Unsupported property type '" << name << "'");
+//    return PropertyType::InvalidPropertyType;
 //}
 //
 //void GuiPropertyComponent::renderProperty(const PropertyInfo& info) const {
-//	switch (info.type) {
-//		case PropertyType::BoolProperty:
-//		{
-//			//	BoolProperty* p = static_cast<BoolProperty*>(prop);
-//			//	std::string name = p->guiName();
+//    switch (info.type) {
+//        case PropertyType::BoolProperty:
+//        {
+//            //    BoolProperty* p = static_cast<BoolProperty*>(prop);
+//            //    std::string name = p->guiName();
 //
-//			//	BoolProperty::ValueType value = *p;
-//			//	ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
-//			//	p->set(value);
+//            //    BoolProperty::ValueType value = *p;
+//            //    ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
+//            //    p->set(value);
 //
 //
-//			
+//            
 //
-//			break;
-//		}
-//		default:
+//            break;
+//        }
+//        default:
 //            LERROR("Missing case statement: {" << int(info.type) << "," << info.identifier << "}");
-//			//ghoul_assert(false, "Missing case statement");
-//		}
+//            //ghoul_assert(false, "Missing case statement");
+//        }
 //
 //}
 
diff --git a/modules/onscreengui/src/guiperformancecomponent.cpp b/modules/onscreengui/src/guiperformancecomponent.cpp
index b06a68312c..e12c639288 100644
--- a/modules/onscreengui/src/guiperformancecomponent.cpp
+++ b/modules/onscreengui/src/guiperformancecomponent.cpp
@@ -31,86 +31,86 @@
 #include <algorithm>
 
 namespace {
-	const std::string _loggerCat = "GuiPerformanceComponent";
+    const std::string _loggerCat = "GuiPerformanceComponent";
 }
 
 namespace openspace {
 namespace gui {
 
 void GuiPerformanceComponent::initialize() {
-	_minMaxValues[0] = 100.f;
-	_minMaxValues[1] = 250.f;
+    _minMaxValues[0] = 100.f;
+    _minMaxValues[1] = 250.f;
 }
 
 void GuiPerformanceComponent::deinitialize() {
-	delete _performanceMemory;
-	_performanceMemory = nullptr;
+    delete _performanceMemory;
+    _performanceMemory = nullptr;
 }
 
 void GuiPerformanceComponent::render() {
-	// Copy and paste from renderengine.cpp::storePerformanceMeasurements method
-//	const int8_t Version = 0;
-	const int nValues = 250;
-	const int lengthName = 256;
-	const int maxValues = 256;
+    // Copy and paste from renderengine.cpp::storePerformanceMeasurements method
+//    const int8_t Version = 0;
+    const int nValues = 250;
+    const int lengthName = 256;
+    const int maxValues = 256;
 
-	struct PerformanceLayout {
-		int8_t version;
-		int32_t nValuesPerEntry;
-		int32_t nEntries;
-		int32_t maxNameLength;
-		int32_t maxEntries;
+    struct PerformanceLayout {
+        int8_t version;
+        int32_t nValuesPerEntry;
+        int32_t nEntries;
+        int32_t maxNameLength;
+        int32_t maxEntries;
 
-		struct PerformanceLayoutEntry {
-			char name[lengthName];
-			float renderTime[nValues];
-			float updateRenderable[nValues];
-			float updateEphemeris[nValues];
+        struct PerformanceLayoutEntry {
+            char name[lengthName];
+            float renderTime[nValues];
+            float updateRenderable[nValues];
+            float updateEphemeris[nValues];
 
-			int32_t currentRenderTime;
-			int32_t currentUpdateRenderable;
-			int32_t currentUpdateEphemeris;
-		};
+            int32_t currentRenderTime;
+            int32_t currentUpdateRenderable;
+            int32_t currentUpdateEphemeris;
+        };
 
-		PerformanceLayoutEntry entries[maxValues];
-	};
+        PerformanceLayoutEntry entries[maxValues];
+    };
 
-	ImGui::Begin("Performance", &_isEnabled);
-	if (OsEng.renderEngine().doesPerformanceMeasurements() &&
-			ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
-	{
-		ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
-		_minMaxValues[1] = fmaxf(_minMaxValues[0], _minMaxValues[1]);
-		
+    ImGui::Begin("Performance", &_isEnabled);
+    if (OsEng.renderEngine().doesPerformanceMeasurements() &&
+            ghoul::SharedMemory::exists(RenderEngine::PerformanceMeasurementSharedData))
+    {
+        ImGui::SliderFloat2("Min values, max Value", _minMaxValues, 0.f, 10000.f);
+        _minMaxValues[1] = fmaxf(_minMaxValues[0], _minMaxValues[1]);
+        
 
-		if (!_performanceMemory)
-			_performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
+        if (!_performanceMemory)
+            _performanceMemory = new ghoul::SharedMemory(RenderEngine::PerformanceMeasurementSharedData);
 
 
         void* ptr = _performanceMemory->memory();
-		PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(ptr);
+        PerformanceLayout* layout = reinterpret_cast<PerformanceLayout*>(ptr);
 
-		for (int i = 0; i < layout->nEntries; ++i) {
-			const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
+        for (int i = 0; i < layout->nEntries; ++i) {
+            const PerformanceLayout::PerformanceLayoutEntry& entry = layout->entries[i];
 
-			if (ImGui::CollapsingHeader(entry.name)) {
-				std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
-				ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+            if (ImGui::CollapsingHeader(entry.name)) {
+                std::string updateEphemerisTime = std::to_string(entry.updateEphemeris[entry.currentUpdateEphemeris - 1]) + "us";
+                ImGui::PlotLines("UpdateEphemeris", &entry.updateEphemeris[0], layout->nValuesPerEntry, 0, updateEphemerisTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
 
-				std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
-				ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+                std::string updateRenderableTime = std::to_string(entry.updateRenderable[entry.currentUpdateRenderable - 1]) + "us";
+                ImGui::PlotLines("UpdateRender", &entry.updateRenderable[0], layout->nValuesPerEntry, 0, updateRenderableTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
 
-				std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
-				ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
-			}
-		}
-	}
-	else {
-		ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
-						   "'openspace.setPerformanceMeasurement(true)'");
-	}
+                std::string renderTime = std::to_string(entry.renderTime[entry.currentRenderTime - 1]) + "us";
+                ImGui::PlotLines("RenderTime", &entry.renderTime[0], layout->nValuesPerEntry, 0, renderTime.c_str(), _minMaxValues[0], _minMaxValues[1], ImVec2(0, 40));
+            }
+        }
+    }
+    else {
+        ImGui::TextWrapped("Performance monitoring is disabled. Enable with "
+                           "'openspace.setPerformanceMeasurement(true)'");
+    }
 
-	ImGui::End();
+    ImGui::End();
 }
 
 
diff --git a/modules/onscreengui/src/guipropertycomponent.cpp b/modules/onscreengui/src/guipropertycomponent.cpp
index bf006eb507..cdac55f613 100644
--- a/modules/onscreengui/src/guipropertycomponent.cpp
+++ b/modules/onscreengui/src/guipropertycomponent.cpp
@@ -40,10 +40,10 @@
 #include "imgui.h"
 
 namespace {
-	const std::string _loggerCat = "GuiPropertyComponent";
-	const ImVec2 size = ImVec2(350, 500);
+    const std::string _loggerCat = "GuiPropertyComponent";
+    const ImVec2 size = ImVec2(350, 500);
 
-	using namespace openspace::properties;
+    using namespace openspace::properties;
 
     void executeScript(const std::string& id, const std::string& value) {
         std::string script =
@@ -198,97 +198,97 @@ namespace {
             executeScript(prop->fullyQualifiedIdentifier(), "0");
     }
 
-	//void renderBoolProperty(Property* prop, const std::string& ownerName) {
-	//	BoolProperty* p = static_cast<BoolProperty*>(prop);
-	//	std::string name = p->guiName();
+    //void renderBoolProperty(Property* prop, const std::string& ownerName) {
+    //    BoolProperty* p = static_cast<BoolProperty*>(prop);
+    //    std::string name = p->guiName();
 
-	//	BoolProperty::ValueType value = *p;
-	//	ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
-	//	p->set(value);
-	//}
+    //    BoolProperty::ValueType value = *p;
+    //    ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
+    //    p->set(value);
+    //}
 
-	//void renderOptionProperty(Property* prop, const std::string& ownerName) {
-	//	OptionProperty* p = static_cast<OptionProperty*>(prop);
-	//	std::string name = p->guiName();
+    //void renderOptionProperty(Property* prop, const std::string& ownerName) {
+    //    OptionProperty* p = static_cast<OptionProperty*>(prop);
+    //    std::string name = p->guiName();
 
-	//	int value = *p;
-	//	std::vector<OptionProperty::Option> options = p->options();
-	//	for (const OptionProperty::Option& o : options) {
-	//		ImGui::RadioButton((ownerName + "." + name).c_str(), &value, o.value);
-	//		ImGui::SameLine();
-	//		ImGui::Text(o.description.c_str());
-	//	}
-	//	p->set(value);
-	//}
+    //    int value = *p;
+    //    std::vector<OptionProperty::Option> options = p->options();
+    //    for (const OptionProperty::Option& o : options) {
+    //        ImGui::RadioButton((ownerName + "." + name).c_str(), &value, o.value);
+    //        ImGui::SameLine();
+    //        ImGui::Text(o.description.c_str());
+    //    }
+    //    p->set(value);
+    //}
 
-	//void renderSelectionProperty(Property* prop, const std::string& ownerName) {
-	//	SelectionProperty* p = static_cast<SelectionProperty*>(prop);
-	//	std::string name = p->guiName();
+    //void renderSelectionProperty(Property* prop, const std::string& ownerName) {
+    //    SelectionProperty* p = static_cast<SelectionProperty*>(prop);
+    //    std::string name = p->guiName();
 
-	//	if (ImGui::CollapsingHeader((ownerName + "." + name).c_str())) {
-	//		const std::vector<SelectionProperty::Option>& options = p->options();
-	//		std::vector<int> newSelectedIndices;
+    //    if (ImGui::CollapsingHeader((ownerName + "." + name).c_str())) {
+    //        const std::vector<SelectionProperty::Option>& options = p->options();
+    //        std::vector<int> newSelectedIndices;
 
-	//		std::vector<int> selectedIndices = p->value();
+    //        std::vector<int> selectedIndices = p->value();
 
-	//		for (int i = 0; i < options.size(); ++i) {
-	//			std::string description = options[i].description;
-	//			bool selected = std::find(selectedIndices.begin(), selectedIndices.end(), i) != selectedIndices.end();
-	//			ImGui::Checkbox(description.c_str(), &selected);
+    //        for (int i = 0; i < options.size(); ++i) {
+    //            std::string description = options[i].description;
+    //            bool selected = std::find(selectedIndices.begin(), selectedIndices.end(), i) != selectedIndices.end();
+    //            ImGui::Checkbox(description.c_str(), &selected);
 
-	//			if (selected)
-	//				newSelectedIndices.push_back(i);
-	//		}
+    //            if (selected)
+    //                newSelectedIndices.push_back(i);
+    //        }
 
-	//		p->setValue(std::move(newSelectedIndices));
-	//	}
-	//}
+    //        p->setValue(std::move(newSelectedIndices));
+    //    }
+    //}
 
-	//void renderIntProperty(Property* prop, const std::string& ownerName) {
-	//	IntProperty* p = static_cast<IntProperty*>(prop);
-	//	std::string name = p->guiName();
+    //void renderIntProperty(Property* prop, const std::string& ownerName) {
+    //    IntProperty* p = static_cast<IntProperty*>(prop);
+    //    std::string name = p->guiName();
 
-	//	IntProperty::ValueType value = *p;
-	//	ImGui::SliderInt((ownerName + "." + name).c_str(), &value, p->minValue(), p->maxValue());
-	//	p->set(value);
-	//}
+    //    IntProperty::ValueType value = *p;
+    //    ImGui::SliderInt((ownerName + "." + name).c_str(), &value, p->minValue(), p->maxValue());
+    //    p->set(value);
+    //}
 
-	//void renderFloatProperty(Property* prop, const std::string& ownerName) {
-	//	FloatProperty* p = static_cast<FloatProperty*>(prop);
-	//	std::string name = p->guiName();
+    //void renderFloatProperty(Property* prop, const std::string& ownerName) {
+    //    FloatProperty* p = static_cast<FloatProperty*>(prop);
+    //    std::string name = p->guiName();
 
-	//	FloatProperty::ValueType value = *p;
-	//	ImGui::SliderFloat((ownerName + "." + name).c_str(), &value, p->minValue(), p->maxValue());
-	//	p->set(value);
-	//}
+    //    FloatProperty::ValueType value = *p;
+    //    ImGui::SliderFloat((ownerName + "." + name).c_str(), &value, p->minValue(), p->maxValue());
+    //    p->set(value);
+    //}
 
-	//void renderVec2Property(Property* prop, const std::string& ownerName) {
-	//	Vec2Property* p = static_cast<Vec2Property*>(prop);
-	//	std::string name = p->guiName();
+    //void renderVec2Property(Property* prop, const std::string& ownerName) {
+    //    Vec2Property* p = static_cast<Vec2Property*>(prop);
+    //    std::string name = p->guiName();
 
-	//	Vec2Property::ValueType value = *p;
+    //    Vec2Property::ValueType value = *p;
 
-	//	ImGui::SliderFloat2((ownerName + "." + name).c_str(), &value.x, p->minValue().x, p->maxValue().x);
-	//	p->set(value);
-	//}
+    //    ImGui::SliderFloat2((ownerName + "." + name).c_str(), &value.x, p->minValue().x, p->maxValue().x);
+    //    p->set(value);
+    //}
 
 
-	//void renderVec3Property(Property* prop, const std::string& ownerName) {
-	//	Vec3Property* p = static_cast<Vec3Property*>(prop);
-	//	std::string name = p->guiName();
+    //void renderVec3Property(Property* prop, const std::string& ownerName) {
+    //    Vec3Property* p = static_cast<Vec3Property*>(prop);
+    //    std::string name = p->guiName();
 
-	//	Vec3Property::ValueType value = *p;
+    //    Vec3Property::ValueType value = *p;
 
-	//	ImGui::SliderFloat3((ownerName + "." + name).c_str(), &value.x, p->minValue().x, p->maxValue().x);
-	//	p->set(value);
-	//}
+    //    ImGui::SliderFloat3((ownerName + "." + name).c_str(), &value.x, p->minValue().x, p->maxValue().x);
+    //    p->set(value);
+    //}
 
-	//void renderTriggerProperty(Property* prop, const std::string& ownerName) {
-	//	std::string name = prop->guiName();
-	//	bool pressed = ImGui::Button((ownerName + "." + name).c_str());
-	//	if (pressed)
-	//		prop->set(0);
-	//}
+    //void renderTriggerProperty(Property* prop, const std::string& ownerName) {
+    //    std::string name = prop->guiName();
+    //    bool pressed = ImGui::Button((ownerName + "." + name).c_str());
+    //    if (pressed)
+    //        prop->set(0);
+    //}
 
 }
 
@@ -296,43 +296,43 @@ namespace openspace {
 namespace gui {
 
 //void GuiPropertyComponent::registerProperty(properties::Property* prop) {
-	//registerProperty(prop->description());
-	//using namespace properties;
+    //registerProperty(prop->description());
+    //using namespace properties;
 
-	//std::string className = prop->className();
+    //std::string className = prop->className();
 
-	//if (className == "BoolProperty")
-	//	_boolProperties.insert(prop);
-	//else if (className == "IntProperty")
-	//	_intProperties.insert(prop);
-	//else if (className == "FloatProperty")
-	//	_floatProperties.insert(prop);
-	//else if (className == "StringProperty")
-	//	_stringProperties.insert(prop);
-	//else if (className == "Vec2Property")
-	//	_vec2Properties.insert(prop);
-	//else if (className == "Vec3Property")
-	//	_vec3Properties.insert(prop);
-	//else if (className == "OptionProperty")
-	//	_optionProperty.insert(prop);
-	//else if (className == "TriggerProperty")
-	//	_triggerProperty.insert(prop);
-	//else if (className == "SelectionProperty")
-	//	_selectionProperty.insert(prop);
-	//else {
-	//	LWARNING("Class name '" << className << "' not handled in GUI generation");
-	//	return;
-	//}
+    //if (className == "BoolProperty")
+    //    _boolProperties.insert(prop);
+    //else if (className == "IntProperty")
+    //    _intProperties.insert(prop);
+    //else if (className == "FloatProperty")
+    //    _floatProperties.insert(prop);
+    //else if (className == "StringProperty")
+    //    _stringProperties.insert(prop);
+    //else if (className == "Vec2Property")
+    //    _vec2Properties.insert(prop);
+    //else if (className == "Vec3Property")
+    //    _vec3Properties.insert(prop);
+    //else if (className == "OptionProperty")
+    //    _optionProperty.insert(prop);
+    //else if (className == "TriggerProperty")
+    //    _triggerProperty.insert(prop);
+    //else if (className == "SelectionProperty")
+    //    _selectionProperty.insert(prop);
+    //else {
+    //    LWARNING("Class name '" << className << "' not handled in GUI generation");
+    //    return;
+    //}
 
-	//std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
-	//size_t pos = fullyQualifiedId.find('.');
-	//std::string owner = fullyQualifiedId.substr(0, pos);
+    //std::string fullyQualifiedId = prop->fullyQualifiedIdentifier();
+    //size_t pos = fullyQualifiedId.find('.');
+    //std::string owner = fullyQualifiedId.substr(0, pos);
 
-	//auto it = _propertiesByOwner.find(owner);
-	//if (it == _propertiesByOwner.end())
-	//	_propertiesByOwner[owner] = { prop };
-	//else
-	//	it->second.push_back(prop);
+    //auto it = _propertiesByOwner.find(owner);
+    //if (it == _propertiesByOwner.end())
+    //    _propertiesByOwner[owner] = { prop };
+    //else
+    //    it->second.push_back(prop);
 
 //}
 
@@ -377,59 +377,59 @@ void GuiPropertyComponent::registerProperty(properties::Property* prop) {
     else
         it->second.push_back(prop);
 
-	//ghoul::Dictionary dictionary;
-	//ghoul::lua::loadDictionaryFromString(propertyDescription, dictionary);
+    //ghoul::Dictionary dictionary;
+    //ghoul::lua::loadDictionaryFromString(propertyDescription, dictionary);
 
-	//handleProperty(dictionary);
+    //handleProperty(dictionary);
 }
 
 void GuiPropertyComponent::handleProperty(const ghoul::Dictionary& dictionary) {
-	//static const std::string TypeKey = "Type";
-	//static const std::string IdentifierKey = "Identifier";
-	//static const std::string NameKey = "Name";
-	//static const std::string GroupKey = "MetaData.Group";
+    //static const std::string TypeKey = "Type";
+    //static const std::string IdentifierKey = "Identifier";
+    //static const std::string NameKey = "Name";
+    //static const std::string GroupKey = "MetaData.Group";
 
-	//ghoul_assert(
-	//	dictionary.hasKeyAndValue<std::string>(TypeKey), "Missing Type key"
-	//);
-	//ghoul_assert(
-	//	dictionary.hasKeyAndValue<std::string>(IdentifierKey), "Missing Identifier key"
-	//);
-	//ghoul_assert(
-	//	dictionary.hasKeyAndValue<std::string>(NameKey), "Missing Name key"
-	//);
-	//ghoul_assert(
-	//	dictionary.hasKeyAndValue<std::string>(GroupKey), "Missing Group key"
-	//);
+    //ghoul_assert(
+    //    dictionary.hasKeyAndValue<std::string>(TypeKey), "Missing Type key"
+    //);
+    //ghoul_assert(
+    //    dictionary.hasKeyAndValue<std::string>(IdentifierKey), "Missing Identifier key"
+    //);
+    //ghoul_assert(
+    //    dictionary.hasKeyAndValue<std::string>(NameKey), "Missing Name key"
+    //);
+    //ghoul_assert(
+    //    dictionary.hasKeyAndValue<std::string>(GroupKey), "Missing Group key"
+    //);
 
-	//std::string typeString = dictionary.value<std::string>(TypeKey);
-	//std::string identifier = dictionary.value<std::string>(IdentifierKey);
-	//std::string name = dictionary.value<std::string>(NameKey);
-	//std::string group = dictionary.value<std::string>(GroupKey);
+    //std::string typeString = dictionary.value<std::string>(TypeKey);
+    //std::string identifier = dictionary.value<std::string>(IdentifierKey);
+    //std::string name = dictionary.value<std::string>(NameKey);
+    //std::string group = dictionary.value<std::string>(GroupKey);
 
-	//PropertyType type = toPropertyType(typeString);
-	//
-	//size_t pos = identifier.find('.');
-	//std::string owner = identifier.substr(0, pos);
+    //PropertyType type = toPropertyType(typeString);
+    //
+    //size_t pos = identifier.find('.');
+    //std::string owner = identifier.substr(0, pos);
 
-	//PropertyInfo info = { type, identifier, name, group };
+    //PropertyInfo info = { type, identifier, name, group };
 
-	//auto it = std::find_if(_properties.begin(), _properties.end(),
-	//	[owner](const Property& prop) {
-	//		return prop.owner == owner;
-	//});
-	//if (it == _properties.end()) {
-	//	Property p;
-	//	p.owner = owner;
-	//	p.properties = {info};
-	//	_properties.push_back(p);
-	//}
-	//else
-	//	it->properties.push_back(std::move(info));
+    //auto it = std::find_if(_properties.begin(), _properties.end(),
+    //    [owner](const Property& prop) {
+    //        return prop.owner == owner;
+    //});
+    //if (it == _properties.end()) {
+    //    Property p;
+    //    p.owner = owner;
+    //    p.properties = {info};
+    //    _properties.push_back(p);
+    //}
+    //else
+    //    it->properties.push_back(std::move(info));
 }
 
 void GuiPropertyComponent::render() {
-	ImGui::Begin("Properties", &_isEnabled, size, 0.5f);
+    ImGui::Begin("Properties", &_isEnabled, size, 0.5f);
 
     if (ImGui::CollapsingHeader("OnScreen GUI")) {
         glm::vec2& pos = OsEng.renderEngine()._onScreenInformation._position;
@@ -506,111 +506,111 @@ void GuiPropertyComponent::render() {
         }
     }
 
-	//for (const Property& prop : _properties) {
-	//	if (ImGui::CollapsingHeader(prop.owner.c_str())) {
-	//		for (const PropertyInfo& info : prop.properties) {
-	//			renderProperty(info);
-	//		}
-	//	}
- //	}
+    //for (const Property& prop : _properties) {
+    //    if (ImGui::CollapsingHeader(prop.owner.c_str())) {
+    //        for (const PropertyInfo& info : prop.properties) {
+    //            renderProperty(info);
+    //        }
+    //    }
+ //    }
 
 
 
-	//for (const auto& p : _propertiesByOwner) {
-	//	if (ImGui::CollapsingHeader(p.first.c_str())) {
-	//		for (properties::Property* prop : p.second) {
-	//			if (_boolProperties.find(prop) != _boolProperties.end()) {
-	//				renderBoolProperty(prop, p.first);
-	//				continue;
-	//			}
+    //for (const auto& p : _propertiesByOwner) {
+    //    if (ImGui::CollapsingHeader(p.first.c_str())) {
+    //        for (properties::Property* prop : p.second) {
+    //            if (_boolProperties.find(prop) != _boolProperties.end()) {
+    //                renderBoolProperty(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_intProperties.find(prop) != _intProperties.end()) {
-	//				renderIntProperty(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_intProperties.find(prop) != _intProperties.end()) {
+    //                renderIntProperty(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_floatProperties.find(prop) != _floatProperties.end()) {
-	//				renderFloatProperty(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_floatProperties.find(prop) != _floatProperties.end()) {
+    //                renderFloatProperty(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_vec2Properties.find(prop) != _vec2Properties.end()) {
-	//				renderVec2Property(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_vec2Properties.find(prop) != _vec2Properties.end()) {
+    //                renderVec2Property(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_vec3Properties.find(prop) != _vec3Properties.end()) {
-	//				renderVec3Property(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_vec3Properties.find(prop) != _vec3Properties.end()) {
+    //                renderVec3Property(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_optionProperty.find(prop) != _optionProperty.end()) {
-	//				renderOptionProperty(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_optionProperty.find(prop) != _optionProperty.end()) {
+    //                renderOptionProperty(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_triggerProperty.find(prop) != _triggerProperty.end()) {
-	//				renderTriggerProperty(prop, p.first);
-	//				continue;
-	//			}
+    //            if (_triggerProperty.find(prop) != _triggerProperty.end()) {
+    //                renderTriggerProperty(prop, p.first);
+    //                continue;
+    //            }
 
-	//			if (_selectionProperty.find(prop) != _selectionProperty.end()) {
-	//				renderSelectionProperty(prop, p.first);
-	//				continue;
-	//			}
-	//		}
-	//	}
-	//}
+    //            if (_selectionProperty.find(prop) != _selectionProperty.end()) {
+    //                renderSelectionProperty(prop, p.first);
+    //                continue;
+    //            }
+    //        }
+    //    }
+    //}
 
-	ImGui::End();
+    ImGui::End();
 }
 
 GuiPropertyComponent::PropertyType GuiPropertyComponent::toPropertyType(
-	const std::string& name) const
+    const std::string& name) const
 {
-	if (name == "BoolProperty")
-		return PropertyType::BoolProperty;
-	if (name == "IntProperty")
-		return PropertyType::IntProperty;
-	if (name == "FloatProperty")
-		return PropertyType::FloatProperty;
-	if (name == "Vec2Property")
-		return PropertyType::Vec2Property;
-	if (name == "Vec3Property")
-		return PropertyType::Vec3Property;
-	if (name == "StringProperty")
-		return PropertyType::StringProperty;
-	if (name == "OptionProperty")
-		return PropertyType::OptionProperty;
-	if (name == "SelectionProperty")
-		return PropertyType::SelectionProperty;
-	if (name == "TriggerProperty")
-		return PropertyType::TriggerProperty;
+    if (name == "BoolProperty")
+        return PropertyType::BoolProperty;
+    if (name == "IntProperty")
+        return PropertyType::IntProperty;
+    if (name == "FloatProperty")
+        return PropertyType::FloatProperty;
+    if (name == "Vec2Property")
+        return PropertyType::Vec2Property;
+    if (name == "Vec3Property")
+        return PropertyType::Vec3Property;
+    if (name == "StringProperty")
+        return PropertyType::StringProperty;
+    if (name == "OptionProperty")
+        return PropertyType::OptionProperty;
+    if (name == "SelectionProperty")
+        return PropertyType::SelectionProperty;
+    if (name == "TriggerProperty")
+        return PropertyType::TriggerProperty;
 
-	LWARNING("Unsupported property type '" << name << "'");
-	return PropertyType::InvalidPropertyType;
+    LWARNING("Unsupported property type '" << name << "'");
+    return PropertyType::InvalidPropertyType;
 }
 
 void GuiPropertyComponent::renderProperty(const PropertyInfo& info) const {
-	switch (info.type) {
-		case PropertyType::BoolProperty:
-		{
-			//	BoolProperty* p = static_cast<BoolProperty*>(prop);
-			//	std::string name = p->guiName();
+    switch (info.type) {
+        case PropertyType::BoolProperty:
+        {
+            //    BoolProperty* p = static_cast<BoolProperty*>(prop);
+            //    std::string name = p->guiName();
 
-			//	BoolProperty::ValueType value = *p;
-			//	ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
-			//	p->set(value);
+            //    BoolProperty::ValueType value = *p;
+            //    ImGui::Checkbox((ownerName + "." + name).c_str(), &value);
+            //    p->set(value);
 
 
-			
+            
 
-			break;
-		}
-		default:
+            break;
+        }
+        default:
             LERROR("Missing case statement: {" << int(info.type) << "," << info.identifier << "}");
-			//ghoul_assert(false, "Missing case statement");
-		}
+            //ghoul_assert(false, "Missing case statement");
+        }
 
 }
 
diff --git a/modules/onscreengui/src/guitimecomponent.cpp b/modules/onscreengui/src/guitimecomponent.cpp
index 2bffaafa22..37ad900f17 100644
--- a/modules/onscreengui/src/guitimecomponent.cpp
+++ b/modules/onscreengui/src/guitimecomponent.cpp
@@ -31,7 +31,7 @@
 #include "imgui.h"
 
 namespace {
-	const std::string _loggerCat = "GuiTimeComponent";
+    const std::string _loggerCat = "GuiTimeComponent";
 }
 
 namespace openspace {
diff --git a/modules/toyvolume/shaders/boundsFs.glsl b/modules/toyvolume/shaders/boundsFs.glsl
index 34b184df57..bb4f9c8cd3 100644
--- a/modules/toyvolume/shaders/boundsFs.glsl
+++ b/modules/toyvolume/shaders/boundsFs.glsl
@@ -29,9 +29,9 @@ in vec4 worldPosition;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 fragColor = vec4(vPosition+0.5, 1.0);
-	vec4 position = worldPosition;
-	float depth = pscDepth(position);
+    vec4 fragColor = vec4(vPosition+0.5, 1.0);
+    vec4 position = worldPosition;
+    float depth = pscDepth(position);
 
     Fragment frag;
     frag.color = fragColor;
diff --git a/modules/toyvolume/shaders/boundsVs.glsl b/modules/toyvolume/shaders/boundsVs.glsl
index fc328f30df..ab1cd161f7 100644
--- a/modules/toyvolume/shaders/boundsVs.glsl
+++ b/modules/toyvolume/shaders/boundsVs.glsl
@@ -35,13 +35,13 @@ out vec4 worldPosition;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vPosition = vertPosition.xyz;
-	worldPosition = modelTransform*vertPosition;
-	
-	vec4 position = pscTransform(worldPosition, mat4(1.0));
+    vPosition = vertPosition.xyz;
+    worldPosition = modelTransform*vertPosition;
     
-	// project the position to view space
-	gl_Position = viewProjection * position;
+    vec4 position = pscTransform(worldPosition, mat4(1.0));
+    
+    // project the position to view space
+    gl_Position = viewProjection * position;
 
     gl_Position.z = 1.0;
 }
diff --git a/modules/volume/rendering/renderablevolume.cpp b/modules/volume/rendering/renderablevolume.cpp
index 431a6bbac2..33dce60490 100644
--- a/modules/volume/rendering/renderablevolume.cpp
+++ b/modules/volume/rendering/renderablevolume.cpp
@@ -82,16 +82,16 @@ ghoul::opengl::Texture* RenderableVolume::loadVolume(
     const std::string& filepath, 
     const ghoul::Dictionary& hintsDictionary) {
 
-	if( ! FileSys.fileExists(filepath)) {
-		LWARNING("Could not load volume, could not find '" << filepath << "'");
-		return nullptr;
-	}
+    if( ! FileSys.fileExists(filepath)) {
+        LWARNING("Could not load volume, could not find '" << filepath << "'");
+        return nullptr;
+    }
 
-	if(hasExtension(filepath, "raw")) {
-		ghoul::RawVolumeReader::ReadHints hints = readHints(hintsDictionary);
-		ghoul::RawVolumeReader rawReader(hints);
-		return rawReader.read(filepath);
-	} else if(hasExtension(filepath, "cdf")) {
+    if(hasExtension(filepath, "raw")) {
+        ghoul::RawVolumeReader::ReadHints hints = readHints(hintsDictionary);
+        ghoul::RawVolumeReader rawReader(hints);
+        return rawReader.read(filepath);
+    } else if(hasExtension(filepath, "cdf")) {
 
         ghoul::opengl::Texture::FilterMode filtermode = ghoul::opengl::Texture::FilterMode::Linear;
         ghoul::opengl::Texture::WrappingMode wrappingmode = ghoul::opengl::Texture::WrappingMode::ClampToEdge;
@@ -139,28 +139,28 @@ ghoul::opengl::Texture* RenderableVolume::loadVolume(
         std::stringstream ss;
         ss << "." << dimensions[0] << "x" << dimensions[1] << "x" << dimensions[2] << "." << "." << variableCacheString << ".cache";
 
-		 // = filepath + ss.str();
+         // = filepath + ss.str();
         ghoul::filesystem::File ghlFile(filepath);
         std::string cachepath = FileSys.cacheManager()->cachedFilename(ghlFile.baseName(),
                                                                        ss.str(),  true);
-		if (cache && FileSys.fileExists(cachepath)) {
+        if (cache && FileSys.fileExists(cachepath)) {
            
 #define VOLUME_LOAD_PROGRESSBAR
             std::ifstream file(cachepath, std::ios::binary | std::ios::in);
-			if (file.is_open()) {
-				size_t length = dimensions[0] * dimensions[1] * dimensions[2];
-				float* data = new float[length];
+            if (file.is_open()) {
+                size_t length = dimensions[0] * dimensions[1] * dimensions[2];
+                float* data = new float[length];
 #ifdef VOLUME_LOAD_PROGRESSBAR
-				LINFO("Loading cache: " << cachepath);
-				ProgressBar pb(static_cast<int>(dimensions[2]));
-				for (size_t i = 0; i < dimensions[2]; ++i) {
-					size_t offset = length / dimensions[2];
-					std::streamsize offsetsize = sizeof(float)*offset;
-					file.read(reinterpret_cast<char*>(data + offset * i), offsetsize);
-					pb.print(static_cast<int>(i));
-				}
+                LINFO("Loading cache: " << cachepath);
+                ProgressBar pb(static_cast<int>(dimensions[2]));
+                for (size_t i = 0; i < dimensions[2]; ++i) {
+                    size_t offset = length / dimensions[2];
+                    std::streamsize offsetsize = sizeof(float)*offset;
+                    file.read(reinterpret_cast<char*>(data + offset * i), offsetsize);
+                    pb.print(static_cast<int>(i));
+                }
 #else
-				file.read(reinterpret_cast<char*>(data), sizeof(float)*length);
+                file.read(reinterpret_cast<char*>(data), sizeof(float)*length);
 #endif
                 file.close();
                 return new ghoul::opengl::Texture(data, dimensions, ghoul::opengl::Texture::Format::Red, GL_RED, GL_FLOAT, filtermode, wrappingmode);
@@ -169,10 +169,10 @@ ghoul::opengl::Texture* RenderableVolume::loadVolume(
             }
         }
 
-		KameleonWrapper kw(filepath);
-		std::string variableString;
-		if (hintsDictionary.hasKey("Variable") && hintsDictionary.getValue("Variable", variableString)) {
-			float* data = kw.getUniformSampledValues(variableString, dimensions);
+        KameleonWrapper kw(filepath);
+        std::string variableString;
+        if (hintsDictionary.hasKey("Variable") && hintsDictionary.getValue("Variable", variableString)) {
+            float* data = kw.getUniformSampledValues(variableString, dimensions);
             if(cache) {
                 std::ofstream file(cachepath, std::ios::binary | std::ios::out);
                 if (file.is_open()) {
@@ -181,45 +181,45 @@ ghoul::opengl::Texture* RenderableVolume::loadVolume(
                     file.close();
                 }
             }
-        	return new ghoul::opengl::Texture(data, dimensions, ghoul::opengl::Texture::Format::Red, GL_RED, GL_FLOAT, filtermode, wrappingmode);
-		} else if (hintsDictionary.hasKey("Variables")) {
-			std::string xVariable, yVariable, zVariable;
-			bool xVar, yVar, zVar;
-			xVar = hintsDictionary.getValue("Variables.1", xVariable);
-			yVar = hintsDictionary.getValue("Variables.2", yVariable);
-			zVar = hintsDictionary.getValue("Variables.3", zVariable);
+            return new ghoul::opengl::Texture(data, dimensions, ghoul::opengl::Texture::Format::Red, GL_RED, GL_FLOAT, filtermode, wrappingmode);
+        } else if (hintsDictionary.hasKey("Variables")) {
+            std::string xVariable, yVariable, zVariable;
+            bool xVar, yVar, zVar;
+            xVar = hintsDictionary.getValue("Variables.1", xVariable);
+            yVar = hintsDictionary.getValue("Variables.2", yVariable);
+            zVar = hintsDictionary.getValue("Variables.3", zVariable);
 
-			if (!xVar || !yVar || !zVar) {
-				LERROR("Error reading variables! Must be 3 and must exist in CDF data");
-			} else {
+            if (!xVar || !yVar || !zVar) {
+                LERROR("Error reading variables! Must be 3 and must exist in CDF data");
+            } else {
 
-				float* data = kw.getUniformSampledVectorValues(xVariable, yVariable, zVariable, dimensions);
+                float* data = kw.getUniformSampledVectorValues(xVariable, yVariable, zVariable, dimensions);
                 if(cache) {
                     //FILE* file = fopen (cachepath.c_str(), "wb");
-					std::ofstream file(cachepath, std::ios::in | std::ios::binary);
-					size_t length = dimensions[0] * dimensions[1] * dimensions[2];
-					file.write(reinterpret_cast<char*>(data), sizeof(float)*length);
+                    std::ofstream file(cachepath, std::ios::in | std::ios::binary);
+                    size_t length = dimensions[0] * dimensions[1] * dimensions[2];
+                    file.write(reinterpret_cast<char*>(data), sizeof(float)*length);
                     file.close();
                 }
 
-				return new ghoul::opengl::Texture(data, dimensions, ghoul::opengl::Texture::Format::RGBA, GL_RGBA, GL_FLOAT, filtermode, wrappingmode);
-			}
+                return new ghoul::opengl::Texture(data, dimensions, ghoul::opengl::Texture::Format::RGBA, GL_RGBA, GL_FLOAT, filtermode, wrappingmode);
+            }
 
-		} else {
-			LWARNING("Hints does not specify a 'Variable' or 'Variables'");
-		}
-	} else {
-		LWARNING("No valid file extension.");
-	}
-	return nullptr;
+        } else {
+            LWARNING("Hints does not specify a 'Variable' or 'Variables'");
+        }
+    } else {
+        LWARNING("No valid file extension.");
+    }
+    return nullptr;
 }
 
 glm::vec3 RenderableVolume::getVolumeOffset(
-		const std::string& filepath,
-		const ghoul::Dictionary& hintsDictionary) {
+        const std::string& filepath,
+        const ghoul::Dictionary& hintsDictionary) {
 
-	KameleonWrapper kw(filepath);
-	return kw.getModelBarycenterOffset();
+    KameleonWrapper kw(filepath);
+    return kw.getModelBarycenterOffset();
 }
 
 ghoul::RawVolumeReader::ReadHints RenderableVolume::readHints(const ghoul::Dictionary& dictionary) {
@@ -454,8 +454,8 @@ ghoul::opengl::Texture* RenderableVolume::loadTransferFunction(const std::string
     // }
 
     return new ghoul::opengl::Texture(transferFunction,
-    		glm::size3_t(width,1,1),ghoul::opengl::Texture::Format::RGBA,
-    		GL_RGBA, GL_FLOAT,filtermode, wrappingmode);
+            glm::size3_t(width,1,1),ghoul::opengl::Texture::Format::RGBA,
+            GL_RGBA, GL_FLOAT,filtermode, wrappingmode);
 }
 
 } // namespace openspace
diff --git a/modules/volume/rendering/renderablevolume.h b/modules/volume/rendering/renderablevolume.h
index bab2ad8de2..1b82fa25a5 100644
--- a/modules/volume/rendering/renderablevolume.h
+++ b/modules/volume/rendering/renderablevolume.h
@@ -33,21 +33,21 @@
 
 // Forward declare to minimize dependencies
 namespace ghoul {
-	namespace filesystem {
-		class File;
-	}
-	namespace opengl {
-		class Texture;
-	}
+    namespace filesystem {
+        class File;
+    }
+    namespace opengl {
+        class Texture;
+    }
 }
 
 namespace openspace {
 
 class RenderableVolume: public Renderable {
 public:
-	// constructors & destructor
-	RenderableVolume(const ghoul::Dictionary& dictionary);
-	~RenderableVolume();
+    // constructors & destructor
+    RenderableVolume(const ghoul::Dictionary& dictionary);
+    ~RenderableVolume();
     
 protected:
     ghoul::opengl::Texture* loadVolume(const std::string& filepath, const ghoul::Dictionary& hintsDictionary);
diff --git a/modules/volume/rendering/renderablevolumegl.cpp b/modules/volume/rendering/renderablevolumegl.cpp
index 02017ac9f8..b6e6e22aa9 100644
--- a/modules/volume/rendering/renderablevolumegl.cpp
+++ b/modules/volume/rendering/renderablevolumegl.cpp
@@ -54,109 +54,109 @@ namespace {
 namespace openspace {
 
 RenderableVolumeGL::RenderableVolumeGL(const ghoul::Dictionary& dictionary)
-	: RenderableVolume(dictionary)
-	, _transferFunctionName("")
-	, _volumeName("")
-	, _volume(nullptr)
-	, _transferFunction(nullptr)
+    : RenderableVolume(dictionary)
+    , _transferFunctionName("")
+    , _volumeName("")
+    , _volume(nullptr)
+    , _transferFunction(nullptr)
     , _boxArray(0)
     , _vertexPositionBuffer(0)
-	, _boxProgram(nullptr)
-	, _boxScaling(1.0, 1.0, 1.0)
-	, _w(0.f)
-	, _updateTransferfunction(false)
-	, _id(-1)
+    , _boxProgram(nullptr)
+    , _boxScaling(1.0, 1.0, 1.0)
+    , _w(0.f)
+    , _updateTransferfunction(false)
+    , _id(-1)
 {
-	std::string name;
+    std::string name;
     bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
-	assert(success);
+    assert(success);
     
     _filename = "";
-	success = dictionary.getValue(KeyVolume, _filename);
-	if (!success) {
-		LERROR("Node '" << name << "' did not contain a valid '" <<  KeyVolume << "'");
-		return;
-	}
-	_filename = absPath(_filename);
-	if (_filename == "") {
-		return;
-	}
+    success = dictionary.getValue(KeyVolume, _filename);
+    if (!success) {
+        LERROR("Node '" << name << "' did not contain a valid '" <<  KeyVolume << "'");
+        return;
+    }
+    _filename = absPath(_filename);
+    if (_filename == "") {
+        return;
+    }
 
     LDEBUG("Volume Filename: " << _filename);
 
-	dictionary.getValue(KeyHints, _hintsDictionary);
+    dictionary.getValue(KeyHints, _hintsDictionary);
 
     _transferFunction = nullptr;
     _transferFunctionFile = nullptr;
     _transferFunctionPath = "";
-	success = dictionary.getValue(KeyTransferFunction, _transferFunctionPath);
-	if (!success) {
-		LERROR("Node '" << name << "' did not contain a valid '" <<
-			KeyTransferFunction << "'");
-		return;
-	}
-	_transferFunctionPath = absPath(_transferFunctionPath);
-	_transferFunctionFile = new ghoul::filesystem::File(_transferFunctionPath, true);
+    success = dictionary.getValue(KeyTransferFunction, _transferFunctionPath);
+    if (!success) {
+        LERROR("Node '" << name << "' did not contain a valid '" <<
+            KeyTransferFunction << "'");
+        return;
+    }
+    _transferFunctionPath = absPath(_transferFunctionPath);
+    _transferFunctionFile = new ghoul::filesystem::File(_transferFunctionPath, true);
     
-	_samplerFilename = "";
-	success = dictionary.getValue(KeySampler, _samplerFilename);
-	if (!success) {
-		LERROR("Node '" << name << "' did not contain a valid '" << KeySampler << "'");
-		return;
-	}
+    _samplerFilename = "";
+    success = dictionary.getValue(KeySampler, _samplerFilename);
+    if (!success) {
+        LERROR("Node '" << name << "' did not contain a valid '" << KeySampler << "'");
+        return;
+    }
     _samplerFilename = absPath(_samplerFilename);
 
-	KameleonWrapper kw(_filename);
-	auto t = kw.getGridUnits();
-	if (dictionary.hasKey(KeyBoxScaling)) {
-		glm::vec4 scalingVec4(_boxScaling, _w);
-		success = dictionary.getValue(KeyBoxScaling, scalingVec4);
-		if (success) {
-			_boxScaling = scalingVec4.xyz();
-			_w = scalingVec4.w;
-		}
-		else {
-			success = dictionary.getValue(KeyBoxScaling, _boxScaling);
-			if (!success) {
-				LERROR("Node '" << name << "' did not contain a valid '" <<
-					KeyBoxScaling << "'");
-				return;
-			}
-		}
-	}
-	else {
-		// Automatic scale detection from model
-		_boxScaling = kw.getModelScale();
-		if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
-			// Earth radius
-			_boxScaling.x *= 6.371f;
-			_boxScaling.y *= 6.371f;
-			_boxScaling.z *= 6.371f;
-			_w = 6;
-		}
-		else if (std::get<0>(t) == "m" && std::get<1>(t) == "radian" && std::get<2>(t) == "radian") {
-			// For spherical coordinate systems the radius is in meter
-			_w = -log10(1.0f/kw.getGridMax().x);
-		}
-		else {
-			LWARNING("Unsupported units for automatic scale detection");
-		}
-	}
+    KameleonWrapper kw(_filename);
+    auto t = kw.getGridUnits();
+    if (dictionary.hasKey(KeyBoxScaling)) {
+        glm::vec4 scalingVec4(_boxScaling, _w);
+        success = dictionary.getValue(KeyBoxScaling, scalingVec4);
+        if (success) {
+            _boxScaling = scalingVec4.xyz();
+            _w = scalingVec4.w;
+        }
+        else {
+            success = dictionary.getValue(KeyBoxScaling, _boxScaling);
+            if (!success) {
+                LERROR("Node '" << name << "' did not contain a valid '" <<
+                    KeyBoxScaling << "'");
+                return;
+            }
+        }
+    }
+    else {
+        // Automatic scale detection from model
+        _boxScaling = kw.getModelScale();
+        if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
+            // Earth radius
+            _boxScaling.x *= 6.371f;
+            _boxScaling.y *= 6.371f;
+            _boxScaling.z *= 6.371f;
+            _w = 6;
+        }
+        else if (std::get<0>(t) == "m" && std::get<1>(t) == "radian" && std::get<2>(t) == "radian") {
+            // For spherical coordinate systems the radius is in meter
+            _w = -log10(1.0f/kw.getGridMax().x);
+        }
+        else {
+            LWARNING("Unsupported units for automatic scale detection");
+        }
+    }
 
-	_pscOffset = kw.getModelBarycenterOffset();
-	if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
-		// Earth radius
-		_pscOffset[0] *= 6.371f;
-		_pscOffset[1] *= 6.371f;
-		_pscOffset[2] *= 6.371f;
-		_pscOffset[3] = 6;
-	}
-	else {
-		// Current spherical models no need for offset
-	}
-	
-	dictionary.getValue(KeyVolumeName, _volumeName);
-	dictionary.getValue(KeyTransferFunctionName, _transferFunctionName);
+    _pscOffset = kw.getModelBarycenterOffset();
+    if (std::get<0>(t) == "R" && std::get<1>(t) == "R" && std::get<2>(t) == "R") {
+        // Earth radius
+        _pscOffset[0] *= 6.371f;
+        _pscOffset[1] *= 6.371f;
+        _pscOffset[2] *= 6.371f;
+        _pscOffset[3] = 6;
+    }
+    else {
+        // Current spherical models no need for offset
+    }
+    
+    dictionary.getValue(KeyVolumeName, _volumeName);
+    dictionary.getValue(KeyTransferFunctionName, _transferFunctionName);
 
     setBoundingSphere(PowerScaledScalar::CreatePSS(glm::length(_boxScaling)*pow(10,_w)));
 }
@@ -165,15 +165,15 @@ RenderableVolumeGL::~RenderableVolumeGL() {
 }
 
 bool RenderableVolumeGL::isReady() const {
-	bool ready = true;
-	ready &= (_boxProgram != nullptr);
-	ready &= (_volume != nullptr);
-	ready &= (_transferFunction != nullptr);
-	return ready; 
+    bool ready = true;
+    ready &= (_boxProgram != nullptr);
+    ready &= (_volume != nullptr);
+    ready &= (_transferFunction != nullptr);
+    return ready; 
 }
 
 bool RenderableVolumeGL::initialize() {
-	// @TODO fix volume and transferfunction names --jonasstrandstedt
+    // @TODO fix volume and transferfunction names --jonasstrandstedt
     if(_filename != "") {
         _volume = loadVolume(_filename, _hintsDictionary);
         _volume->uploadTexture();
@@ -247,8 +247,8 @@ bool RenderableVolumeGL::initialize() {
 
     glGenVertexArrays(1, &_boxArray); // generate array
     glBindVertexArray(_boxArray); // bind array
-	glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
-	glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer); // bind buffer
+    glGenBuffers(1, &_vertexPositionBuffer); // generate buffer
+    glBindBuffer(GL_ARRAY_BUFFER, _vertexPositionBuffer); // bind buffer
     glBufferData(GL_ARRAY_BUFFER, sizeof(vertex_data), vertex_data, GL_STATIC_DRAW);
     glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, reinterpret_cast<void*>(0));
     glEnableVertexAttribArray(0);
@@ -257,20 +257,20 @@ bool RenderableVolumeGL::initialize() {
 }
 
 bool RenderableVolumeGL::deinitialize() {
-	if (_volume)
-		delete _volume;
-	if (_transferFunctionFile)
-		delete _transferFunctionFile;
-	if (_transferFunction)
-		delete _transferFunction;
-	_volume = nullptr;
-	_transferFunctionFile = nullptr;
-	_transferFunction = nullptr;
+    if (_volume)
+        delete _volume;
+    if (_transferFunctionFile)
+        delete _transferFunctionFile;
+    if (_transferFunction)
+        delete _transferFunction;
+    _volume = nullptr;
+    _transferFunctionFile = nullptr;
+    _transferFunction = nullptr;
 
-	glDeleteVertexArrays(1, &_boxArray);
-	glGenBuffers(1, &_vertexPositionBuffer);
+    glDeleteVertexArrays(1, &_boxArray);
+    glGenBuffers(1, &_vertexPositionBuffer);
     
-	return true;
+    return true;
 }
 
 void RenderableVolumeGL::render(const RenderData& data) {
@@ -294,13 +294,13 @@ void RenderableVolumeGL::render(const RenderData& data) {
 
     // fetch data
     psc currentPosition         = data.position;
-	currentPosition += _pscOffset; // Move box to model barycenter
+    currentPosition += _pscOffset; // Move box to model barycenter
 
     _boxProgram->activate();
-	_boxProgram->setUniform("volumeType", _id);
-	_boxProgram->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
-	_boxProgram->setUniform("modelTransform", transform);
-	setPscUniforms(_boxProgram, &data.camera, currentPosition);
+    _boxProgram->setUniform("volumeType", _id);
+    _boxProgram->setUniform("modelViewProjection", data.camera.viewProjectionMatrix());
+    _boxProgram->setUniform("modelTransform", transform);
+    setPscUniforms(_boxProgram, &data.camera, currentPosition);
 
     // make sure GL_CULL_FACE is enabled (it should be)
     glEnable(GL_CULL_FACE);
diff --git a/modules/volume/rendering/renderablevolumegl.h b/modules/volume/rendering/renderablevolumegl.h
index 166bb26d4d..c3d484edad 100644
--- a/modules/volume/rendering/renderablevolumegl.h
+++ b/modules/volume/rendering/renderablevolumegl.h
@@ -30,52 +30,52 @@
 
 // Forward declare to minimize dependencies
 namespace ghoul {
-	namespace filesystem {
-		class File;
-	}
-	namespace opengl {
-		class ProgramObject;
-		class Texture;
-	}
+    namespace filesystem {
+        class File;
+    }
+    namespace opengl {
+        class ProgramObject;
+        class Texture;
+    }
 }
 
 namespace openspace {
 
 class RenderableVolumeGL: public RenderableVolume {
 public:
-	RenderableVolumeGL(const ghoul::Dictionary& dictionary);
-	~RenderableVolumeGL();
+    RenderableVolumeGL(const ghoul::Dictionary& dictionary);
+    ~RenderableVolumeGL();
     
-	bool initialize() override;
+    bool initialize() override;
     bool deinitialize() override;
 
-	bool isReady() const override;
+    bool isReady() const override;
 
-	virtual void render(const RenderData& data) override;
-	virtual void update(const UpdateData& data) override;
+    virtual void render(const RenderData& data) override;
+    virtual void update(const UpdateData& data) override;
 
 private:
-	ghoul::Dictionary _hintsDictionary;
+    ghoul::Dictionary _hintsDictionary;
 
     std::string _filename;
 
     std::string _transferFunctionName;
-	std::string _volumeName;
+    std::string _volumeName;
 
     std::string _transferFunctionPath;
-	std::string _samplerFilename;
+    std::string _samplerFilename;
     
     ghoul::filesystem::File* _transferFunctionFile;
 
-	ghoul::opengl::Texture* _volume;
-	ghoul::opengl::Texture* _transferFunction;
+    ghoul::opengl::Texture* _volume;
+    ghoul::opengl::Texture* _transferFunction;
 
-	GLuint _boxArray; 
-	GLuint _vertexPositionBuffer;
-	ghoul::opengl::ProgramObject* _boxProgram;
-	glm::vec3 _boxScaling;
-	psc _pscOffset;
-	float _w;
+    GLuint _boxArray; 
+    GLuint _vertexPositionBuffer;
+    ghoul::opengl::ProgramObject* _boxProgram;
+    glm::vec3 _boxScaling;
+    psc _pscOffset;
+    float _w;
     
     bool _updateTransferfunction;
     int _id;
diff --git a/shaders/PowerScaling/powerScalingMath.hglsl b/shaders/PowerScaling/powerScalingMath.hglsl
index 2fb96797f9..b14e15db60 100644
--- a/shaders/PowerScaling/powerScalingMath.hglsl
+++ b/shaders/PowerScaling/powerScalingMath.hglsl
@@ -30,26 +30,26 @@ const float k = 10.0;
 const float FLT_MAX = 1e38; // Not max but large enough for the purpose
 
 float log10(float x) {  
-	return log(x) / log(10);   
+    return log(x) / log(10);   
 }
 
 vec4 psc_normalization(vec4 v) {
-	vec4 v2 = v;
-	float l = length(v.xyz);
-	v2.xyz = v.xyz / l;
-	v2.w = v.w - log10(1.0/l);
-	return v2;
+    vec4 v2 = v;
+    float l = length(v.xyz);
+    v2.xyz = v.xyz / l;
+    v2.w = v.w - log10(1.0/l);
+    return v2;
 }
 
 vec4 psc_addition(vec4 v1, vec4 v2) {
-	float ds = v2.w - v1.w;
-	if(ds >= 0) {
-		float p = pow(k,-ds);
-		return vec4(v1.x*p + v2.x, v1.y*p + v2.y, v1.z*p + v2.z, v2.w);
-	} else {
-		float p = pow(k,ds);
-		return vec4(v1.x + v2.x*p, v1.y + v2.y*p, v1.z + v2.z*p, v1.w);
-	}
+    float ds = v2.w - v1.w;
+    if(ds >= 0) {
+        float p = pow(k,-ds);
+        return vec4(v1.x*p + v2.x, v1.y*p + v2.y, v1.z*p + v2.z, v2.w);
+    } else {
+        float p = pow(k,ds);
+        return vec4(v1.x + v2.x*p, v1.y + v2.y*p, v1.z + v2.z*p, v1.w);
+    }
 }
 
 vec4 psc_subtraction(vec4 v1, vec4 v2) {
@@ -58,14 +58,14 @@ vec4 psc_subtraction(vec4 v1, vec4 v2) {
 }
 
 vec2 psc_addition(vec2 v1, vec2 v2) {
-	float ds = v2.y - v1.y;
-	if(ds >= 0) {
-		float p = pow(k,-ds);
-		return vec2(v1.x*p + v2.x, v2.y);
-	} else {
-		float p = pow(k,ds);
-		return vec2(v1.x + v2.x*p, v1.y);
-	}
+    float ds = v2.y - v1.y;
+    if(ds >= 0) {
+        float p = pow(k,-ds);
+        return vec2(v1.x*p + v2.x, v2.y);
+    } else {
+        float p = pow(k,ds);
+        return vec2(v1.x + v2.x*p, v1.y);
+    }
 }
 
 vec2 psc_subtraction(vec2 v1, vec2 v2) {
@@ -75,17 +75,17 @@ vec2 psc_subtraction(vec2 v1, vec2 v2) {
 
 
 vec4 z_normalization(vec4 v_in) {
-	vec4 v_out = v_in;
-	if(v_out.z > 0.0) {
-		v_out.z = 1;
-	} else if(v_out.z < 0.0) {
-		v_out.z = 1;
-	} else {
-		float tmp = max(max(abs(v_out.x), abs(v_out.y)),0);
-		if(tmp == 0.0)
-			v_out.s = FLT_MAX;
-	}
-	return v_out;
+    vec4 v_out = v_in;
+    if(v_out.z > 0.0) {
+        v_out.z = 1;
+    } else if(v_out.z < 0.0) {
+        v_out.z = 1;
+    } else {
+        float tmp = max(max(abs(v_out.x), abs(v_out.y)),0);
+        if(tmp == 0.0)
+            v_out.s = FLT_MAX;
+    }
+    return v_out;
 }
 
 /**
diff --git a/shaders/PowerScaling/powerScaling_fs.hglsl b/shaders/PowerScaling/powerScaling_fs.hglsl
index 7aec0d5398..855c98707a 100644
--- a/shaders/PowerScaling/powerScaling_fs.hglsl
+++ b/shaders/PowerScaling/powerScaling_fs.hglsl
@@ -29,22 +29,22 @@
 
 #include "powerScalingMath.hglsl"
 
-const float s_far			= 27.0f; //= gl_DepthRange.far;	// 40
-const float s_farcutoff		= 12.0f;
-const float s_nearcutoff	= 7.00f;
-const float s_near			= 1.00f;// gl_DepthRange.near;	// 0.1
+const float s_far            = 27.0f; //= gl_DepthRange.far;    // 40
+const float s_farcutoff        = 12.0f;
+const float s_nearcutoff    = 7.00f;
+const float s_near            = 1.00f;// gl_DepthRange.near;    // 0.1
 
 vec4 psc_normlization(vec4 invec) {
-	
-	float xymax = max(invec.x,invec.y);
+    
+    float xymax = max(invec.x,invec.y);
 
-	if(invec.z > 0.0f || invec.z < 0.0f) {
-		return invec / abs(invec.z);
-	} else if (xymax != 0.0f) {
-		return invec / xymax;
-	} else {
-		return invec / -.0;
-	}
+    if(invec.z > 0.0f || invec.z < 0.0f) {
+        return invec / abs(invec.z);
+    } else if (xymax != 0.0f) {
+        return invec / xymax;
+    } else {
+        return invec / -.0;
+    }
 }
 
 
diff --git a/shaders/PowerScaling/powerScaling_vs.hglsl b/shaders/PowerScaling/powerScaling_vs.hglsl
index ce8d936289..a32a4df334 100644
--- a/shaders/PowerScaling/powerScaling_vs.hglsl
+++ b/shaders/PowerScaling/powerScaling_vs.hglsl
@@ -33,49 +33,49 @@ uniform vec4 objpos;
 #include "powerScalingMath.hglsl"
 
 vec4 psc_to_meter(vec4 v1, vec2 v2) {
-	float factor = v2.x * pow(k,v2.y + v1.w);
-	return vec4(v1.xyz * factor, 1.0);
+    float factor = v2.x * pow(k,v2.y + v1.w);
+    return vec4(v1.xyz * factor, 1.0);
 }
 
 vec4 psc_scaling(vec4 v1, vec2 v2) {
-	float ds = v2.y - v1.w;
-	if(ds >= 0) {
-		return vec4(v1.xyz * v2.x * pow(k,v1.w), v2.y);
-	} else {
-		return vec4(v1.xyz * v2.x * pow(k,v2.y), v1.w);
-	}
+    float ds = v2.y - v1.w;
+    if(ds >= 0) {
+        return vec4(v1.xyz * v2.x * pow(k,v1.w), v2.y);
+    } else {
+        return vec4(v1.xyz * v2.x * pow(k,v2.y), v1.w);
+    }
 }
 
 vec4 pscTransform(inout vec4 vertexPosition, mat4 modelTransform) {
-	vec3 local_vertex_pos = mat3(modelTransform) * vertexPosition.xyz;
-	//vec4 lvp = ModelTransform * vertexPosition;
-	
-	// PSC addition; local vertex position and the object power scaled world position
-	vertexPosition = psc_addition(vec4(local_vertex_pos,vertexPosition.w),objpos);
-	//position = psc_addition(lvp,objpos);
-	
-	// PSC addition; rotated and viewscaled vertex and the cmaeras negative position
-	vertexPosition = psc_addition(vertexPosition,vec4(-campos.xyz,campos.w));
-	
-	// rotate the camera
-	vertexPosition.xyz =  mat3(camrot) * vertexPosition.xyz;
-	vec4 tmp = vertexPosition;
-	vertexPosition = psc_scaling(vertexPosition, scaling);
-	//position = vec4(local_vertex_pos, position.w);
-	//position =  camrot* position;
+    vec3 local_vertex_pos = mat3(modelTransform) * vertexPosition.xyz;
+    //vec4 lvp = ModelTransform * vertexPosition;
+    
+    // PSC addition; local vertex position and the object power scaled world position
+    vertexPosition = psc_addition(vec4(local_vertex_pos,vertexPosition.w),objpos);
+    //position = psc_addition(lvp,objpos);
+    
+    // PSC addition; rotated and viewscaled vertex and the cmaeras negative position
+    vertexPosition = psc_addition(vertexPosition,vec4(-campos.xyz,campos.w));
+    
+    // rotate the camera
+    vertexPosition.xyz =  mat3(camrot) * vertexPosition.xyz;
+    vec4 tmp = vertexPosition;
+    vertexPosition = psc_scaling(vertexPosition, scaling);
+    //position = vec4(local_vertex_pos, position.w);
+    //position =  camrot* position;
 
-	// rescales the scene to fit inside the view frustum
-	// is set from the main program, but these are decent values
-	// scaling = vec2(1.0, -8.0);
+    // rescales the scene to fit inside the view frustum
+    // is set from the main program, but these are decent values
+    // scaling = vec2(1.0, -8.0);
 
-	// project using the rescaled coordinates,
-	//vec4 vs_position_rescaled = psc_scaling(position, scaling);
-	tmp = psc_to_meter(tmp, scaling);
-	
-	// tmp.z *= 2.0;
+    // project using the rescaled coordinates,
+    //vec4 vs_position_rescaled = psc_scaling(position, scaling);
+    tmp = psc_to_meter(tmp, scaling);
+    
+    // tmp.z *= 2.0;
 
-	// return vertexPosition;
-	return tmp;
+    // return vertexPosition;
+    return tmp;
 }
 
 #endif
\ No newline at end of file
diff --git a/shaders/abuffer/abufferfragment.glsl b/shaders/abuffer/abufferfragment.glsl
index e986da537e..be93e3d78c 100644
--- a/shaders/abuffer/abufferfragment.glsl
+++ b/shaders/abuffer/abufferfragment.glsl
@@ -76,11 +76,11 @@ const uint mask_next   = mask_28;
 const uint shift_next  = 0;
 
 void bitinsert(inout uint pack, uint val, uint mask, uint shift) {
-	pack &= ~mask;
-	pack |= (val << shift) & mask;
+    pack &= ~mask;
+    pack |= (val << shift) & mask;
 }
 uint bitextract(in uint pack, uint mask, uint shift) {
-	return (pack >> shift) & (mask >> shift);
+    return (pack >> shift) & (mask >> shift);
 }
 
 /**
diff --git a/shaders/abuffer/renderabuffer.vert b/shaders/abuffer/renderabuffer.vert
index d691d5208d..d069c8affe 100644
--- a/shaders/abuffer/renderabuffer.vert
+++ b/shaders/abuffer/renderabuffer.vert
@@ -28,6 +28,6 @@ in vec4 position;
 out vec2 texCoord;
 
 void main() {
-	gl_Position = position;
-	texCoord = 0.5 + position.xy / 2.0;
+    gl_Position = position;
+    texCoord = 0.5 + position.xy / 2.0;
 }
diff --git a/shaders/abuffer/resolveabuffer.vert b/shaders/abuffer/resolveabuffer.vert
index d691d5208d..d069c8affe 100644
--- a/shaders/abuffer/resolveabuffer.vert
+++ b/shaders/abuffer/resolveabuffer.vert
@@ -28,6 +28,6 @@ in vec4 position;
 out vec2 texCoord;
 
 void main() {
-	gl_Position = position;
-	texCoord = 0.5 + position.xy / 2.0;
+    gl_Position = position;
+    texCoord = 0.5 + position.xy / 2.0;
 }
diff --git a/shaders/exitpoints.frag b/shaders/exitpoints.frag
index ac8f780f5f..938df00ca5 100644
--- a/shaders/exitpoints.frag
+++ b/shaders/exitpoints.frag
@@ -35,16 +35,16 @@ in float s;
 #include "PowerScaling/powerScaling_fs.hglsl"
  
 void main() {
-	vec4 fragColor = vec4(vPosition+0.5, 1.0);
-	vec4 position = worldPosition;
-	float depth = pscDepth(position);
+    vec4 fragColor = vec4(vPosition+0.5, 1.0);
+    vec4 position = worldPosition;
+    float depth = pscDepth(position);
 
-	gl_FragDepth = depth;
+    gl_FragDepth = depth;
 
-	ABufferStruct_t frag;
-	_col_(frag, fragColor);
-	_z_(frag, depth);
-	_type_(frag, volumeType);
-	_pos_(frag, position);
-	addToBuffer(frag);
+    ABufferStruct_t frag;
+    _col_(frag, fragColor);
+    _z_(frag, depth);
+    _type_(frag, volumeType);
+    _pos_(frag, position);
+    addToBuffer(frag);
 }
\ No newline at end of file
diff --git a/shaders/exitpoints.vert b/shaders/exitpoints.vert
index 1d63c3d2c5..1abe4bf478 100644
--- a/shaders/exitpoints.vert
+++ b/shaders/exitpoints.vert
@@ -37,21 +37,21 @@ out float s;
 
 void main() {
 
-	//vs_st = in_st;
-	//vs_stp = in_position.xyz;
+    //vs_st = in_st;
+    //vs_stp = in_position.xyz;
 
-	vPosition = vertPosition.xyz;
-	worldPosition = vertPosition;
+    vPosition = vertPosition.xyz;
+    worldPosition = vertPosition;
 
-	// this is wrong for the normal. The normal transform is the transposed inverse of the model transform
-	//vs_normal = normalize(modelTransform * vec4(in_normal,0));
-	
-	vec4 position = pscTransform(worldPosition, modelTransform);
+    // this is wrong for the normal. The normal transform is the transposed inverse of the model transform
+    //vs_normal = normalize(modelTransform * vec4(in_normal,0));
+    
+    vec4 position = pscTransform(worldPosition, modelTransform);
 
-	// project the position to view space
-	gl_Position =  z_normalization(modelViewProjection * position);
+    // project the position to view space
+    gl_Position =  z_normalization(modelViewProjection * position);
 
-	// vPosition = vertPosition.xyz;
-	// worldPosition = (modelTransform *vec4(vPosition, 1.0)).xyz;
-	// gl_Position = modelViewProjection  *vec4(worldPosition, 1.0);
+    // vPosition = vertPosition.xyz;
+    // worldPosition = (modelTransform *vec4(vPosition, 1.0)).xyz;
+    // gl_Position = modelViewProjection  *vec4(worldPosition, 1.0);
 }
\ No newline at end of file
diff --git a/shaders/fboPass_fs.glsl b/shaders/fboPass_fs.glsl
index 5c7ea014ab..96f424130b 100644
--- a/shaders/fboPass_fs.glsl
+++ b/shaders/fboPass_fs.glsl
@@ -42,23 +42,23 @@ out vec4 color;
 #define M_PI 3.14159265358979323846
 
 vec4 uvToModel( float u, float v, vec4 radius, float segments){
-	float fj = u * segments;
-	float fi = v * segments;
+    float fj = u * segments;
+    float fi = v * segments;
 
-	float theta = fi * float(M_PI) / segments;  // 0 -> PI
-	float phi   = fj * float(M_PI) * 2.0f / segments;
+    float theta = fi * float(M_PI) / segments;  // 0 -> PI
+    float phi   = fj * float(M_PI) * 2.0f / segments;
 
-	float x = radius[0] * sin(phi) * sin(theta);  //
-	float y = radius[1] * cos(theta);             // up
-	float z = radius[2] * cos(phi) * sin(theta);  //
+    float x = radius[0] * sin(phi) * sin(theta);  //
+    float y = radius[1] * cos(theta);             // up
+    float z = radius[2] * cos(phi) * sin(theta);  //
 
-	return vec4(x, y, z, radius[3]);
+    return vec4(x, y, z, radius[3]);
 }
 
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 bool inRange(float x, float a, float b){
-	return (x >= a && x <= b);
+    return (x >= a && x <= b);
 } 
 
 void main() {
@@ -68,7 +68,7 @@ void main() {
   
   vec4 raw_pos   = psc_to_meter(vertex, _scaling);
   vec4 projected = ProjectorMatrix * ModelTransform * raw_pos;
-	
+    
   projected.x /= projected.w;
   projected.y /= projected.w;
   
@@ -78,11 +78,11 @@ void main() {
   
   if((inRange(projected.x, 0, 1) &&  
       inRange(projected.y, 0, 1)) &&
-	  dot(v_b, normal) < 0 ) {
-		color = texture(texture1, projected.xy);
+      dot(v_b, normal) < 0 ) {
+        color = texture(texture1, projected.xy);
   }else{
- 	 color = texture(texture2, uv);
-	 color.a = projectionFading;
+      color = texture(texture2, uv);
+     color.a = projectionFading;
   }
   
   // color.a  = 0.1f;//1.f - abs(uv.x - 0.55) / (0.6 - 0.5); // blending
diff --git a/shaders/fboPass_vs.glsl b/shaders/fboPass_vs.glsl
index be897a61d7..b9db5043ae 100644
--- a/shaders/fboPass_vs.glsl
+++ b/shaders/fboPass_vs.glsl
@@ -39,8 +39,8 @@ flat out uint vs_segments;
 #include "PowerScaling/powerScaling_vs.hglsl"
 
 void main() {
-	vs_position  = in_position;
-	vs_segments  = segments;
-	gl_Position  = vec4(in_position.xy, 0.0, 1.0);
+    vs_position  = in_position;
+    vs_segments  = segments;
+    gl_Position  = vec4(in_position.xy, 0.0, 1.0);
 
 }
diff --git a/shaders/framebuffer/resolveframebuffer.vert b/shaders/framebuffer/resolveframebuffer.vert
index d691d5208d..d069c8affe 100644
--- a/shaders/framebuffer/resolveframebuffer.vert
+++ b/shaders/framebuffer/resolveframebuffer.vert
@@ -28,6 +28,6 @@ in vec4 position;
 out vec2 texCoord;
 
 void main() {
-	gl_Position = position;
-	texCoord = 0.5 + position.xy / 2.0;
+    gl_Position = position;
+    texCoord = 0.5 + position.xy / 2.0;
 }
diff --git a/shaders/nighttexture_fs.glsl b/shaders/nighttexture_fs.glsl
index d61c0e0f38..588f4bf581 100644
--- a/shaders/nighttexture_fs.glsl
+++ b/shaders/nighttexture_fs.glsl
@@ -44,39 +44,39 @@ in vec4 vs_position;
 #include "fragment.glsl"
 
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse = texture(texture1, vs_st);
-	vec4 diffuse2 = texture(nightTex, vs_st);
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse = texture(texture1, vs_st);
+    vec4 diffuse2 = texture(nightTex, vs_st);
 
-	Fragment frag;
-	if (_performShading) {
-		// directional lighting
-		vec3 origin = vec3(0.0);
-		vec4 spec = vec4(0.0);
-		
-		vec3 n = normalize(vs_normal.xyz);
-		//vec3 e = normalize(camdir);
-		vec3 l_pos = vec3(sun_pos); // sun.
-		vec3 l_dir = normalize(l_pos-objpos.xyz);
-		float intensity = min(max(5*dot(n,l_dir), 0.0), 1);
-		float darkSide  = min(max(5*dot(n,-l_dir), 0.0), 1);
-		
-		float shine = 0.0001;
+    Fragment frag;
+    if (_performShading) {
+        // directional lighting
+        vec3 origin = vec3(0.0);
+        vec4 spec = vec4(0.0);
+        
+        vec3 n = normalize(vs_normal.xyz);
+        //vec3 e = normalize(camdir);
+        vec3 l_pos = vec3(sun_pos); // sun.
+        vec3 l_dir = normalize(l_pos-objpos.xyz);
+        float intensity = min(max(5*dot(n,l_dir), 0.0), 1);
+        float darkSide  = min(max(5*dot(n,-l_dir), 0.0), 1);
+        
+        float shine = 0.0001;
 
-		vec4 specular = vec4(0.5);
-		vec4 ambient = vec4(0.0,0.0,0.0,transparency);
-		
-		vec4 daytex = max(intensity * diffuse, ambient);
-		vec4 mixtex = mix(diffuse, diffuse2,  (1+dot(n,-l_dir))/2);	
-		
-		diffuse = (daytex*2 + mixtex)/3;
-	}
+        vec4 specular = vec4(0.5);
+        vec4 ambient = vec4(0.0,0.0,0.0,transparency);
+        
+        vec4 daytex = max(intensity * diffuse, ambient);
+        vec4 mixtex = mix(diffuse, diffuse2,  (1+dot(n,-l_dir))/2);    
+        
+        diffuse = (daytex*2 + mixtex)/3;
+    }
 
-	diffuse[3] = transparency;
-	frag.color = diffuse;
-	frag.depth = depth;
+    diffuse[3] = transparency;
+    frag.color = diffuse;
+    frag.depth = depth;
 
-	return frag;
+    return frag;
 }
 
diff --git a/shaders/nighttexture_vs.glsl b/shaders/nighttexture_vs.glsl
index cb945fa133..a03d356322 100644
--- a/shaders/nighttexture_vs.glsl
+++ b/shaders/nighttexture_vs.glsl
@@ -42,16 +42,16 @@ out float s;
 
 void main()
 {
-	// set variables
-	vs_st = in_st;
-	vs_position = in_position;
-	vec4 tmp = in_position;
+    // set variables
+    vs_st = in_st;
+    vs_position = in_position;
+    vec4 tmp = in_position;
 
-	// this is wrong for the normal. The normal transform is the transposed inverse of the model transform
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    // this is wrong for the normal. The normal transform is the transposed inverse of the model transform
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/shaders/pointcloud_fs.glsl b/shaders/pointcloud_fs.glsl
index e58f685e8d..7e4028f34f 100644
--- a/shaders/pointcloud_fs.glsl
+++ b/shaders/pointcloud_fs.glsl
@@ -30,5 +30,5 @@ out vec4 diffuse;
 
 void main()
 {
-	diffuse = vs_color;
+    diffuse = vs_color;
 }
\ No newline at end of file
diff --git a/shaders/pointcloud_vs.glsl b/shaders/pointcloud_vs.glsl
index 58d7bb895e..eaad8b33f9 100644
--- a/shaders/pointcloud_vs.glsl
+++ b/shaders/pointcloud_vs.glsl
@@ -34,8 +34,8 @@ out vec4 vs_color;
 
 void main()
 {
-	// set variables
-	vs_color = in_color;
+    // set variables
+    vs_color = in_color;
 
-	gl_Position =  ViewProjection*ModelTransform*vec4(in_position,1);
+    gl_Position =  ViewProjection*ModelTransform*vec4(in_position,1);
 }
\ No newline at end of file
diff --git a/shaders/postFX_fs.glsl b/shaders/postFX_fs.glsl
index a9cf57c44b..4a2dbe46ba 100644
--- a/shaders/postFX_fs.glsl
+++ b/shaders/postFX_fs.glsl
@@ -32,5 +32,5 @@ uniform float Opacity;
 
 void main()
 {
-	Color = texture(Tex, UV) * Opacity;
+    Color = texture(Tex, UV) * Opacity;
 }
\ No newline at end of file
diff --git a/shaders/pscstandard_fs.glsl b/shaders/pscstandard_fs.glsl
index 786ddedce2..c32305121c 100644
--- a/shaders/pscstandard_fs.glsl
+++ b/shaders/pscstandard_fs.glsl
@@ -44,41 +44,41 @@ in vec4 vs_position;
 
 //#include "PowerScaling/powerScaling_vs.hglsl"
 Fragment getFragment() {
-	vec4 position = vs_position;
-	float depth = pscDepth(position);
-	vec4 diffuse = texture(texture1, vs_st);
+    vec4 position = vs_position;
+    float depth = pscDepth(position);
+    vec4 diffuse = texture(texture1, vs_st);
 
-	Fragment frag;
-	if (_performShading) {
-		// directional lighting
-		vec3 origin = vec3(0.0);
-		vec4 spec = vec4(0.0);
-		
-		vec3 n = normalize(vs_normal.xyz);
-		//vec3 e = normalize(camdir);
-		vec3 l_pos = vec3(sun_pos); // sun.
-		vec3 l_dir = normalize(l_pos-objpos.xyz);
-		float intensity = min(max(5*dot(n,l_dir), 0.0), 1);
-		
-		float shine = 0.0001;
+    Fragment frag;
+    if (_performShading) {
+        // directional lighting
+        vec3 origin = vec3(0.0);
+        vec4 spec = vec4(0.0);
+        
+        vec3 n = normalize(vs_normal.xyz);
+        //vec3 e = normalize(camdir);
+        vec3 l_pos = vec3(sun_pos); // sun.
+        vec3 l_dir = normalize(l_pos-objpos.xyz);
+        float intensity = min(max(5*dot(n,l_dir), 0.0), 1);
+        
+        float shine = 0.0001;
 
-		vec4 specular = vec4(0.5);
-		vec4 ambient = vec4(0.0,0.0,0.0,transparency);
-		/*
-		if(intensity > 0.f){
-			// halfway vector
-			vec3 h = normalize(l_dir + e);
-			// specular factor
-			float intSpec = max(dot(h,n),0.0);
-			spec = specular * pow(intSpec, shine);
-		}
-		*/
-		diffuse = max(intensity * diffuse, ambient);
-	}
+        vec4 specular = vec4(0.5);
+        vec4 ambient = vec4(0.0,0.0,0.0,transparency);
+        /*
+        if(intensity > 0.f){
+            // halfway vector
+            vec3 h = normalize(l_dir + e);
+            // specular factor
+            float intSpec = max(dot(h,n),0.0);
+            spec = specular * pow(intSpec, shine);
+        }
+        */
+        diffuse = max(intensity * diffuse, ambient);
+    }
 
-	diffuse[3] = transparency;
-	frag.color = diffuse;
-	frag.depth = depth;
+    diffuse[3] = transparency;
+    frag.color = diffuse;
+    frag.depth = depth;
 
-	return frag;
+    return frag;
 }
diff --git a/shaders/pscstandard_vs.glsl b/shaders/pscstandard_vs.glsl
index 13f3025471..030d74cc15 100644
--- a/shaders/pscstandard_vs.glsl
+++ b/shaders/pscstandard_vs.glsl
@@ -41,17 +41,17 @@ out float s;
 
 void main()
 {
-	// set variables
-	vs_st = in_st;
-	//vs_stp = in_position.xyz;
-	vs_position = in_position;
-	vec4 tmp = in_position;
+    // set variables
+    vs_st = in_st;
+    //vs_stp = in_position.xyz;
+    vs_position = in_position;
+    vec4 tmp = in_position;
 
-	// this is wrong for the normal. The normal transform is the transposed inverse of the model transform
-	vs_normal = normalize(ModelTransform * vec4(in_normal,0));
-	
-	vec4 position = pscTransform(tmp, ModelTransform);
-	vs_position = tmp;
-	position = ViewProjection * position;
-	gl_Position =  z_normalization(position);
+    // this is wrong for the normal. The normal transform is the transposed inverse of the model transform
+    vs_normal = normalize(ModelTransform * vec4(in_normal,0));
+    
+    vec4 position = pscTransform(tmp, ModelTransform);
+    vs_position = tmp;
+    position = ViewProjection * position;
+    gl_Position =  z_normalization(position);
 }
\ No newline at end of file
diff --git a/shaders/quadVert.glsl b/shaders/quadVert.glsl
index 80652fae25..419392bd62 100644
--- a/shaders/quadVert.glsl
+++ b/shaders/quadVert.glsl
@@ -33,6 +33,6 @@ out vec2 texCoord;
 const vec2 screenScale = vec2(0.5, 0.5);
 
 void main() {
-	texCoord = vertPosition.xy*screenScale+screenScale; // scale vertex attribute to [0-1] range
-	gl_Position = vec4(vertPosition.xy, 0.0, 1.0);
+    texCoord = vertPosition.xy*screenScale+screenScale; // scale vertex attribute to [0-1] range
+    gl_Position = vec4(vertPosition.xy, 0.0, 1.0);
 }
diff --git a/shaders/twopassraycaster.frag b/shaders/twopassraycaster.frag
index 8e5c8c482f..2456c232b3 100644
--- a/shaders/twopassraycaster.frag
+++ b/shaders/twopassraycaster.frag
@@ -33,39 +33,39 @@ in vec2 texCoords;
 out vec4 fragColor;
  
 void main() {
-	vec3 front  = texture(texFront, texCoords).xyz;
-	vec3 back 	= texture(texBack, texCoords).xyz;
-	vec3 direction = back-front;
-	float directionLength = length(direction);
-	direction = normalize(direction);
-	vec3 position = front;
-	vec4 tmp, color = vec4(0);
+    vec3 front  = texture(texFront, texCoords).xyz;
+    vec3 back     = texture(texBack, texCoords).xyz;
+    vec3 direction = back-front;
+    float directionLength = length(direction);
+    direction = normalize(direction);
+    vec3 position = front;
+    vec4 tmp, color = vec4(0);
 
-	while (length(position-front) < directionLength && color.r != 1.0) {
-		tmp = texture(texVolume, position);
-		color = max(color, tmp); // MIP
-		position = position + direction * stepSize;
-	}
+    while (length(position-front) < directionLength && color.r != 1.0) {
+        tmp = texture(texVolume, position);
+        color = max(color, tmp); // MIP
+        position = position + direction * stepSize;
+    }
 
-	fragColor = vec4(color.rrr, 1.0);
-	
-	// // DEBUG DEBUG DEBUG
-	// fragColor = vec4(front, 1.0);
-	// if (front.x < 0.1)
-	//     fragColor = vec4(1.0);
+    fragColor = vec4(color.rrr, 1.0);
+    
+    // // DEBUG DEBUG DEBUG
+    // fragColor = vec4(front, 1.0);
+    // if (front.x < 0.1)
+    //     fragColor = vec4(1.0);
 
-	// if (front.y < 0.1)
-	//     fragColor = vec4(1.0);
+    // if (front.y < 0.1)
+    //     fragColor = vec4(1.0);
 
-	// if (front.x > 0.9)
-	//     fragColor = vec4(1.0);
+    // if (front.x > 0.9)
+    //     fragColor = vec4(1.0);
 
-	// if (front.y > 0.9)
-	//     fragColor = vec4(1.0);
+    // if (front.y > 0.9)
+    //     fragColor = vec4(1.0);
 
-	// if (front.x > 0.45 && front.x < 0.55)
-	//     fragColor = vec4(0.0);
+    // if (front.x > 0.45 && front.x < 0.55)
+    //     fragColor = vec4(0.0);
 
-	// if (front.y > 0.45 && front.y < 0.55)
-	//     fragColor = vec4(0.0);
+    // if (front.y > 0.45 && front.y < 0.55)
+    //     fragColor = vec4(0.0);
 }
\ No newline at end of file
diff --git a/shaders/twopassraycaster.vert b/shaders/twopassraycaster.vert
index 3a33677ff2..01669e0b9c 100644
--- a/shaders/twopassraycaster.vert
+++ b/shaders/twopassraycaster.vert
@@ -34,6 +34,6 @@ out vec2 texCoords;
 const vec2 screenScale = vec2(0.5, 0.5);
 
 void main() {
-	texCoords = vertPosition.xy*screenScale+screenScale; // scale vertex attribute to [0-1] range
-	gl_Position = vec4(vertPosition.xy, 0.0, 1.0);
+    texCoords = vertPosition.xy*screenScale+screenScale; // scale vertex attribute to [0-1] range
+    gl_Position = vec4(vertPosition.xy, 0.0, 1.0);
 }
\ No newline at end of file
diff --git a/src/engine/logfactory.cpp b/src/engine/logfactory.cpp
index 83ebd83bdc..2b5f2cd226 100644
--- a/src/engine/logfactory.cpp
+++ b/src/engine/logfactory.cpp
@@ -31,48 +31,48 @@
 #include <ghoul/logging/textlog.h>
 
 namespace {
-	const std::string keyType = "Type";
-	const std::string keyFilename = "FileName";
-	const std::string keyAppend = "Append";
-	const std::string keyTimeStamping = "TimeStamping";
-	const std::string keyDateStamping = "DateStamping";
-	const std::string keyCategoryStamping = "CategoryStamping";
-	const std::string keyLogLevelStamping = "LogLevelStamping";
+    const std::string keyType = "Type";
+    const std::string keyFilename = "FileName";
+    const std::string keyAppend = "Append";
+    const std::string keyTimeStamping = "TimeStamping";
+    const std::string keyDateStamping = "DateStamping";
+    const std::string keyCategoryStamping = "CategoryStamping";
+    const std::string keyLogLevelStamping = "LogLevelStamping";
 
-	const std::string valueHtmlLog = "HTML";
-	const std::string valueTextLog = "Text";
+    const std::string valueHtmlLog = "HTML";
+    const std::string valueTextLog = "Text";
 }
 
 namespace openspace {
 
 std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictionary) {
-	std::string type;
-	bool typeSuccess = dictionary.getValue(keyType, type);
-	if (!typeSuccess) {
+    std::string type;
+    bool typeSuccess = dictionary.getValue(keyType, type);
+    if (!typeSuccess) {
         throw ghoul::RuntimeError(
             "Requested log did not contain key '" + keyType + "'", "LogFactory"
         );
-	}
+    }
 
-	std::string filename;
-	bool filenameSuccess = dictionary.getValue(keyFilename, filename);
-	if (!filenameSuccess) {
+    std::string filename;
+    bool filenameSuccess = dictionary.getValue(keyFilename, filename);
+    if (!filenameSuccess) {
         throw ghoul::RuntimeError(
             "Requested log did not contain key '" + keyFilename + "'", "LogFactory"
         );
-	}
-	filename = absPath(filename);
+    }
+    filename = absPath(filename);
 
-	bool append = true;
-	dictionary.getValue(keyAppend, append);
-	bool timeStamp = true;
-	dictionary.getValue(keyTimeStamping, timeStamp);
-	bool dateStamp = true;
-	dictionary.getValue(keyDateStamping, dateStamp);
-	bool categoryStamp = true;
-	dictionary.getValue(keyCategoryStamping, categoryStamp);
-	bool logLevelStamp = true;
-	dictionary.getValue(keyLogLevelStamping, logLevelStamp);
+    bool append = true;
+    dictionary.getValue(keyAppend, append);
+    bool timeStamp = true;
+    dictionary.getValue(keyTimeStamping, timeStamp);
+    bool dateStamp = true;
+    dictionary.getValue(keyDateStamping, dateStamp);
+    bool categoryStamp = true;
+    dictionary.getValue(keyCategoryStamping, categoryStamp);
+    bool logLevelStamp = true;
+    dictionary.getValue(keyLogLevelStamping, logLevelStamp);
 
     using Append = ghoul::logging::TextLog::Append;
     using TimeStamping = ghoul::logging::Log::TimeStamping;
@@ -80,31 +80,31 @@ std::unique_ptr<ghoul::logging::Log> createLog(const ghoul::Dictionary& dictiona
     using CategoryStamping = ghoul::logging::Log::CategoryStamping;
     using LogLevelStamping = ghoul::logging::Log::LogLevelStamping;
 
-	if (type == valueHtmlLog) {
+    if (type == valueHtmlLog) {
         return std::make_unique<ghoul::logging::HTMLLog>(
-			filename,
+            filename,
             append ? Append::Yes : Append::No,
             timeStamp ? TimeStamping::Yes : TimeStamping::No,
             dateStamp ? DateStamping::Yes : DateStamping::No,
             categoryStamp ? CategoryStamping::Yes : CategoryStamping::No,
             logLevelStamp ? LogLevelStamping::Yes : LogLevelStamping::No
         );
-	}
-	else if (type == valueTextLog) {
+    }
+    else if (type == valueTextLog) {
         return std::make_unique<ghoul::logging::TextLog>(
-			filename,
+            filename,
             append ? Append::Yes : Append::No,
             timeStamp ? TimeStamping::Yes : TimeStamping::No,
             dateStamp ? DateStamping::Yes : DateStamping::No,
             categoryStamp ? CategoryStamping::Yes : CategoryStamping::No,
             logLevelStamp ? LogLevelStamping::Yes : LogLevelStamping::No
         );
-	}
-	else {
+    }
+    else {
         throw ghoul::RuntimeError(
             "Log with type '" + type + "' did not name a valid log", "LogFactory"
         );
-	}
+    }
 }
     
 } // namespace openspace
diff --git a/src/engine/openspaceengine.cpp b/src/engine/openspaceengine.cpp
index a473c8048d..9d3a6d4df9 100644
--- a/src/engine/openspaceengine.cpp
+++ b/src/engine/openspaceengine.cpp
@@ -640,7 +640,7 @@ void OpenSpaceEngine::preSynchronization() {
 void OpenSpaceEngine::postSynchronizationPreDraw() {
     Time::ref().postSynchronizationPreDraw();
 
-    _scriptEngine->postSynchronizationPreDraw();	
+    _scriptEngine->postSynchronizationPreDraw();    
     _renderEngine->postSynchronizationPreDraw();
     
     if (_isMaster && _gui->isEnabled() && _windowWrapper->isRegularRendering()) {
diff --git a/src/engine/wrapper/windowwrapper.cpp b/src/engine/wrapper/windowwrapper.cpp
index db23097ce0..8283edf577 100644
--- a/src/engine/wrapper/windowwrapper.cpp
+++ b/src/engine/wrapper/windowwrapper.cpp
@@ -61,11 +61,11 @@ glm::ivec2 WindowWrapper::currentWindowResolution() const {
 }
 
 glm::ivec2 WindowWrapper::currentDrawBufferResolution() const {
-	return currentWindowSize();
+    return currentWindowSize();
 }
 
 int WindowWrapper::currentNumberOfAaSamples() const {
-	return 1;
+    return 1;
 }
 
 bool WindowWrapper::isRegularRendering() const {
diff --git a/src/interaction/controller.cpp b/src/interaction/controller.cpp
index 95165fdadd..0b46d4d82f 100644
--- a/src/interaction/controller.cpp
+++ b/src/interaction/controller.cpp
@@ -31,7 +31,7 @@ namespace interaction {
 
 void Controller::setHandler(InteractionHandler* handler)
 {
-	_handler = handler;
+    _handler = handler;
 }
 
 } // namespace interaction
diff --git a/src/interaction/deviceidentifier.cpp b/src/interaction/deviceidentifier.cpp
index a6d16cb42a..def1c670a2 100644
--- a/src/interaction/deviceidentifier.cpp
+++ b/src/interaction/deviceidentifier.cpp
@@ -11,130 +11,130 @@ DeviceIdentifier* DeviceIdentifier::this_ = nullptr;
 
 DeviceIdentifier::DeviceIdentifier() {
 
-	// scan for devices on init
-	devices_ = 0;
-	for(int i = 0; i < MAXDEVICES; ++i) {
-		inputDevice_[i] = InputDevice::NONE;
-	}
+    // scan for devices on init
+    devices_ = 0;
+    for(int i = 0; i < MAXDEVICES; ++i) {
+        inputDevice_[i] = InputDevice::NONE;
+    }
 }
 
 DeviceIdentifier::~DeviceIdentifier() {
 
-	// deallocates memory on exit
-	for(int i = 0; i < MAXDEVICES; ++i) {
-		if(inputDevice_[i] != InputDevice::NONE) {
-			delete axesPos_[i];
-			delete buttons_[i];
-		}
-	}
+    // deallocates memory on exit
+    for(int i = 0; i < MAXDEVICES; ++i) {
+        if(inputDevice_[i] != InputDevice::NONE) {
+            delete axesPos_[i];
+            delete buttons_[i];
+        }
+    }
 }
 
 void DeviceIdentifier::init() {
-	assert( ! this_);
-	this_ = new DeviceIdentifier();
+    assert( ! this_);
+    this_ = new DeviceIdentifier();
 }
 
 void DeviceIdentifier::deinit() {
-	assert(this_);
-	delete this_;
-	this_ = nullptr;
+    assert(this_);
+    delete this_;
+    this_ = nullptr;
 }
 
 DeviceIdentifier& DeviceIdentifier::ref() {
-	assert(this_);
+    assert(this_);
     return *this_;
 }
 
 bool DeviceIdentifier::isInitialized() {
-	return this_ != nullptr;
+    return this_ != nullptr;
 }
 
 void DeviceIdentifier::scanDevices() {
-	assert(this_);
+    assert(this_);
 
-	// sgct/glfw supports 16 joysticks, scans all of them
-	for (int i = 0; i < MAXDEVICES; ++i)
-	{
+    // sgct/glfw supports 16 joysticks, scans all of them
+    for (int i = 0; i < MAXDEVICES; ++i)
+    {
         void* joystickName = NULL;
-		if( joystickName != NULL ) {
+        if( joystickName != NULL ) {
 
-			// allocate 
-			axesPos_[i] = new float[numberOfAxes_[i]];
-			buttons_[i] = new unsigned char[numberOfButtons_[i]];
-			
-			// increment the device count
-			++devices_;
-			
-			// identify what device it is
-			if(numberOfAxes_[i] == 6 && numberOfButtons_[i] == 10) {
-				printf("XBOX controller ");
-				inputDevice_[i] = InputDevice::XBOX;
-			} else if(numberOfAxes_[i] == 6 && numberOfButtons_[i] == 4) {
-				printf("SPACENAVIGATOR ");
-				inputDevice_[i] = InputDevice::SPACENAVIGATOR;
-			} else {
-				printf("UNKNOWN device ");
-				inputDevice_[i] = InputDevice::UNKNOWN;
-			}
-			printf("found at position %i, b=%i, a=%i\n", i, numberOfButtons_[i], numberOfAxes_[i]);
-			
-			
-		} else {
-			inputDevice_[i] = InputDevice::NONE;
-		}
-		
-	}
+            // allocate 
+            axesPos_[i] = new float[numberOfAxes_[i]];
+            buttons_[i] = new unsigned char[numberOfButtons_[i]];
+            
+            // increment the device count
+            ++devices_;
+            
+            // identify what device it is
+            if(numberOfAxes_[i] == 6 && numberOfButtons_[i] == 10) {
+                printf("XBOX controller ");
+                inputDevice_[i] = InputDevice::XBOX;
+            } else if(numberOfAxes_[i] == 6 && numberOfButtons_[i] == 4) {
+                printf("SPACENAVIGATOR ");
+                inputDevice_[i] = InputDevice::SPACENAVIGATOR;
+            } else {
+                printf("UNKNOWN device ");
+                inputDevice_[i] = InputDevice::UNKNOWN;
+            }
+            printf("found at position %i, b=%i, a=%i\n", i, numberOfButtons_[i], numberOfAxes_[i]);
+            
+            
+        } else {
+            inputDevice_[i] = InputDevice::NONE;
+        }
+        
+    }
 }
 
 const int DeviceIdentifier::numberOfDevices() const {
-	assert(this_);
-	return devices_;
+    assert(this_);
+    return devices_;
 }
 
 const InputDevice DeviceIdentifier::type(const int device) const {
-	assert(this_);
-	return inputDevice_[device];
+    assert(this_);
+    return inputDevice_[device];
 }
 
 void DeviceIdentifier::update() {
-	assert(this_);
-	for(int i = 0; i < devices_; ++i) {
-		update(i);
-	}
+    assert(this_);
+    for(int i = 0; i < devices_; ++i) {
+        update(i);
+    }
 }
 
 void DeviceIdentifier::update(const int device) {
-	assert(this_);
-	if(inputDevice_[device] != InputDevice::NONE) {
-	}
+    assert(this_);
+    if(inputDevice_[device] != InputDevice::NONE) {
+    }
 }
 
 const int DeviceIdentifier::getButtons(const int device, unsigned char **buttons) const {
-	assert(this_);
-	if(inputDevice_[device] != InputDevice::NONE) {
-		if(buttons)
-			*buttons = buttons_[device];
-		return numberOfButtons_[device];
-	}
-	return 0;
+    assert(this_);
+    if(inputDevice_[device] != InputDevice::NONE) {
+        if(buttons)
+            *buttons = buttons_[device];
+        return numberOfButtons_[device];
+    }
+    return 0;
 }
 
 const int DeviceIdentifier::getAxes(const int device, float **axespos) const {
-	assert(this_);
-	if(inputDevice_[device] != InputDevice::NONE) {
-		if(axespos)
-			*axespos = axesPos_[device];
-		return numberOfAxes_[device];
-	}
-	return 0;
+    assert(this_);
+    if(inputDevice_[device] != InputDevice::NONE) {
+        if(axespos)
+            *axespos = axesPos_[device];
+        return numberOfAxes_[device];
+    }
+    return 0;
 }
 
 void DeviceIdentifier::get(const int device, unsigned char **buttons, float **axespos) const {
-	assert(this_);
-	if(inputDevice_[device] != InputDevice::NONE) {
-		 *axespos = axesPos_[device];
-		 *buttons = buttons_[device];
-	}
+    assert(this_);
+    if(inputDevice_[device] != InputDevice::NONE) {
+         *axespos = axesPos_[device];
+         *buttons = buttons_[device];
+    }
 }
 
 } // namespace openspace
diff --git a/src/interaction/externalcontrol/externalconnectioncontroller.cpp b/src/interaction/externalcontrol/externalconnectioncontroller.cpp
index 4ea86f2fed..5482c9b3de 100644
--- a/src/interaction/externalcontrol/externalconnectioncontroller.cpp
+++ b/src/interaction/externalcontrol/externalconnectioncontroller.cpp
@@ -1,7 +1,7 @@
 #include <openspace/interaction/externalcontrol/externalconnectioncontroller.h>
 
 namespace openspace {
-	
+    
 ExternalConnectionController::ExternalConnectionController() {
 }
 
diff --git a/src/interaction/externalcontrol/externalcontrol.cpp b/src/interaction/externalcontrol/externalcontrol.cpp
index 9060259c7f..1c279a0dfb 100644
--- a/src/interaction/externalcontrol/externalcontrol.cpp
+++ b/src/interaction/externalcontrol/externalcontrol.cpp
@@ -4,7 +4,7 @@
 #include <cstdio>
 
 namespace openspace {
-	
+    
 ExternalControl::ExternalControl() {
 
 }
@@ -17,15 +17,15 @@ void ExternalControl::update() {
 }
 
 void ExternalControl::rotate(const glm::quat &rotation) {
-	//OsEng.interactionHandler().rotate(rotation);
+    //OsEng.interactionHandler().rotate(rotation);
 }
 
 void ExternalControl::orbit(const glm::quat &rotation) {
-	//OsEng.interactionHandler().orbit(rotation);
+    //OsEng.interactionHandler().orbit(rotation);
 }
 
 void ExternalControl::distance(const PowerScaledScalar &distance) {
-	//OsEng.interactionHandler().distance(distance);
+    //OsEng.interactionHandler().distance(distance);
 }
 
 
diff --git a/src/interaction/externalcontrol/joystickexternalcontrol.cpp b/src/interaction/externalcontrol/joystickexternalcontrol.cpp
index 7f2f543d3b..0e5f4500ca 100644
--- a/src/interaction/externalcontrol/joystickexternalcontrol.cpp
+++ b/src/interaction/externalcontrol/joystickexternalcontrol.cpp
@@ -17,43 +17,43 @@
 //}
 //
 //void JoystickExternalControl::setInputDevice(const int device) {
-//	if(device >= 0 && device <= 16) {
-//		inputDevice_ = device;
-//		numberOfButtons_ = DeviceIdentifier::ref().getButtons(inputDevice_);
-//		numberOfAxes_ = DeviceIdentifier::ref().getAxes(inputDevice_);
-//		clear();
-//		pyarrSize_ = numberOfButtons_ + numberOfAxes_;
-//		pyarr_ = new PyObject*[pyarrSize_];
-//	}
-//	
+//    if(device >= 0 && device <= 16) {
+//        inputDevice_ = device;
+//        numberOfButtons_ = DeviceIdentifier::ref().getButtons(inputDevice_);
+//        numberOfAxes_ = DeviceIdentifier::ref().getAxes(inputDevice_);
+//        clear();
+//        pyarrSize_ = numberOfButtons_ + numberOfAxes_;
+//        pyarr_ = new PyObject*[pyarrSize_];
+//    }
+//    
 //}
 //
 //void JoystickExternalControl::update() {
-//	
-//	if(inputDevice_ != -1) {
-//		float *axesPos;
-//		unsigned char *buttons;
-//		DeviceIdentifier::ref().getButtons(inputDevice_, &buttons);
-//		DeviceIdentifier::ref().getAxes(inputDevice_, &axesPos);
+//    
+//    if(inputDevice_ != -1) {
+//        float *axesPos;
+//        unsigned char *buttons;
+//        DeviceIdentifier::ref().getButtons(inputDevice_, &buttons);
+//        DeviceIdentifier::ref().getAxes(inputDevice_, &axesPos);
 //
-//		// init array
-//		for(int i = 0; i < numberOfButtons_; ++i){
-//			pyarr_[i] = PyLong_FromLong(buttons[i]);
-//		}
-//		for(int i = 0; i < numberOfAxes_; ++i){
-//			pyarr_[i+numberOfButtons_] = PyFloat_FromDouble(axesPos[i]);
-//		}
-//	} 
+//        // init array
+//        for(int i = 0; i < numberOfButtons_; ++i){
+//            pyarr_[i] = PyLong_FromLong(buttons[i]);
+//        }
+//        for(int i = 0; i < numberOfAxes_; ++i){
+//            pyarr_[i+numberOfButtons_] = PyFloat_FromDouble(axesPos[i]);
+//        }
+//    } 
 //
-//	run();
+//    run();
 //
-//	if(inputDevice_ != -1) {
-//		// cleanup
-//		for(int i = 0; i < pyarrSize_; ++i) {
-//			Py_DECREF(pyarr_[i]);
-//		}
-//	}
-//	
+//    if(inputDevice_ != -1) {
+//        // cleanup
+//        for(int i = 0; i < pyarrSize_; ++i) {
+//            Py_DECREF(pyarr_[i]);
+//        }
+//    }
+//    
 //}
 //
 //JoystickExternalControl::~JoystickExternalControl() {
diff --git a/src/interaction/externalcontrol/keyboardexternalcontrol.cpp b/src/interaction/externalcontrol/keyboardexternalcontrol.cpp
index 9715da5326..3b27afc66e 100644
--- a/src/interaction/externalcontrol/keyboardexternalcontrol.cpp
+++ b/src/interaction/externalcontrol/keyboardexternalcontrol.cpp
@@ -14,48 +14,48 @@
 //
 //
 //KeyboardExternalControl::KeyboardExternalControl(const char *filename): PythonExternalControl(filename) {
-//	clear();
-//	pyarrSize_ = 'Z' - 'A' + 80; // all letters, 69 special keys, space and 10 numbers
-//	pyarr_ = new PyObject*[pyarrSize_];
-//	for(int i = 0; i < pyarrSize_; ++i) {
-//		pyarr_[i] = PyLong_FromLong(0);
-//	}
+//    clear();
+//    pyarrSize_ = 'Z' - 'A' + 80; // all letters, 69 special keys, space and 10 numbers
+//    pyarr_ = new PyObject*[pyarrSize_];
+//    for(int i = 0; i < pyarrSize_; ++i) {
+//        pyarr_[i] = PyLong_FromLong(0);
+//    }
 //}
 //
 //void KeyboardExternalControl::keyboardCallback(int key, int action) {
-//	
-//	//printf("key: %i\n",key);
-//	int pos = -1;
-//	if(key >= '0' && key <= '9') {
-//		pos = key - '0';
-//		Py_XDECREF(pyarr_[pos]);
-//		pyarr_[pos] = PyLong_FromLong(action);
-//	} else if(key >= 'A' && key <= 'Z') {
-//		pos = key - 'A' + 10;
-//		Py_XDECREF(pyarr_[pos]);
-//		pyarr_[pos] = PyLong_FromLong(action);
-//	} else if (key > 256 && key < 256+69) {
-//		pos = key - 256 + 'Z'-'A' +10; 
-//		Py_XDECREF(pyarr_[pos]);
-//		pyarr_[pos] = PyLong_FromLong(action);
-//	} else if (key == 32) {
-//		pos = 'Z' - 'A' + 11;
-//		Py_XDECREF(pyarr_[pos]);
-//		pyarr_[pos] = PyLong_FromLong(action);
-//	}
-//	//printf("pos: %i\n",pos);
+//    
+//    //printf("key: %i\n",key);
+//    int pos = -1;
+//    if(key >= '0' && key <= '9') {
+//        pos = key - '0';
+//        Py_XDECREF(pyarr_[pos]);
+//        pyarr_[pos] = PyLong_FromLong(action);
+//    } else if(key >= 'A' && key <= 'Z') {
+//        pos = key - 'A' + 10;
+//        Py_XDECREF(pyarr_[pos]);
+//        pyarr_[pos] = PyLong_FromLong(action);
+//    } else if (key > 256 && key < 256+69) {
+//        pos = key - 256 + 'Z'-'A' +10; 
+//        Py_XDECREF(pyarr_[pos]);
+//        pyarr_[pos] = PyLong_FromLong(action);
+//    } else if (key == 32) {
+//        pos = 'Z' - 'A' + 11;
+//        Py_XDECREF(pyarr_[pos]);
+//        pyarr_[pos] = PyLong_FromLong(action);
+//    }
+//    //printf("pos: %i\n",pos);
 //}
 //
 //
 //
 //void KeyboardExternalControl::update() {
-//	run();
+//    run();
 //}
 //
 //KeyboardExternalControl::~KeyboardExternalControl() {
-//	for(int i = 0; i < pyarrSize_; ++i) {
-//		Py_XDECREF(pyarr_[i]);
-//	}
+//    for(int i = 0; i < pyarrSize_; ++i) {
+//        Py_XDECREF(pyarr_[i]);
+//    }
 //}
 //
 //} // namespace openspace
diff --git a/src/interaction/externalcontrol/mouseexternalcontrol.cpp b/src/interaction/externalcontrol/mouseexternalcontrol.cpp
index d9da0d00dc..41d93bd951 100644
--- a/src/interaction/externalcontrol/mouseexternalcontrol.cpp
+++ b/src/interaction/externalcontrol/mouseexternalcontrol.cpp
@@ -14,65 +14,65 @@
 //
 //
 //MouseExternalControl::MouseExternalControl(const char *filename): PythonExternalControl(filename) {
-//	clear();
-//	pyarrSize_ = 6*2;
-//	pyarr_ = new PyObject*[pyarrSize_];
-//	x_ = 0;
-//	y_ = 0;
-//	pos_ = 0;
-//	button1_ = 0;
-//	button2_ = 0;
-//	button3_ = 0;
-//	for(int i = 0; i < pyarrSize_; ++i) {
-//		pyarr_[i] = PyLong_FromLong(0);;
-//	}
+//    clear();
+//    pyarrSize_ = 6*2;
+//    pyarr_ = new PyObject*[pyarrSize_];
+//    x_ = 0;
+//    y_ = 0;
+//    pos_ = 0;
+//    button1_ = 0;
+//    button2_ = 0;
+//    button3_ = 0;
+//    for(int i = 0; i < pyarrSize_; ++i) {
+//        pyarr_[i] = PyLong_FromLong(0);;
+//    }
 //
 //}
 //
 //void MouseExternalControl::mouseButtonCallback(int key, int action) {
-//	if(key == 0)
-//		button1_ = action;
-//	if(key == 1)
-//		button2_ = action;
-//	if(key == 2)
-//		button3_ = action;
+//    if(key == 0)
+//        button1_ = action;
+//    if(key == 1)
+//        button2_ = action;
+//    if(key == 2)
+//        button3_ = action;
 //}
 //
 //void MouseExternalControl::mousePosCallback(int x, int y) {
-//	x_ = x;
-//	y_ = y;
+//    x_ = x;
+//    y_ = y;
 //}
-//	
+//    
 //void MouseExternalControl::mouseScrollCallback(int pos) {
-//	pos_ = pos;
+//    pos_ = pos;
 //}
 //
 //void MouseExternalControl::update() {
-//	
-//	pyarr_[6] = pyarr_[0];
-//	pyarr_[7] = pyarr_[1];
-//	pyarr_[8] = pyarr_[2];
-//	pyarr_[9] = pyarr_[3];
-//	pyarr_[10] = pyarr_[4];
-//	pyarr_[11] = pyarr_[5];
-//	pyarr_[0] = PyLong_FromLong(button1_);
-//	pyarr_[1] = PyLong_FromLong(button2_);
-//	pyarr_[2] = PyLong_FromLong(button3_);
-//	pyarr_[3] = PyLong_FromLong(pos_);
-//	pyarr_[4] = PyLong_FromLong(x_);
-//	pyarr_[5] = PyLong_FromLong(y_);
+//    
+//    pyarr_[6] = pyarr_[0];
+//    pyarr_[7] = pyarr_[1];
+//    pyarr_[8] = pyarr_[2];
+//    pyarr_[9] = pyarr_[3];
+//    pyarr_[10] = pyarr_[4];
+//    pyarr_[11] = pyarr_[5];
+//    pyarr_[0] = PyLong_FromLong(button1_);
+//    pyarr_[1] = PyLong_FromLong(button2_);
+//    pyarr_[2] = PyLong_FromLong(button3_);
+//    pyarr_[3] = PyLong_FromLong(pos_);
+//    pyarr_[4] = PyLong_FromLong(x_);
+//    pyarr_[5] = PyLong_FromLong(y_);
 //
-//	run();
+//    run();
 //
-//	// cleanup
-//	for(int i = pyarrSize_ / 2; i < pyarrSize_; ++i) {
-//		Py_XDECREF(pyarr_[i]);
-//	}
-//	
+//    // cleanup
+//    for(int i = pyarrSize_ / 2; i < pyarrSize_; ++i) {
+//        Py_XDECREF(pyarr_[i]);
+//    }
+//    
 //}
 //
 //MouseExternalControl::~MouseExternalControl() {
-//	
+//    
 //}
 //
 //} // namespace openspace
diff --git a/src/interaction/externalcontrol/pythonexternalcontrol.cpp b/src/interaction/externalcontrol/pythonexternalcontrol.cpp
index ac95c3639a..541421b6d0 100644
--- a/src/interaction/externalcontrol/pythonexternalcontrol.cpp
+++ b/src/interaction/externalcontrol/pythonexternalcontrol.cpp
@@ -32,115 +32,115 @@
 //static PyObject* pyexcontrol_message(PyObject *self, PyObject *args)
 //{
 //    char* text = 0;
-//	 if(!PyArg_ParseTuple(args, "s:pyexcontrol_yeah",&text))
+//     if(!PyArg_ParseTuple(args, "s:pyexcontrol_yeah",&text))
 //        Py_RETURN_NONE;
-//	
-//	PythonExternalControl * ext = 0;
-//	ext->message(text);
+//    
+//    PythonExternalControl * ext = 0;
+//    ext->message(text);
 //
-//	Py_RETURN_NONE;
+//    Py_RETURN_NONE;
 //}
 //
 //static PyObject* pyexcontrol_rotateCamera(PyObject *self, PyObject *args)
 //{
-//	char* text = 0;
-//	float f1 = 0;
-//	float f2 = 0;
-//	float f3 = 0;
-//	float f4 = 0;
-//	if(!PyArg_ParseTuple(args, "fff:pyexcontrol_rotateCamera",&f1,&f2,&f3))
-//		Py_RETURN_NONE;
-//	
-//	double dt = InteractionHandler::ref().getDt();
-//	glm::vec3 EulerAngles(f1*dt,f2*dt, f3*dt);
-//	glm::quat rot = glm::quat(EulerAngles);
-//	ExternalControl * ext = 0;
-//	ext->rotate(rot);
+//    char* text = 0;
+//    float f1 = 0;
+//    float f2 = 0;
+//    float f3 = 0;
+//    float f4 = 0;
+//    if(!PyArg_ParseTuple(args, "fff:pyexcontrol_rotateCamera",&f1,&f2,&f3))
+//        Py_RETURN_NONE;
+//    
+//    double dt = InteractionHandler::ref().getDt();
+//    glm::vec3 EulerAngles(f1*dt,f2*dt, f3*dt);
+//    glm::quat rot = glm::quat(EulerAngles);
+//    ExternalControl * ext = 0;
+//    ext->rotate(rot);
 //
-//	Py_RETURN_NONE;
+//    Py_RETURN_NONE;
 //}
 //
 //static PyObject* pyexcontrol_orbitCamera(PyObject *self, PyObject *args)
 //{
-//	char* text = 0;
-//	float f1 = 0;
-//	float f2 = 0;
-//	float f3 = 0;
-//	if(!PyArg_ParseTuple(args, "fff:pyexcontrol_rotateCamera",&f1,&f2,&f3))
-//		Py_RETURN_NONE;
-//	
-//	double dt = InteractionHandler::ref().getDt();
-//	glm::vec3 EulerAngles(f1*dt,f2*dt, f3*dt);
-//	glm::quat rot = glm::quat(EulerAngles);
-//	ExternalControl * ext = 0;
-//	ext->orbit(rot);
-//	
-//	Py_RETURN_NONE;
+//    char* text = 0;
+//    float f1 = 0;
+//    float f2 = 0;
+//    float f3 = 0;
+//    if(!PyArg_ParseTuple(args, "fff:pyexcontrol_rotateCamera",&f1,&f2,&f3))
+//        Py_RETURN_NONE;
+//    
+//    double dt = InteractionHandler::ref().getDt();
+//    glm::vec3 EulerAngles(f1*dt,f2*dt, f3*dt);
+//    glm::quat rot = glm::quat(EulerAngles);
+//    ExternalControl * ext = 0;
+//    ext->orbit(rot);
+//    
+//    Py_RETURN_NONE;
 //}
 //
 //static PyObject* pyexcontrol_distance(PyObject *self, PyObject *args)
 //{
-//	char* text = 0;
-//	float f1 = 0;
-//	float f2 = 0;
-//	if(!PyArg_ParseTuple(args, "ff:pyexcontrol_rotateCamera",&f1,&f2))
-//		Py_RETURN_NONE;
-//	
-//	float dt = static_cast<float>(InteractionHandler::ref().getDt());
-//	pss dist(f1*dt,f2);
-//	ExternalControl * ext = 0;
-//	ext->distance(dist);
-//	
-//	Py_RETURN_NONE;
+//    char* text = 0;
+//    float f1 = 0;
+//    float f2 = 0;
+//    if(!PyArg_ParseTuple(args, "ff:pyexcontrol_rotateCamera",&f1,&f2))
+//        Py_RETURN_NONE;
+//    
+//    float dt = static_cast<float>(InteractionHandler::ref().getDt());
+//    pss dist(f1*dt,f2);
+//    ExternalControl * ext = 0;
+//    ext->distance(dist);
+//    
+//    Py_RETURN_NONE;
 //}
 //
 //PyMethodDef* PythonExternalControl::getMethodDef() {
-//	// creating the python callback function table
-//	static PyMethodDef pyexcontrol_methods[] = {
-//		{"numargs", pyexcontrol_numargs, METH_VARARGS, "function"},
-//		{"message", pyexcontrol_message, METH_VARARGS, "function"},
-//		{"rotate", pyexcontrol_rotateCamera, METH_VARARGS, "function"},
-//		{"orbit", pyexcontrol_orbitCamera, METH_VARARGS, "function"},
-//		{"distance", pyexcontrol_distance, METH_VARARGS, "function"},
-//		 {NULL, NULL, 0, NULL}
-//	};
-//	return pyexcontrol_methods;
+//    // creating the python callback function table
+//    static PyMethodDef pyexcontrol_methods[] = {
+//        {"numargs", pyexcontrol_numargs, METH_VARARGS, "function"},
+//        {"message", pyexcontrol_message, METH_VARARGS, "function"},
+//        {"rotate", pyexcontrol_rotateCamera, METH_VARARGS, "function"},
+//        {"orbit", pyexcontrol_orbitCamera, METH_VARARGS, "function"},
+//        {"distance", pyexcontrol_distance, METH_VARARGS, "function"},
+//         {NULL, NULL, 0, NULL}
+//    };
+//    return pyexcontrol_methods;
 //}
 //
 //void PythonExternalControl::message(const char *text) {
-//	
-//	 printf("Input message from PythonScript: %s\n", text);
+//    
+//     printf("Input message from PythonScript: %s\n", text);
 //}
 //
 //PythonExternalControl::PythonExternalControl(const char *filename) {
-//	pyarr_ = nullptr;
-//	ps_.load(filename, true);
+//    pyarr_ = nullptr;
+//    ps_.load(filename, true);
 //}
 //
 //
 //void PythonExternalControl::update() {
-//	run();
+//    run();
 //}
 //
 //void PythonExternalControl::run() {
-//	if(pyarrSize_ > 0)
-//		ps_.run(pyarrSize_, pyarr_);
-//	else
-//		ps_.run();
+//    if(pyarrSize_ > 0)
+//        ps_.run(pyarrSize_, pyarr_);
+//    else
+//        ps_.run();
 //}
 //
 //
 //void PythonExternalControl::clear() {
-//	if(pyarr_ != nullptr) {
-//		// cleanup
-//		delete pyarr_;
-//		pyarr_ = nullptr;
-//		pyarrSize_ = 0;
-//	}
+//    if(pyarr_ != nullptr) {
+//        // cleanup
+//        delete pyarr_;
+//        pyarr_ = nullptr;
+//        pyarrSize_ = 0;
+//    }
 //}
 //
 //PythonExternalControl::~PythonExternalControl() {
-//	clear();
+//    clear();
 //}
 //
 //} // namespace openspace
diff --git a/src/interaction/externalcontrol/randomexternalcontrol.cpp b/src/interaction/externalcontrol/randomexternalcontrol.cpp
index 2433f9d6a6..88ddd29813 100644
--- a/src/interaction/externalcontrol/randomexternalcontrol.cpp
+++ b/src/interaction/externalcontrol/randomexternalcontrol.cpp
@@ -2,58 +2,58 @@
 
 #include <cstdio>
 #ifndef __WIN32__
-	#include <unistd.h>
+    #include <unistd.h>
 #endif
 
 namespace openspace {
 
 typedef struct 
 {
-	bool *keepGoing;
-	double *dx;
+    bool *keepGoing;
+    double *dx;
 } parm;
 
 void *updatedx(void * arg) {
-	parm *p = (parm*) arg;
-	bool *kg = p->keepGoing;
-	double *dx = p->dx;
-	while( *kg ) {
-		//printf("Hello world!\n");
-		*dx = *dx + 0.5;
+    parm *p = (parm*) arg;
+    bool *kg = p->keepGoing;
+    double *dx = p->dx;
+    while( *kg ) {
+        //printf("Hello world!\n");
+        *dx = *dx + 0.5;
 
-		
+        
 #ifndef __WIN32__
         // random sleep time
         int diff = rand() % 200;
 
         usleep(10000*diff);
 #endif
-	}
-	delete p;
-	return NULL;
+    }
+    delete p;
+    return NULL;
 }
 
-	
+    
 RandomExternalControl::RandomExternalControl() {
-	/*
-	inputGuard = PTHREAD_MUTEX_INITIALIZER;
+    /*
+    inputGuard = PTHREAD_MUTEX_INITIALIZER;
 
-	pthread_attr_t pthread_custom_attr;
-	pthread_attr_init(&pthread_custom_attr);
-	keepGoing_ = new bool;
-	*keepGoing_ = true;
-	parm *p = (parm*)malloc(sizeof(parm));
-	p->keepGoing = keepGoing_;
-	p->dx = &dx_;
+    pthread_attr_t pthread_custom_attr;
+    pthread_attr_init(&pthread_custom_attr);
+    keepGoing_ = new bool;
+    *keepGoing_ = true;
+    parm *p = (parm*)malloc(sizeof(parm));
+    p->keepGoing = keepGoing_;
+    p->dx = &dx_;
 
-	pthread_create(&backgroundThread, &pthread_custom_attr, updatedx, (void*)p);
-	*/
+    pthread_create(&backgroundThread, &pthread_custom_attr, updatedx, (void*)p);
+    */
 }
 
 RandomExternalControl::~RandomExternalControl() {
-	*keepGoing_ = false;
-	//pthread_join(backgroundThread, NULL);
-	delete keepGoing_;
+    *keepGoing_ = false;
+    //pthread_join(backgroundThread, NULL);
+    delete keepGoing_;
 }
 
 } // namespace openspace
diff --git a/src/interaction/interactionhandler.cpp b/src/interaction/interactionhandler.cpp
index 3865b2eb99..31c30d3c68 100644
--- a/src/interaction/interactionhandler.cpp
+++ b/src/interaction/interactionhandler.cpp
@@ -121,7 +121,7 @@ void InteractionHandler::update(double deltaTime) {
     
     _keyframeMutex.lock();
 
-    if (_keyframes.size() > 4){	//wait until enough samples are buffered
+    if (_keyframes.size() > 4){    //wait until enough samples are buffered
         hasKeys = true;
         
         openspace::network::datamessagestructures::PositionKeyframe p0, p1, p2, p3;
@@ -214,12 +214,12 @@ const Camera* const InteractionHandler::camera() const {
 }
 
 //void InteractionHandler::keyboardCallback(int key, int action) {
-//	if (_keyboardController) {
-//		auto start = ghoul::HighResClock::now();
-//		_keyboardController->keyPressed(KeyAction(action), Key(key), KeyModifier::None);
-//		auto end = ghoul::HighResClock::now();
-//		LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
-//	}
+//    if (_keyboardController) {
+//        auto start = ghoul::HighResClock::now();
+//        _keyboardController->keyPressed(KeyAction(action), Key(key), KeyModifier::None);
+//        auto end = ghoul::HighResClock::now();
+//        LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
+//    }
 //}
 
 void InteractionHandler::mouseButtonCallback(MouseButton button, MouseAction action) {
@@ -272,7 +272,7 @@ void InteractionHandler::orbit(const float &dx, const float &dy, const float &dz
     }
 
     //new camera position
-    relative = origin + relative_focus_coordinate; 	
+    relative = origin + relative_focus_coordinate;     
 
     float bounds = 2.f * (_focusNode ? _focusNode->boundingSphere().lengthf() : 0.f) / 10.f;
 
@@ -292,22 +292,22 @@ void InteractionHandler::orbit(const float &dx, const float &dy, const float &dz
 
 //void InteractionHandler::distance(const float &d){
 //
-//	lockControls();
+//    lockControls();
 //
-//	psc relative = _camera->position();
-//	const psc origin = (_focusNode) ? _focusNode->worldPosition() : psc();
-//	psc relative_origin_coordinate = relative - origin;
-//	// addition 100% of bounds (fix later to something node specific?)
-//	float bounds = 2.f * (_focusNode ? _focusNode->boundingSphere().lengthf() : 0.f);
+//    psc relative = _camera->position();
+//    const psc origin = (_focusNode) ? _focusNode->worldPosition() : psc();
+//    psc relative_origin_coordinate = relative - origin;
+//    // addition 100% of bounds (fix later to something node specific?)
+//    float bounds = 2.f * (_focusNode ? _focusNode->boundingSphere().lengthf() : 0.f);
 //
-//	psc target = relative + relative_origin_coordinate * d;// *fmaxf(bounds, (1.f - d));
-//	//don't fly into objects
-//	if ((target - origin).length() < bounds){
-//		target = relative;
-//	}
-//	_camera->setPosition(target);
-//	
-//	unlockControls();
+//    psc target = relative + relative_origin_coordinate * d;// *fmaxf(bounds, (1.f - d));
+//    //don't fly into objects
+//    if ((target - origin).length() < bounds){
+//        target = relative;
+//    }
+//    _camera->setPosition(target);
+//    
+//    unlockControls();
 //}
 
 void InteractionHandler::orbitDelta(const glm::quat& rotation)
@@ -345,17 +345,17 @@ void InteractionHandler::orbitDelta(const glm::quat& rotation)
 
 //<<<<<<< HEAD
 //void InteractionHandler::distance(const PowerScaledScalar &dist, size_t iterations) {
-//	if (iterations > 5)
-//		return;
-//	//assert(this_);
-//	lockControls();
-//	
-//	psc relative = _camera->position();
-//	const psc origin = (_node) ? _node->worldPosition() : psc();
+//    if (iterations > 5)
+//        return;
+//    //assert(this_);
+//    lockControls();
+//    
+//    psc relative = _camera->position();
+//    const psc origin = (_node) ? _node->worldPosition() : psc();
 //
-//	psc relative_origin_coordinate = relative - origin;
-//	const glm::vec3 dir(relative_origin_coordinate.direction());
-//	glm::vec3 newdir = dir * dist[0];
+//    psc relative_origin_coordinate = relative - origin;
+//    const glm::vec3 dir(relative_origin_coordinate.direction());
+//    glm::vec3 newdir = dir * dist[0];
 //=======
 void InteractionHandler::rotateDelta(const glm::quat& rotation)
 {
diff --git a/src/interaction/keyboardcontroller.cpp b/src/interaction/keyboardcontroller.cpp
index 235a2ebef7..ba7dd478f2 100644
--- a/src/interaction/keyboardcontroller.cpp
+++ b/src/interaction/keyboardcontroller.cpp
@@ -36,291 +36,291 @@
 #include <chrono>
 
 namespace {
-	const std::string _loggerCat = "KeyboardController";
+    const std::string _loggerCat = "KeyboardController";
 }
 
 namespace openspace {
 namespace interaction {
 
 void KeyboardControllerFixed::keyPressed(KeyAction action, Key key, KeyModifier modifier) {
-	// TODO package in script
-	const float dt = static_cast<float>( _handler->deltaTime());
-	if(action == KeyAction::Press|| action == KeyAction::Repeat) {
+    // TODO package in script
+    const float dt = static_cast<float>( _handler->deltaTime());
+    if(action == KeyAction::Press|| action == KeyAction::Repeat) {
         const float speed = 2.75;
-		if (key == Key::S) {
-		    glm::vec3 euler(speed * dt, 0.0, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->orbitDelta(rot);
-		}
-		if (key == Key::W) {
-		    glm::vec3 euler(-speed * dt, 0.0, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->orbitDelta(rot);
-		}
-		if (key == Key::A) {
-		    glm::vec3 euler(0.0, -speed * dt, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->orbitDelta(rot);
-		}
-		if (key == Key::D) {
-		    glm::vec3 euler(0.0, speed * dt, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->orbitDelta(rot);
-		}
-		if (key == Key::Q) {
-			Time::ref().advanceTime(dt);
-		}
-		if (key == Key::Right) {
-		    glm::vec3 euler(0.0, speed * dt, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->rotateDelta(rot);
-		}
-		if (key == Key::Left) {
-		    glm::vec3 euler(0.0, -speed * dt, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->rotateDelta(rot);
-		}
-		if (key == Key::Down) {
-		    glm::vec3 euler(speed * dt, 0.0, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->rotateDelta(rot);
-		}
-		if (key == Key::Up) {
-		    glm::vec3 euler(-speed * dt, 0.0, 0.0);
-		    glm::quat rot = glm::quat(euler);
-		    _handler->rotateDelta(rot);
-		}
-		if (key == Key::R) {
-		    PowerScaledScalar dist(-speed * dt, 0.0);
-		    _handler->distanceDelta(dist);
-		}
-		if (key == Key::F) {
-		    PowerScaledScalar dist(speed * dt, 0.0);
-		    _handler->distanceDelta(dist);
-		}
-		if (key == Key::T) {
-			PowerScaledScalar dist(-speed * pow(10.0f, 11.0f) * dt, 0.0f);
-			_handler->distanceDelta(dist);
-		}
-		//if (key == Keys::G) {
-		//	acc += 0.001;
-		//	PowerScaledScalar dist(speed * pow(10, 8 * acc) * dt, 0.0);
-		//	distanceDelta(dist);
-		//}
-		if (key == Key::Y) {
-			PowerScaledScalar dist(-speed * 100.0f * dt, 6.0f);
-			_handler->distanceDelta(dist);
-		}
-		if (key == Key::H) {
-			PowerScaledScalar dist(speed * 100.0f * dt, 6.0f);
-			_handler->distanceDelta(dist);
-		}
-	
-		if (key == Key::KeypadSubtract) {
-			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
-			s[1] -= 0.5;
-			OsEng.renderEngine().camera()->setScaling(s);
-		}
-		if (key == Key::KeypadAdd) {
-			glm::vec2 s = OsEng.renderEngine().camera()->scaling();
-			s[1] += 0.5;
-			OsEng.renderEngine().camera()->setScaling(s);
-		}
-	}
-	/*
-	if (key == '1') {
-	    SceneGraphNode* node = getSceneGraphNode("sun");
-	
-	    setFocusNode(node);
-	    getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 0.5, 10.0));
-	    getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
-	}
-	
-	if (key == '2') {
-	    SceneGraphNode* node = getSceneGraphNode("earth");
-	
-	    setFocusNode(node);
-	    getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 1.0, 8.0));
-	    getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
-	}
-	
-	
-	if (key == '3') {
-	    SceneGraphNode* node = getSceneGraphNode("moon");
-	
-	    setFocusNode(node);
-	    getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 0.5, 8.0));
-	    getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
-	}
-	*/
+        if (key == Key::S) {
+            glm::vec3 euler(speed * dt, 0.0, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->orbitDelta(rot);
+        }
+        if (key == Key::W) {
+            glm::vec3 euler(-speed * dt, 0.0, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->orbitDelta(rot);
+        }
+        if (key == Key::A) {
+            glm::vec3 euler(0.0, -speed * dt, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->orbitDelta(rot);
+        }
+        if (key == Key::D) {
+            glm::vec3 euler(0.0, speed * dt, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->orbitDelta(rot);
+        }
+        if (key == Key::Q) {
+            Time::ref().advanceTime(dt);
+        }
+        if (key == Key::Right) {
+            glm::vec3 euler(0.0, speed * dt, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->rotateDelta(rot);
+        }
+        if (key == Key::Left) {
+            glm::vec3 euler(0.0, -speed * dt, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->rotateDelta(rot);
+        }
+        if (key == Key::Down) {
+            glm::vec3 euler(speed * dt, 0.0, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->rotateDelta(rot);
+        }
+        if (key == Key::Up) {
+            glm::vec3 euler(-speed * dt, 0.0, 0.0);
+            glm::quat rot = glm::quat(euler);
+            _handler->rotateDelta(rot);
+        }
+        if (key == Key::R) {
+            PowerScaledScalar dist(-speed * dt, 0.0);
+            _handler->distanceDelta(dist);
+        }
+        if (key == Key::F) {
+            PowerScaledScalar dist(speed * dt, 0.0);
+            _handler->distanceDelta(dist);
+        }
+        if (key == Key::T) {
+            PowerScaledScalar dist(-speed * pow(10.0f, 11.0f) * dt, 0.0f);
+            _handler->distanceDelta(dist);
+        }
+        //if (key == Keys::G) {
+        //    acc += 0.001;
+        //    PowerScaledScalar dist(speed * pow(10, 8 * acc) * dt, 0.0);
+        //    distanceDelta(dist);
+        //}
+        if (key == Key::Y) {
+            PowerScaledScalar dist(-speed * 100.0f * dt, 6.0f);
+            _handler->distanceDelta(dist);
+        }
+        if (key == Key::H) {
+            PowerScaledScalar dist(speed * 100.0f * dt, 6.0f);
+            _handler->distanceDelta(dist);
+        }
+    
+        if (key == Key::KeypadSubtract) {
+            glm::vec2 s = OsEng.renderEngine().camera()->scaling();
+            s[1] -= 0.5;
+            OsEng.renderEngine().camera()->setScaling(s);
+        }
+        if (key == Key::KeypadAdd) {
+            glm::vec2 s = OsEng.renderEngine().camera()->scaling();
+            s[1] += 0.5;
+            OsEng.renderEngine().camera()->setScaling(s);
+        }
+    }
+    /*
+    if (key == '1') {
+        SceneGraphNode* node = getSceneGraphNode("sun");
+    
+        setFocusNode(node);
+        getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 0.5, 10.0));
+        getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
+    }
+    
+    if (key == '2') {
+        SceneGraphNode* node = getSceneGraphNode("earth");
+    
+        setFocusNode(node);
+        getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 1.0, 8.0));
+        getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
+    }
+    
+    
+    if (key == '3') {
+        SceneGraphNode* node = getSceneGraphNode("moon");
+    
+        setFocusNode(node);
+        getCamera()->setPosition(node->getWorldPosition() + psc(0.0, 0.0, 0.5, 8.0));
+        getCamera()->setCameraDirection(glm::vec3(0.0, 0.0, -1.0));
+    }
+    */
 }
 
 void KeyboardControllerLua::keyPressed(KeyAction action, Key key, KeyModifier modifier) {
-	lua_State* s = luaL_newstate();
-	luaL_openlibs(s);
-	
-	int status = luaL_loadfile(s, absPath("${SCRIPTS}/default_keybinding.lua").c_str());
-	if (status != LUA_OK) {
-		LERROR("Error loading script: '" << lua_tostring(s, -1) << "'");
-		return;
-	}
+    lua_State* s = luaL_newstate();
+    luaL_openlibs(s);
+    
+    int status = luaL_loadfile(s, absPath("${SCRIPTS}/default_keybinding.lua").c_str());
+    if (status != LUA_OK) {
+        LERROR("Error loading script: '" << lua_tostring(s, -1) << "'");
+        return;
+    }
 
-	if (lua_pcall(s, 0, LUA_MULTRET, 0)) {
-		LERROR("Error executing script: " << lua_tostring(s, -1));
-		return;
-	}
+    if (lua_pcall(s, 0, LUA_MULTRET, 0)) {
+        LERROR("Error executing script: " << lua_tostring(s, -1));
+        return;
+    }
 
     auto start = std::chrono::high_resolution_clock::now();
 
-	lua_getfield(s, -1, keyToString(key, modifier).c_str());
-	if (!lua_isnil(s, -1))
-		lua_pcall(s, 0, 0, 0);
-	else
-		LINFO("Key not found");
+    lua_getfield(s, -1, keyToString(key, modifier).c_str());
+    if (!lua_isnil(s, -1))
+        lua_pcall(s, 0, 0, 0);
+    else
+        LINFO("Key not found");
 
     auto end = std::chrono::high_resolution_clock::now();
-	LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
+    LINFO("Keyboard timing: " << std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count() << "ns");
 
 
 }
 
 std::string KeyboardControllerLua::keyToString(Key key, KeyModifier mod) const {
-	std::string result = "";
-	int intMod = static_cast<int>(mod);
-	if (intMod & static_cast<int>(KeyModifier::Control))
-		result += "CTRL + ";
-	if (intMod & static_cast<int>(KeyModifier::Super))
-		result += "SUPER + ";
-	if (intMod & static_cast<int>(KeyModifier::Alt))
-		result += "ALT + ";
-	if (intMod & static_cast<int>(KeyModifier::Shift))
-		result += "SHIFT + ";
+    std::string result = "";
+    int intMod = static_cast<int>(mod);
+    if (intMod & static_cast<int>(KeyModifier::Control))
+        result += "CTRL + ";
+    if (intMod & static_cast<int>(KeyModifier::Super))
+        result += "SUPER + ";
+    if (intMod & static_cast<int>(KeyModifier::Alt))
+        result += "ALT + ";
+    if (intMod & static_cast<int>(KeyModifier::Shift))
+        result += "SHIFT + ";
 
-	switch (key) {
-		case Key::Unknown:			result += "Unknown";		break;
-		case Key::Space:			result += "Space";			break;
-		case Key::Apostrophe:		result += "Apostrophe";		break;
-		case Key::Comma:			result += "Comma";			break;
-		case Key::Minus:			result += "Minus";			break;
-		case Key::Period:			result += "Period";			break;
-		case Key::Slash:			result += "Slash";			break;
-		case Key::Num0:				result += "0";				break;
-		case Key::Num1:				result += "1";				break;
-		case Key::Num2:				result += "2";				break;
-		case Key::Num3:				result += "3";				break;
-		case Key::Num4:				result += "4";				break;
-		case Key::Num5:				result += "5";				break;
-		case Key::Num6:				result += "6";				break;
-		case Key::Num7:				result += "7";				break;
-		case Key::Num8:				result += "8";				break;
-		case Key::Num9:				result += "9";				break;
-		case Key::SemiColon:		result += "SemiColon";		break;
-		case Key::Equal:			result += "Equal";			break;
-		case Key::A:				result += "A";				break;
-		case Key::B:				result += "B";				break;
-		case Key::C:				result += "C";				break;
-		case Key::D:				result += "D";				break;
-		case Key::E:				result += "E";				break;
-		case Key::F:				result += "F";				break;
-		case Key::G:				result += "G";				break;
-		case Key::H:				result += "H";				break;
-		case Key::I:				result += "I";				break;
-		case Key::J:				result += "J";				break;
-		case Key::K:				result += "K";				break;
-		case Key::L:				result += "L";				break;
-		case Key::M:				result += "M";				break;
-		case Key::N:				result += "N";				break;
-		case Key::O:				result += "O";				break;
-		case Key::P:				result += "P";				break;
-		case Key::Q:				result += "Q";				break;
-		case Key::R:				result += "R";				break;
-		case Key::S:				result += "S";				break;
-		case Key::T:				result += "T";				break;
-		case Key::U:				result += "U";				break;
-		case Key::V:				result += "V";				break;
-		case Key::W:				result += "W";				break;
-		case Key::X:				result += "X";				break;
-		case Key::Y:				result += "Y";				break;
-		case Key::Z:				result += "Z";				break;
-		case Key::LeftBracket:		result += "LeftBracket";	break;
-		case Key::BackSlash:		result += "BackSlash";		break;
-		case Key::RightBracket:		result += "RightBracket";	break;
-		case Key::GraveAccent:		result += "GraveAccent";	break;
-		case Key::World1:			result += "World1";			break;
-		case Key::World2:			result += "World2";			break;
-		case Key::Escape:			result += "Escape";			break;
-		case Key::Enter:			result += "Enter";			break;
-		case Key::Tab:				result += "Tab";			break;
-		case Key::BackSpace:		result += "BackSpace";		break;
-		case Key::Insert:			result += "Insert";			break;
-		case Key::Delete:			result += "Delete";			break;
-		case Key::Right:			result += "Right";			break;
-		case Key::Left:				result += "Left";			break;
-		case Key::Down:				result += "Down";			break;
-		case Key::Up:				result += "Up";				break;
-		case Key::PageUp:			result += "PageUp";			break;
-		case Key::PageDown:			result += "PageDown";		break;
-		case Key::Home:				result += "Home";			break;
-		case Key::End:				result += "End";			break;
-		case Key::CapsLock:			result += "CapsLock";		break;
-		case Key::ScrollLock:		result += "ScrollLock";		break;
-		case Key::NumLock:			result += "NumLock";		break;
-		case Key::PrintScreen:		result += "PrintScreen";	break;
-		case Key::Pause:			result += "Pause";			break;
-		case Key::F1:				result += "F1";				break;
-		case Key::F2:				result += "F2";				break;
-		case Key::F3:				result += "F3";				break;
-		case Key::F4:				result += "F4";				break;
-		case Key::F5:				result += "F5";				break;
-		case Key::F6:				result += "F6";				break;
-		case Key::F7:				result += "F7";				break;
-		case Key::F8:				result += "F8";				break;
-		case Key::F9:				result += "F9";				break;
-		case Key::F10:				result += "F10";			break;
-		case Key::F11:				result += "F11";			break;
-		case Key::F12:				result += "F12";			break;
-		case Key::F13:				result += "F13";			break;
-		case Key::F14:				result += "F14";			break;
-		case Key::F15:				result += "F15";			break;
-		case Key::F16:				result += "F16";			break;
-		case Key::F17:				result += "F17";			break;
-		case Key::F18:				result += "F18";			break;
-		case Key::F19:				result += "F19";			break;
-		case Key::F20:				result += "F20";			break;
-		case Key::F21:				result += "F21";			break;
-		case Key::F22:				result += "F22";			break;
-		case Key::F23:				result += "F23";			break;
-		case Key::F24:				result += "F24";			break;
-		case Key::F25:				result += "F25";			break;
-		case Key::Keypad0:			result += "Keypad0";		break;
-		case Key::Keypad1:			result += "Keypad1";		break;
-		case Key::Keypad2:			result += "Keypad2";		break;
-		case Key::Keypad3:			result += "Keypad3";		break;
-		case Key::Keypad4:			result += "Keypad4";		break;
-		case Key::Keypad5:			result += "Keypad5";		break;
-		case Key::Keypad6:			result += "Keypad6";		break;
-		case Key::Keypad7:			result += "Keypad7";		break;
-		case Key::Keypad8:			result += "Keypad8";		break;
-		case Key::Keypad9:			result += "Keypad9";		break;
-		case Key::KeypadDecimal:	result += "KeypadDecimal";	break;
-		case Key::KeypadDivide:		result += "KeypadDivide";	break;
-		case Key::KeypadMultiply:	result += "KeypadMultiply";	break;
-		case Key::KeypadSubtract:	result += "KeypadSubtract";	break;
-		case Key::KeypadAdd:		result += "KeypadAdd";		break;
-		case Key::KeypadEnter:		result += "KeypadEnter";	break;
-		case Key::LeftShift:		result += "LeftShift";		break;
-		case Key::LeftControl:		result += "LeftControl";	break;
-		case Key::LeftAlt:			result += "LeftAlt";		break;
-		case Key::LeftSuper:		result += "LeftSuper";		break;
-		case Key::RightShift:		result += "RightShift";		break;
-		case Key::RightControl:		result += "RightControl";	break;
-		case Key::RightAlt:			result += "RightAlt";		break;
-		case Key::RightSuper:		result += "RightSuper";		break;
-		case Key::Menu:				result += "Menu";			break;
-		default:
-			assert(false);
-	}
-	return result;
+    switch (key) {
+        case Key::Unknown:            result += "Unknown";        break;
+        case Key::Space:            result += "Space";            break;
+        case Key::Apostrophe:        result += "Apostrophe";        break;
+        case Key::Comma:            result += "Comma";            break;
+        case Key::Minus:            result += "Minus";            break;
+        case Key::Period:            result += "Period";            break;
+        case Key::Slash:            result += "Slash";            break;
+        case Key::Num0:                result += "0";                break;
+        case Key::Num1:                result += "1";                break;
+        case Key::Num2:                result += "2";                break;
+        case Key::Num3:                result += "3";                break;
+        case Key::Num4:                result += "4";                break;
+        case Key::Num5:                result += "5";                break;
+        case Key::Num6:                result += "6";                break;
+        case Key::Num7:                result += "7";                break;
+        case Key::Num8:                result += "8";                break;
+        case Key::Num9:                result += "9";                break;
+        case Key::SemiColon:        result += "SemiColon";        break;
+        case Key::Equal:            result += "Equal";            break;
+        case Key::A:                result += "A";                break;
+        case Key::B:                result += "B";                break;
+        case Key::C:                result += "C";                break;
+        case Key::D:                result += "D";                break;
+        case Key::E:                result += "E";                break;
+        case Key::F:                result += "F";                break;
+        case Key::G:                result += "G";                break;
+        case Key::H:                result += "H";                break;
+        case Key::I:                result += "I";                break;
+        case Key::J:                result += "J";                break;
+        case Key::K:                result += "K";                break;
+        case Key::L:                result += "L";                break;
+        case Key::M:                result += "M";                break;
+        case Key::N:                result += "N";                break;
+        case Key::O:                result += "O";                break;
+        case Key::P:                result += "P";                break;
+        case Key::Q:                result += "Q";                break;
+        case Key::R:                result += "R";                break;
+        case Key::S:                result += "S";                break;
+        case Key::T:                result += "T";                break;
+        case Key::U:                result += "U";                break;
+        case Key::V:                result += "V";                break;
+        case Key::W:                result += "W";                break;
+        case Key::X:                result += "X";                break;
+        case Key::Y:                result += "Y";                break;
+        case Key::Z:                result += "Z";                break;
+        case Key::LeftBracket:        result += "LeftBracket";    break;
+        case Key::BackSlash:        result += "BackSlash";        break;
+        case Key::RightBracket:        result += "RightBracket";    break;
+        case Key::GraveAccent:        result += "GraveAccent";    break;
+        case Key::World1:            result += "World1";            break;
+        case Key::World2:            result += "World2";            break;
+        case Key::Escape:            result += "Escape";            break;
+        case Key::Enter:            result += "Enter";            break;
+        case Key::Tab:                result += "Tab";            break;
+        case Key::BackSpace:        result += "BackSpace";        break;
+        case Key::Insert:            result += "Insert";            break;
+        case Key::Delete:            result += "Delete";            break;
+        case Key::Right:            result += "Right";            break;
+        case Key::Left:                result += "Left";            break;
+        case Key::Down:                result += "Down";            break;
+        case Key::Up:                result += "Up";                break;
+        case Key::PageUp:            result += "PageUp";            break;
+        case Key::PageDown:            result += "PageDown";        break;
+        case Key::Home:                result += "Home";            break;
+        case Key::End:                result += "End";            break;
+        case Key::CapsLock:            result += "CapsLock";        break;
+        case Key::ScrollLock:        result += "ScrollLock";        break;
+        case Key::NumLock:            result += "NumLock";        break;
+        case Key::PrintScreen:        result += "PrintScreen";    break;
+        case Key::Pause:            result += "Pause";            break;
+        case Key::F1:                result += "F1";                break;
+        case Key::F2:                result += "F2";                break;
+        case Key::F3:                result += "F3";                break;
+        case Key::F4:                result += "F4";                break;
+        case Key::F5:                result += "F5";                break;
+        case Key::F6:                result += "F6";                break;
+        case Key::F7:                result += "F7";                break;
+        case Key::F8:                result += "F8";                break;
+        case Key::F9:                result += "F9";                break;
+        case Key::F10:                result += "F10";            break;
+        case Key::F11:                result += "F11";            break;
+        case Key::F12:                result += "F12";            break;
+        case Key::F13:                result += "F13";            break;
+        case Key::F14:                result += "F14";            break;
+        case Key::F15:                result += "F15";            break;
+        case Key::F16:                result += "F16";            break;
+        case Key::F17:                result += "F17";            break;
+        case Key::F18:                result += "F18";            break;
+        case Key::F19:                result += "F19";            break;
+        case Key::F20:                result += "F20";            break;
+        case Key::F21:                result += "F21";            break;
+        case Key::F22:                result += "F22";            break;
+        case Key::F23:                result += "F23";            break;
+        case Key::F24:                result += "F24";            break;
+        case Key::F25:                result += "F25";            break;
+        case Key::Keypad0:            result += "Keypad0";        break;
+        case Key::Keypad1:            result += "Keypad1";        break;
+        case Key::Keypad2:            result += "Keypad2";        break;
+        case Key::Keypad3:            result += "Keypad3";        break;
+        case Key::Keypad4:            result += "Keypad4";        break;
+        case Key::Keypad5:            result += "Keypad5";        break;
+        case Key::Keypad6:            result += "Keypad6";        break;
+        case Key::Keypad7:            result += "Keypad7";        break;
+        case Key::Keypad8:            result += "Keypad8";        break;
+        case Key::Keypad9:            result += "Keypad9";        break;
+        case Key::KeypadDecimal:    result += "KeypadDecimal";    break;
+        case Key::KeypadDivide:        result += "KeypadDivide";    break;
+        case Key::KeypadMultiply:    result += "KeypadMultiply";    break;
+        case Key::KeypadSubtract:    result += "KeypadSubtract";    break;
+        case Key::KeypadAdd:        result += "KeypadAdd";        break;
+        case Key::KeypadEnter:        result += "KeypadEnter";    break;
+        case Key::LeftShift:        result += "LeftShift";        break;
+        case Key::LeftControl:        result += "LeftControl";    break;
+        case Key::LeftAlt:            result += "LeftAlt";        break;
+        case Key::LeftSuper:        result += "LeftSuper";        break;
+        case Key::RightShift:        result += "RightShift";        break;
+        case Key::RightControl:        result += "RightControl";    break;
+        case Key::RightAlt:            result += "RightAlt";        break;
+        case Key::RightSuper:        result += "RightSuper";        break;
+        case Key::Menu:                result += "Menu";            break;
+        default:
+            assert(false);
+    }
+    return result;
 }
 
 } // namespace interaction
diff --git a/src/interaction/luaconsole.cpp b/src/interaction/luaconsole.cpp
index a7bf1ccb99..7fe960624b 100644
--- a/src/interaction/luaconsole.cpp
+++ b/src/interaction/luaconsole.cpp
@@ -59,8 +59,8 @@ LuaConsole::LuaConsole()
     , _autoCompleteInfo({NoAutoComplete, false, ""})
     , _isVisible(false)
 {
-//	_commands.push_back("");
-//	_activeCommand = _commands.size() - 1;
+//    _commands.push_back("");
+//    _activeCommand = _commands.size() - 1;
 }
 
 void LuaConsole::initialize() {
diff --git a/src/interaction/mousecontroller.cpp b/src/interaction/mousecontroller.cpp
index b646c9214d..73db191e71 100644
--- a/src/interaction/mousecontroller.cpp
+++ b/src/interaction/mousecontroller.cpp
@@ -33,112 +33,112 @@ namespace openspace {
 namespace interaction {
 
 MouseController::MouseController()
-	: _lastTrackballPos(0.f)
-	, _isMouseBeingPressedAndHeld(false)
+    : _lastTrackballPos(0.f)
+    , _isMouseBeingPressedAndHeld(false)
 {}
 
 glm::vec3 MouseController::mapToTrackball(glm::vec2 mousePos) {
-	const float RADIUS = 0.5; // Sphere radius
-	glm::vec3 out = glm::vec3(mousePos.x - 0.5, -1.0*(mousePos.y - 0.5), 0);
+    const float RADIUS = 0.5; // Sphere radius
+    glm::vec3 out = glm::vec3(mousePos.x - 0.5, -1.0*(mousePos.y - 0.5), 0);
 
-	// Mapping according to Holroyds trackball
-	// Piece-wise sphere + hyperbolic sheet
-	if (out.x*out.x + out.y*out.y <= RADIUS*RADIUS / 2.0) {
-		//Spherical Region
-		out.z = RADIUS*RADIUS - (out.x*out.x + out.y*out.y);
-		out.z = out.z > 0.0f ? sqrtf(out.z) : 0.0f;
-	}
-	else { //Hyperbolic Region - for smooth z values
-		out.z = (RADIUS*RADIUS) / (2.0f*sqrt(out.x*out.x + out.y*out.y));
-	}
+    // Mapping according to Holroyds trackball
+    // Piece-wise sphere + hyperbolic sheet
+    if (out.x*out.x + out.y*out.y <= RADIUS*RADIUS / 2.0) {
+        //Spherical Region
+        out.z = RADIUS*RADIUS - (out.x*out.x + out.y*out.y);
+        out.z = out.z > 0.0f ? sqrtf(out.z) : 0.0f;
+    }
+    else { //Hyperbolic Region - for smooth z values
+        out.z = (RADIUS*RADIUS) / (2.0f*sqrt(out.x*out.x + out.y*out.y));
+    }
 
-	return glm::normalize(out);
+    return glm::normalize(out);
 }
 
 glm::vec3 MouseController::mapToCamera(glm::vec3 trackballPos) {
-	//Get x,y,z axis vectors of current camera view
-	glm::vec3 currentViewYaxis = glm::normalize(_handler->camera()->lookUpVector());
-	psc viewDir = _handler->camera()->position() - _handler->focusNode()->worldPosition();
-	glm::vec3 currentViewZaxis = glm::normalize(viewDir.vec3());
-	glm::vec3 currentViewXaxis = glm::normalize(glm::cross(currentViewYaxis, currentViewZaxis));
+    //Get x,y,z axis vectors of current camera view
+    glm::vec3 currentViewYaxis = glm::normalize(_handler->camera()->lookUpVector());
+    psc viewDir = _handler->camera()->position() - _handler->focusNode()->worldPosition();
+    glm::vec3 currentViewZaxis = glm::normalize(viewDir.vec3());
+    glm::vec3 currentViewXaxis = glm::normalize(glm::cross(currentViewYaxis, currentViewZaxis));
 
-	//mapping to camera co-ordinate
-	currentViewXaxis *= trackballPos.x;
-	currentViewYaxis *= trackballPos.y;
-	currentViewZaxis *= trackballPos.z;
-	return (currentViewXaxis + currentViewYaxis + currentViewZaxis);
+    //mapping to camera co-ordinate
+    currentViewXaxis *= trackballPos.x;
+    currentViewYaxis *= trackballPos.y;
+    currentViewZaxis *= trackballPos.z;
+    return (currentViewXaxis + currentViewYaxis + currentViewZaxis);
 }
 
 void MouseController::trackballRotate(int x, int y) {
-	// Normalize mouse coordinates to [0,1]
+    // Normalize mouse coordinates to [0,1]
     glm::vec2 res = OsEng.windowWrapper().currentWindowSize();
-	glm::vec2 mousePos = glm::vec2((float)x / res.x, (float)y / res.y);
+    glm::vec2 mousePos = glm::vec2((float)x / res.x, (float)y / res.y);
 
-	mousePos = glm::clamp(mousePos, -0.5f, 1.5f); // Ugly fix #1: Camera position becomes NaN on mouse values outside [-0.5, 1.5]
-	//mousePos[1] = 0.5; 							// Ugly fix #2: Tempoarily only allow rotation around y
+    mousePos = glm::clamp(mousePos, -0.5f, 1.5f); // Ugly fix #1: Camera position becomes NaN on mouse values outside [-0.5, 1.5]
+    //mousePos[1] = 0.5;                             // Ugly fix #2: Tempoarily only allow rotation around y
 
-	glm::vec3 curTrackballPos = mapToTrackball(mousePos);
-	//	LDEBUG(mousePos.x << ", " << mousePos.y << " = " << curTrackballPos.x << ", " << curTrackballPos.y << ", " << curTrackballPos.z);
+    glm::vec3 curTrackballPos = mapToTrackball(mousePos);
+    //    LDEBUG(mousePos.x << ", " << mousePos.y << " = " << curTrackballPos.x << ", " << curTrackballPos.y << ", " << curTrackballPos.z);
 
-	// Disable movement on the first click for extra smoothness
-	if (!_isMouseBeingPressedAndHeld) {
-		_lastTrackballPos = curTrackballPos;
-		_isMouseBeingPressedAndHeld = true;
-	}
+    // Disable movement on the first click for extra smoothness
+    if (!_isMouseBeingPressedAndHeld) {
+        _lastTrackballPos = curTrackballPos;
+        _isMouseBeingPressedAndHeld = true;
+    }
 
-	if (curTrackballPos != _lastTrackballPos) {
-		// calculate rotation angle (in radians)
-		float rotationAngle = glm::angle(curTrackballPos, _lastTrackballPos);
-		rotationAngle *= static_cast<float>(_handler->deltaTime()) * 100.0f;
+    if (curTrackballPos != _lastTrackballPos) {
+        // calculate rotation angle (in radians)
+        float rotationAngle = glm::angle(curTrackballPos, _lastTrackballPos);
+        rotationAngle *= static_cast<float>(_handler->deltaTime()) * 100.0f;
 
-		// Map trackballpos to camera
-		//		glm::vec3 trackballMappedToCamera = mapToCamera(_lastTrackballPos - curTrackballPos);
-		//		psc currentCamPos = camera_->getPosition();
-		//		glm::vec3 nextCamPos = currentCamPos.getVec3f() + trackballMappedToCamera;
-		//		glm::vec3 rotationAxis = glm::cross(currentCamPos.getVec3f(), nextCamPos);
+        // Map trackballpos to camera
+        //        glm::vec3 trackballMappedToCamera = mapToCamera(_lastTrackballPos - curTrackballPos);
+        //        psc currentCamPos = camera_->getPosition();
+        //        glm::vec3 nextCamPos = currentCamPos.getVec3f() + trackballMappedToCamera;
+        //        glm::vec3 rotationAxis = glm::cross(currentCamPos.getVec3f(), nextCamPos);
 
-		glm::vec3 rotationAxis = glm::cross(_lastTrackballPos, curTrackballPos);
-		rotationAxis = glm::normalize(rotationAxis);
-		glm::quat quaternion = glm::angleAxis(rotationAngle, rotationAxis);
+        glm::vec3 rotationAxis = glm::cross(_lastTrackballPos, curTrackballPos);
+        rotationAxis = glm::normalize(rotationAxis);
+        glm::quat quaternion = glm::angleAxis(rotationAngle, rotationAxis);
 
-		// Apply quaternion to camera
-		_handler->orbitDelta(quaternion);
+        // Apply quaternion to camera
+        _handler->orbitDelta(quaternion);
 
-		_lastTrackballPos = curTrackballPos;
-	}
+        _lastTrackballPos = curTrackballPos;
+    }
 }
 
 
 TrackballMouseController::TrackballMouseController()
-	: MouseController()
-	, _leftMouseButtonDown(false)
+    : MouseController()
+    , _leftMouseButtonDown(false)
 {}
 
 void TrackballMouseController::button(MouseButton button, MouseAction action) {
-	if (button == MouseButton::Left && action == MouseAction::Press)
-			_leftMouseButtonDown = true;
-	else if (button == MouseButton::Left && action == MouseAction::Release) {
-		_leftMouseButtonDown = false;
-		_isMouseBeingPressedAndHeld = false;
-	}
+    if (button == MouseButton::Left && action == MouseAction::Press)
+            _leftMouseButtonDown = true;
+    else if (button == MouseButton::Left && action == MouseAction::Release) {
+        _leftMouseButtonDown = false;
+        _isMouseBeingPressedAndHeld = false;
+    }
 }
 
 void TrackballMouseController::move(float x, float y) {
-	if (_leftMouseButtonDown)
-		trackballRotate(static_cast<int>(x), static_cast<int>(y));
+    if (_leftMouseButtonDown)
+        trackballRotate(static_cast<int>(x), static_cast<int>(y));
 }
 
 void TrackballMouseController::scrollWheel(int pos) {
-	const float speed = 4.75f;
-	const float dt = static_cast<float>(_handler->deltaTime());
-	if (pos < 0) {
-		PowerScaledScalar dist(speed * dt, 0.0f);
-		_handler->distanceDelta(dist);
-	}
-	else if (pos > 0) {
-		PowerScaledScalar dist(-speed * dt, 0.0f);
-		_handler->distanceDelta(dist);
-	}
+    const float speed = 4.75f;
+    const float dt = static_cast<float>(_handler->deltaTime());
+    if (pos < 0) {
+        PowerScaledScalar dist(speed * dt, 0.0f);
+        _handler->distanceDelta(dist);
+    }
+    else if (pos > 0) {
+        PowerScaledScalar dist(-speed * dt, 0.0f);
+        _handler->distanceDelta(dist);
+    }
 }
 
 void TrackballMouseController::update(const double& dt){
@@ -155,63 +155,63 @@ OrbitalMouseController::OrbitalMouseController()
     , _rotationSpeed(10.f)
     , _navigationSpeed(3.f)
 {
-	for (int n = 0; n < 3; ++n){
-		_previousCursorPos[n] = glm::vec2(0);
-	}
+    for (int n = 0; n < 3; ++n){
+        _previousCursorPos[n] = glm::vec2(0);
+    }
 }
 
 void OrbitalMouseController::button(MouseButton button, MouseAction action) {
-	if (button == MouseButton::Left){
-		if (action == MouseAction::Press){
-			_leftMouseButtonDown = true;
+    if (button == MouseButton::Left){
+        if (action == MouseAction::Press){
+            _leftMouseButtonDown = true;
             _previousCursorPos[MouseButtons::ButtonLeft] = OsEng.windowWrapper().mousePosition();
-		}
-		else if (action == MouseAction::Release) {
-			_leftMouseButtonDown = false;
-			_currentCursorDiff[MouseButtons::ButtonLeft] = glm::vec2(0);
-		}
-	}
-	else if (button == MouseButton::Right){
-		if (action == MouseAction::Press){
-			_rightMouseButtonDown = true;
+        }
+        else if (action == MouseAction::Release) {
+            _leftMouseButtonDown = false;
+            _currentCursorDiff[MouseButtons::ButtonLeft] = glm::vec2(0);
+        }
+    }
+    else if (button == MouseButton::Right){
+        if (action == MouseAction::Press){
+            _rightMouseButtonDown = true;
             _previousCursorPos[MouseButtons::ButtonRight] = OsEng.windowWrapper().mousePosition();
-		}
-		else if (action == MouseAction::Release) {
-			_rightMouseButtonDown = false;
-			_currentCursorDiff[MouseButtons::ButtonRight] = glm::vec2(0);
-		}
-	}
-	else if (button == MouseButton::Middle){
-		if (action == MouseAction::Press){
-			_middleMouseButtonDown = true;
+        }
+        else if (action == MouseAction::Release) {
+            _rightMouseButtonDown = false;
+            _currentCursorDiff[MouseButtons::ButtonRight] = glm::vec2(0);
+        }
+    }
+    else if (button == MouseButton::Middle){
+        if (action == MouseAction::Press){
+            _middleMouseButtonDown = true;
             _previousCursorPos[MouseButtons::ButtonMiddle] = OsEng.windowWrapper().mousePosition();
-		}
-		else if (action == MouseAction::Release) {
-			_middleMouseButtonDown = false;
-			_currentCursorDiff[MouseButtons::ButtonMiddle] = glm::vec2(0);
-		}
-	}
+        }
+        else if (action == MouseAction::Release) {
+            _middleMouseButtonDown = false;
+            _currentCursorDiff[MouseButtons::ButtonMiddle] = glm::vec2(0);
+        }
+    }
 
 }
 
 void OrbitalMouseController::move(float x, float y) {
     _currentCursorPos = OsEng.windowWrapper().mousePosition();
 
-	if (_leftMouseButtonDown) {
+    if (_leftMouseButtonDown) {
         glm::vec2 diff = _currentCursorPos - _previousCursorPos[MouseButtons::ButtonLeft];
         glm::vec2 res = OsEng.windowWrapper().currentWindowSize();
         _currentCursorDiff[MouseButtons::ButtonLeft] = diff / res;
-	}
-	if (_rightMouseButtonDown) {
+    }
+    if (_rightMouseButtonDown) {
         glm::vec2 diff = _currentCursorPos - _previousCursorPos[MouseButtons::ButtonRight];
         glm::vec2 res = OsEng.windowWrapper().currentWindowSize();
         _currentCursorDiff[MouseButtons::ButtonRight] = diff / res;
-	}
-	if (_middleMouseButtonDown) {
+    }
+    if (_middleMouseButtonDown) {
         glm::vec2 diff = _currentCursorPos - _previousCursorPos[MouseButtons::ButtonMiddle];
         glm::vec2 res = OsEng.windowWrapper().currentWindowSize();
         _currentCursorDiff[MouseButtons::ButtonMiddle] = diff / res;
-	}
+    }
 }
 
 void OrbitalMouseController::scrollWheel(int pos) {
@@ -222,24 +222,24 @@ void OrbitalMouseController::update(const double& dt){
     const float interactionSpeed = OsEng.interactionHandler().interactionSensitivity();
     const bool rotationInvert = OsEng.interactionHandler().invertRotation();
     const bool rollInvert = OsEng.interactionHandler().invertRoll();
-	
-	//if (_leftMouseButtonDown || _rightMouseButtonDown || _middleMouseButtonDown){
-		_handler->orbit(
-			static_cast<float>(_leftMouseButtonDown) * static_cast<float>(dt)  *  _currentCursorDiff[MouseButtons::ButtonLeft].x * interactionSpeed * (rotationInvert ? -1.f : 1.f), 
-			static_cast<float>(_leftMouseButtonDown) * static_cast<float>(dt)  *  _currentCursorDiff[MouseButtons::ButtonLeft].y * interactionSpeed * (rotationInvert ? -1.f : 1.f),
-			static_cast<float>(_middleMouseButtonDown) * static_cast<float>(dt) * _currentCursorDiff[MouseButtons::ButtonMiddle].x * interactionSpeed  * (rollInvert ? -1.f : 1.f),
-			static_cast<float>(_rightMouseButtonDown) * static_cast<float>(dt)  * _currentCursorDiff[MouseButtons::ButtonRight].y * _navigationSpeed);
-	//}
-	
-//	if (_leftMouseButtonDown){
-//		_handler->orbit(static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonLeft].x * _rotationSpeed, static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonLeft].y * _rotationSpeed, 0.f);
-//	}	
-//	if (_middleMouseButtonDown){
-//		_handler->orbit(0.f, 0.f, static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonMiddle].x * _rotationSpeed);
-//	}
-//	if (_rightMouseButtonDown){
-//		_handler->distance(static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonRight].y * _navigationSpeed);
-//	}
+    
+    //if (_leftMouseButtonDown || _rightMouseButtonDown || _middleMouseButtonDown){
+        _handler->orbit(
+            static_cast<float>(_leftMouseButtonDown) * static_cast<float>(dt)  *  _currentCursorDiff[MouseButtons::ButtonLeft].x * interactionSpeed * (rotationInvert ? -1.f : 1.f), 
+            static_cast<float>(_leftMouseButtonDown) * static_cast<float>(dt)  *  _currentCursorDiff[MouseButtons::ButtonLeft].y * interactionSpeed * (rotationInvert ? -1.f : 1.f),
+            static_cast<float>(_middleMouseButtonDown) * static_cast<float>(dt) * _currentCursorDiff[MouseButtons::ButtonMiddle].x * interactionSpeed  * (rollInvert ? -1.f : 1.f),
+            static_cast<float>(_rightMouseButtonDown) * static_cast<float>(dt)  * _currentCursorDiff[MouseButtons::ButtonRight].y * _navigationSpeed);
+    //}
+    
+//    if (_leftMouseButtonDown){
+//        _handler->orbit(static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonLeft].x * _rotationSpeed, static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonLeft].y * _rotationSpeed, 0.f);
+//    }    
+//    if (_middleMouseButtonDown){
+//        _handler->orbit(0.f, 0.f, static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonMiddle].x * _rotationSpeed);
+//    }
+//    if (_rightMouseButtonDown){
+//        _handler->distance(static_cast<float>(dt)* _currentCursorDiff[MouseButtons::ButtonRight].y * _navigationSpeed);
+//    }
 }
 
 } // namespace interaction
diff --git a/src/network/parallelconnection.cpp b/src/network/parallelconnection.cpp
index e7dfa28e43..6c50b40644 100644
--- a/src/network/parallelconnection.cpp
+++ b/src/network/parallelconnection.cpp
@@ -64,7 +64,7 @@
 #include "parallelconnection_lua.inl"
 
 namespace {
-	const std::string _loggerCat = "ParallelConnection";
+    const std::string _loggerCat = "ParallelConnection";
 }
 
 namespace openspace {
@@ -219,29 +219,29 @@ void ParallelConnection::clientConnect(){
         return;
     }
             
-	if (!initNetworkAPI()){
+    if (!initNetworkAPI()){
         LERROR("Failed to initialize network API for Parallel Connection");
         return;
-	}
-			
-	struct addrinfo *addresult = NULL, *ptr = NULL, hints;
-	#ifdef __WIN32__ //WinSock
-		ZeroMemory(&hints, sizeof(hints));
-	#else
-		memset(&hints, 0, sizeof(hints));
-	#endif
-	hints.ai_family = AF_INET;
-	hints.ai_socktype = SOCK_STREAM;
-	hints.ai_protocol = IPPROTO_TCP;
-	hints.ai_flags = AI_PASSIVE;
+    }
+            
+    struct addrinfo *addresult = NULL, *ptr = NULL, hints;
+    #ifdef __WIN32__ //WinSock
+        ZeroMemory(&hints, sizeof(hints));
+    #else
+        memset(&hints, 0, sizeof(hints));
+    #endif
+    hints.ai_family = AF_INET;
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_protocol = IPPROTO_TCP;
+    hints.ai_flags = AI_PASSIVE;
 
-	// Resolve the local address and port to be used by the server
-	int result = getaddrinfo(_address.c_str(), _port.c_str(), &hints, &addresult);
-	if (result != 0)
-	{
+    // Resolve the local address and port to be used by the server
+    int result = getaddrinfo(_address.c_str(), _port.c_str(), &hints, &addresult);
+    if (result != 0)
+    {
         LERROR("Failed to parse hints for Parallel Connection");
-		return;
-	}
+        return;
+    }
             
     //we're not connected
     _isConnected.store(false);
@@ -250,8 +250,8 @@ void ParallelConnection::clientConnect(){
     _tryConnect.store(true);
             
     //start connection thread
-	_connectionThread = new (std::nothrow) std::thread(&ParallelConnection::establishConnection, this, addresult);
-			
+    _connectionThread = new (std::nothrow) std::thread(&ParallelConnection::establishConnection, this, addresult);
+            
 }
 
 void ParallelConnection::establishConnection(addrinfo *info){
@@ -349,60 +349,60 @@ void ParallelConnection::establishConnection(addrinfo *info){
 #endif
     }
             
-	//cleanup
-	freeaddrinfo(info);
+    //cleanup
+    freeaddrinfo(info);
 }
 
 void ParallelConnection::sendAuthentication(){
     //length of this nodes name
-	uint16_t namelen = static_cast<uint16_t>(_name.length());
+    uint16_t namelen = static_cast<uint16_t>(_name.length());
             
     //total size of the buffer, header + size of passcodde + namelength + size of namelength
-	int size = headerSize() + sizeof(uint32_t) + sizeof(namelen) + static_cast<int>(namelen);
+    int size = headerSize() + sizeof(uint32_t) + sizeof(namelen) + static_cast<int>(namelen);
 
     //create and reserve buffer
     std::vector<char> buffer;
-	buffer.reserve(size);
+    buffer.reserve(size);
 
     //write header to buffer
     writeHeader(buffer, MessageTypes::Authentication);
 
-	//write passcode to buffer
-	buffer.insert(buffer.end(), reinterpret_cast<char*>(&_passCode), reinterpret_cast<char*>(&_passCode) + sizeof(uint32_t));
+    //write passcode to buffer
+    buffer.insert(buffer.end(), reinterpret_cast<char*>(&_passCode), reinterpret_cast<char*>(&_passCode) + sizeof(uint32_t));
 
-	//write the length of the nodes name to buffer
-	buffer.insert(buffer.end(), reinterpret_cast<char*>(&namelen), reinterpret_cast<char*>(&namelen) + sizeof(uint16_t));
+    //write the length of the nodes name to buffer
+    buffer.insert(buffer.end(), reinterpret_cast<char*>(&namelen), reinterpret_cast<char*>(&namelen) + sizeof(uint16_t));
 
-	//write this nodes name to buffer
-	buffer.insert(buffer.end(), _name.begin(), _name.end());
+    //write this nodes name to buffer
+    buffer.insert(buffer.end(), _name.begin(), _name.end());
             
     //send buffer
-	queueMessage(buffer);
+    queueMessage(buffer);
 }
 
 void ParallelConnection::delegateDecoding(uint32_t type){
-	switch (type){
-	case MessageTypes::Authentication:
+    switch (type){
+    case MessageTypes::Authentication:
         //not used
-		break;
-	case MessageTypes::Initialization:
-		initializationMessageReceived();
-		break;
-	case MessageTypes::Data:
-		dataMessageReceived();
+        break;
+    case MessageTypes::Initialization:
+        initializationMessageReceived();
+        break;
+    case MessageTypes::Data:
+        dataMessageReceived();
         break;
     case MessageTypes::Script:
             //not used
-		break;
-	case MessageTypes::HostInfo:
-		hostInfoMessageReceived();
-		break;
-	case MessageTypes::InitializationRequest:
-		initializationRequestMessageReceived();
-		break;
-	default:
-		//unknown message type
-		break;
+        break;
+    case MessageTypes::HostInfo:
+        hostInfoMessageReceived();
+        break;
+    case MessageTypes::InitializationRequest:
+        initializationRequestMessageReceived();
+        break;
+    default:
+        //unknown message type
+        break;
     }
 }
 
@@ -410,28 +410,28 @@ void ParallelConnection::initializationMessageReceived(){
             
     int result;
             
-	uint32_t id, datasize;
+    uint32_t id, datasize;
     uint16_t numscripts;
             
     std::vector<char> buffer;
-	buffer.resize(sizeof(id));
+    buffer.resize(sizeof(id));
 
-	//read id
-	result = receiveData(_clientSocket, buffer, sizeof(id), 0);
-	if (result < 0){
-		//error
-	}
-	id = *(reinterpret_cast<uint32_t*>(buffer.data()));
+    //read id
+    result = receiveData(_clientSocket, buffer, sizeof(id), 0);
+    if (result < 0){
+        //error
+    }
+    id = *(reinterpret_cast<uint32_t*>(buffer.data()));
 
-	//read datalength
-	result = receiveData(_clientSocket, buffer, sizeof(datasize), 0);
-	if (result < 0){
-		//error
-	}
-	datasize = *(reinterpret_cast<uint32_t*>(buffer.data()));
+    //read datalength
+    result = receiveData(_clientSocket, buffer, sizeof(datasize), 0);
+    if (result < 0){
+        //error
+    }
+    datasize = *(reinterpret_cast<uint32_t*>(buffer.data()));
             
-	buffer.clear();
-	buffer.resize(sizeof(uint16_t));
+    buffer.clear();
+    buffer.resize(sizeof(uint16_t));
     //read number of scripts
     result = receiveData(_clientSocket, buffer, sizeof(numscripts), 0);
     if(result < 0){
@@ -484,22 +484,22 @@ void ParallelConnection::initializationMessageReceived(){
 }
 
 void ParallelConnection::dataMessageReceived(){
-	int result;
-	uint16_t msglen;
+    int result;
+    uint16_t msglen;
     uint16_t type;
 
     //create a buffer to hold the size of streamdata message
     std::vector<char> buffer;
-	buffer.resize(sizeof(type));
+    buffer.resize(sizeof(type));
             
     //read type of data message
-	result = receiveData(_clientSocket, buffer, sizeof(type), 0);
+    result = receiveData(_clientSocket, buffer, sizeof(type), 0);
 
-	if (result <= 0){
-		//error
+    if (result <= 0){
+        //error
         LERROR("Failed to read type of data message received.");
-		return;
-	}
+        return;
+    }
             
     //the type of data message received
     type =(*(reinterpret_cast<uint16_t*>(buffer.data())));
@@ -514,20 +514,20 @@ void ParallelConnection::dataMessageReceived(){
     }
             
     //the size in bytes of the streamdata message
-	msglen = (*(reinterpret_cast<uint16_t*>(buffer.data())));
+    msglen = (*(reinterpret_cast<uint16_t*>(buffer.data())));
 
     //resize the buffer to be able to read the streamdata
-	buffer.clear();
-	buffer.resize(msglen);
+    buffer.clear();
+    buffer.resize(msglen);
 
     //read the data into buffer
-	result = receiveData(_clientSocket, buffer, msglen, 0);
+    result = receiveData(_clientSocket, buffer, msglen, 0);
             
-	if (result <= 0){
-		//error
+    if (result <= 0){
+        //error
         LERROR("Failed to read data message.");
-		return;
-	}
+        return;
+    }
             
     //which type of data message was received?
     switch(type){
@@ -634,50 +634,50 @@ void ParallelConnection::sendFunc(){
         
 void ParallelConnection::hostInfoMessageReceived(){
     //create buffer
-	std::vector<char> hostflag;
+    std::vector<char> hostflag;
     //resize to hold a flag saying if we're host or not
-	hostflag.resize(1);
+    hostflag.resize(1);
             
     //read data into buffer
-	int result = receiveData(_clientSocket, hostflag, 1, 0);
+    int result = receiveData(_clientSocket, hostflag, 1, 0);
 
     //enough data was read
-	if (result > 0){
+    if (result > 0){
                 
         //we've been assigned as host
-		if (hostflag.at(0) == 1){
+        if (hostflag.at(0) == 1){
                     
-			//we're already host, do nothing (dummy check)
-			if (_isHost.load()){
-				return;
-			}
-			else{
+            //we're already host, do nothing (dummy check)
+            if (_isHost.load()){
+                return;
+            }
+            else{
                         
-				//we're the host
-				_isHost.store(true);
+                //we're the host
+                _isHost.store(true);
 
-				//start broadcasting
-				_broadcastThread = new (std::nothrow) std::thread(&ParallelConnection::broadcast, this);
-			}
-		}
-		else{   //we've been assigned as client
+                //start broadcasting
+                _broadcastThread = new (std::nothrow) std::thread(&ParallelConnection::broadcast, this);
+            }
+        }
+        else{   //we've been assigned as client
                     
-			//we were broadcasting but should stop now
-			if (_isHost.load()){
+            //we were broadcasting but should stop now
+            if (_isHost.load()){
 
                 //stop broadcast loop
-				_isHost.store(false);
-						
+                _isHost.store(false);
+                        
                 //and delete broadcasting thread
                 if (_broadcastThread != nullptr){
-					_broadcastThread->join();
-					delete _broadcastThread;
-					_broadcastThread = nullptr;
-				}                       
-			}
-			else{
-				//we were not broadcasting so nothing to do
-			}
+                    _broadcastThread->join();
+                    delete _broadcastThread;
+                    _broadcastThread = nullptr;
+                }                       
+            }
+            else{
+                //we were not broadcasting so nothing to do
+            }
                     
             //clear buffered any keyframes
             OsEng.interactionHandler().clearKeyframes();
@@ -691,13 +691,13 @@ void ParallelConnection::hostInfoMessageReceived(){
             writeHeader(buffer, MessageTypes::InitializationRequest);
 
             //send message
-			queueMessage(buffer);
-		}
-	}
-	else{
+            queueMessage(buffer);
+        }
+    }
+    else{
         LERROR("Error " << _ERRNO << " detected in connection, disconnecting.");
         signalDisconnect();
-	}
+    }
 }
 
 void ParallelConnection::initializationRequestMessageReceived(){
@@ -771,74 +771,74 @@ void ParallelConnection::initializationRequestMessageReceived(){
 }
 
 void ParallelConnection::listenCommunication(){
-			
-    //create basic buffer for receiving first part of messages
-	std::vector<char> buffer;
-    //size of the header
-	buffer.resize(headerSize());
             
-	int result;
+    //create basic buffer for receiving first part of messages
+    std::vector<char> buffer;
+    //size of the header
+    buffer.resize(headerSize());
+            
+    int result;
             
     //while we're still connected
-	while (_isConnected.load()){
+    while (_isConnected.load()){
         //receive the first parts of a message
-		result = receiveData(_clientSocket, buffer, headerSize(), 0);
+        result = receiveData(_clientSocket, buffer, headerSize(), 0);
 
         //if enough data was received
-		if (result > 0){
+        if (result > 0){
                 
             //make sure that header matches this version of OpenSpace
-			if (buffer[0] == 'O' &&                     //Open
-				buffer[1] == 'S' &&                     //Space
-				buffer[2] == OPENSPACE_VERSION_MAJOR && // major version
-				buffer[3] == OPENSPACE_VERSION_MINOR    // minor version
-				)
-			{
-				//parse type
-				uint32_t type = (*(reinterpret_cast<uint32_t*>(&buffer[4])));
+            if (buffer[0] == 'O' &&                     //Open
+                buffer[1] == 'S' &&                     //Space
+                buffer[2] == OPENSPACE_VERSION_MAJOR && // major version
+                buffer[3] == OPENSPACE_VERSION_MINOR    // minor version
+                )
+            {
+                //parse type
+                uint32_t type = (*(reinterpret_cast<uint32_t*>(&buffer[4])));
 
                 //and delegate decoding depending on type
-				delegateDecoding(type);
-			}
+                delegateDecoding(type);
+            }
             else{
                 LERROR("Error: Client OpenSpace version " << OPENSPACE_VERSION_MAJOR << ", " << OPENSPACE_VERSION_MINOR << " does not match server version " << buffer[2] <<", " << buffer[3] << std::endl << "Message not decoded.");
             }
-		}
-		else{
-			if (result == 0){
-				//connection rejected
-				LERROR("Parallel connection rejected, disconnecting...");
-			}
-			else{
-				LERROR("Error " << _ERRNO << " detected in connection, disconnecting!");
-			}
+        }
+        else{
+            if (result == 0){
+                //connection rejected
+                LERROR("Parallel connection rejected, disconnecting...");
+            }
+            else{
+                LERROR("Error " << _ERRNO << " detected in connection, disconnecting!");
+            }
 
             //signal that a disconnect should be performed
             signalDisconnect();
-			break;
-		}
-	}
+            break;
+        }
+    }
 
 }
 
 int ParallelConnection::receiveData(_SOCKET & socket, std::vector<char> &buffer, int length, int flags){
-	int result = 0;
-	int received = 0;
-	while (result < length){
-		received = recv(socket, buffer.data() + result, length - result, flags);
+    int result = 0;
+    int received = 0;
+    while (result < length){
+        received = recv(socket, buffer.data() + result, length - result, flags);
 
-		if (received > 0){
-			result += received;
-			received = 0;
-		}
-		else{
-			//error receiving
-			result = received;
-			break;
-		}
-	}
+        if (received > 0){
+            result += received;
+            received = 0;
+        }
+        else{
+            //error receiving
+            result = received;
+            break;
+        }
+    }
 
-	return result;
+    return result;
 }
         
 void ParallelConnection::setPort(const std::string  &port){
@@ -870,37 +870,37 @@ void ParallelConnection::requestHostship(const std::string &password){
     buffer.insert(buffer.end(), reinterpret_cast<char*>(&passcode), reinterpret_cast<char*>(&passcode) + sizeof(uint32_t));
             
     //send message
-	queueMessage(buffer);
+    queueMessage(buffer);
 }
 
 void ParallelConnection::setPassword(const std::string& pwd){
-	_passCode = hash(pwd);
+    _passCode = hash(pwd);
 }
 
 bool ParallelConnection::initNetworkAPI(){
-	#if defined(__WIN32__)
-		WSADATA wsaData;
-		WORD version;
-		int error;
+    #if defined(__WIN32__)
+        WSADATA wsaData;
+        WORD version;
+        int error;
 
-		version = MAKEWORD(2, 2);
+        version = MAKEWORD(2, 2);
 
-		error = WSAStartup(version, &wsaData);
+        error = WSAStartup(version, &wsaData);
 
-		if (error != 0 ||
-			LOBYTE(wsaData.wVersion) != 2 ||
-			HIBYTE(wsaData.wVersion) != 2)
-		{
-			/* incorrect WinSock version */
-			LERROR("Failed to init winsock API.");
-			//WSACleanup();
-			return false;
-		}
-	#else
-				//No init needed on unix
-	#endif
+        if (error != 0 ||
+            LOBYTE(wsaData.wVersion) != 2 ||
+            HIBYTE(wsaData.wVersion) != 2)
+        {
+            /* incorrect WinSock version */
+            LERROR("Failed to init winsock API.");
+            //WSACleanup();
+            return false;
+        }
+    #else
+                //No init needed on unix
+    #endif
 
-	return true;
+    return true;
 }
 
 void ParallelConnection::preSynchronization(){
@@ -1029,18 +1029,18 @@ std::string ParallelConnection::scriptFromPropertyAndValue(const std::string pro
 }
         
 void ParallelConnection::broadcast(){
-			
+            
     //while we're still connected and we're the host
-	while (_isConnected.load() && _isHost.load()){
+    while (_isConnected.load() && _isHost.load()){
 
         //create a keyframe with current position and orientation of camera
         network::datamessagestructures::PositionKeyframe kf;
-		kf._position = OsEng.interactionHandler().camera()->position();
-		kf._viewRotationQuat = glm::quat_cast(OsEng.interactionHandler().camera()->viewRotationMatrix());
-				
+        kf._position = OsEng.interactionHandler().camera()->position();
+        kf._viewRotationQuat = glm::quat_cast(OsEng.interactionHandler().camera()->viewRotationMatrix());
+                
         //timestamp as current runtime of OpenSpace instance
         kf._timeStamp = OsEng.runTime();
-				
+                
         //create a buffer for the keyframe
         std::vector<char> kfBuffer;
                 
@@ -1048,33 +1048,33 @@ void ParallelConnection::broadcast(){
         kf.serialize(kfBuffer);
                 
         //get the size of the keyframebuffer
-		uint16_t msglen = static_cast<uint16_t>(kfBuffer.size());
+        uint16_t msglen = static_cast<uint16_t>(kfBuffer.size());
                 
         //the type of message
         uint16_t type = static_cast<uint16_t>(network::datamessagestructures::PositionData);
                 
         //create the full buffer
-		std::vector<char> buffer;
-		buffer.reserve(headerSize() + sizeof(type) + sizeof(msglen) + msglen);
-				
-		//write header
+        std::vector<char> buffer;
+        buffer.reserve(headerSize() + sizeof(type) + sizeof(msglen) + msglen);
+                
+        //write header
         writeHeader(buffer, MessageTypes::Data);
                 
         //type of message
         buffer.insert(buffer.end(), reinterpret_cast<char*>(&type), reinterpret_cast<char*>(&type) + sizeof(type));
 
-		//size of message
-		buffer.insert(buffer.end(), reinterpret_cast<char*>(&msglen), reinterpret_cast<char*>(&msglen) + sizeof(msglen));
+        //size of message
+        buffer.insert(buffer.end(), reinterpret_cast<char*>(&msglen), reinterpret_cast<char*>(&msglen) + sizeof(msglen));
 
-		//actual message
-		buffer.insert(buffer.end(), kfBuffer.begin(), kfBuffer.end());
+        //actual message
+        buffer.insert(buffer.end(), kfBuffer.begin(), kfBuffer.end());
 
-		//send message
-		queueMessage(buffer);
+        //send message
+        queueMessage(buffer);
 
-		//100 ms sleep - send keyframes 10 times per second
-		std::this_thread::sleep_for(std::chrono::milliseconds(100));
-	}
+        //100 ms sleep - send keyframes 10 times per second
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    }
 }
         
 void ParallelConnection::writeHeader(std::vector<char> &buffer, uint32_t messageType){
@@ -1110,30 +1110,30 @@ scripting::ScriptEngine::LuaLibrary ParallelConnection::luaLibrary() {
                 "number",
                 "Set the port for the parallel connection"
             },
-			{
-				"setAddress",
-				&luascriptfunctions::setAddress,
-				"string",
-				"Set the address for the parallel connection"
-			},
-			{
-				"setPassword",
-				&luascriptfunctions::setPassword,
-				"string",
-				"Set the password for the parallel connection"
-			},
-			{
-				"setDisplayName",
-				&luascriptfunctions::setDisplayName,
-				"string",
-				"Set your display name for the parallel connection"
-			},
-			{
-				"connect",
-				&luascriptfunctions::connect,
-				"",
-				"Connect to parallel"
-			},
+            {
+                "setAddress",
+                &luascriptfunctions::setAddress,
+                "string",
+                "Set the address for the parallel connection"
+            },
+            {
+                "setPassword",
+                &luascriptfunctions::setPassword,
+                "string",
+                "Set the password for the parallel connection"
+            },
+            {
+                "setDisplayName",
+                &luascriptfunctions::setDisplayName,
+                "string",
+                "Set your display name for the parallel connection"
+            },
+            {
+                "connect",
+                &luascriptfunctions::connect,
+                "",
+                "Connect to parallel"
+            },
             {
                 "disconnect",
                 &luascriptfunctions::disconnect,
diff --git a/src/properties/matrixproperty.cpp b/src/properties/matrixproperty.cpp
index 2bdb434b60..ebf75616e9 100644
--- a/src/properties/matrixproperty.cpp
+++ b/src/properties/matrixproperty.cpp
@@ -115,21 +115,21 @@ namespace properties {
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat2Property, glm::mat2x2, glm::mat2x2(0),
                                   glm::mat2x2(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat2x2(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat2x2(
-									0.01f, 0.01f,
-									0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f,
+                                    0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat2x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat2x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat2x2),
@@ -138,25 +138,25 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat2Property, glm::mat2x2, glm::mat2x2(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat2x3Property, glm::mat2x3, glm::mat2x3(0),
                                   glm::mat2x3(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat2x3(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat2x3(
-									0.01f, 0.01f, 0.01f,
-									0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f,
+                                    0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat2x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat2x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat2x3),
@@ -165,29 +165,29 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat2x3Property, glm::mat2x3, glm::mat2x3(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat2x4Property, glm::mat2x4, glm::mat2x4(0),
                                   glm::mat2x4(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat2x4(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat2x4(
-									0.01f, 0.01f, 0.01f, 0.01f,
-									0.01f, 0.01f, 0.01f, 0.01f
-							      ),
+                                    0.01f, 0.01f, 0.01f, 0.01f,
+                                    0.01f, 0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat2x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat2x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat2x4),
@@ -196,25 +196,25 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat2x4Property, glm::mat2x4, glm::mat2x4(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat3x2Property, glm::mat3x2, glm::mat3x2(0),
                                   glm::mat3x2(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat3x2(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat3x2(
-									0.01f, 0.01f, 0.01f,
-									0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f,
+                                    0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat3x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat3x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat3x2),
@@ -223,32 +223,32 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat3x2Property, glm::mat3x2, glm::mat3x2(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat3Property, glm::mat3x3, glm::mat3x3(0),
                                   glm::mat3x3(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat3x3(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat3x3(
-									0.01f, 0.01f, 0.01f,
-									0.01f, 0.01f, 0.01f,
-									0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f,
+                                    0.01f, 0.01f, 0.01f,
+                                    0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat3x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat3x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat3x3),
@@ -257,38 +257,38 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat3Property, glm::mat3x3, glm::mat3x3(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat3x4Property, glm::mat3x4, glm::mat3x4(0),
                                   glm::mat3x4(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat3x4(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat3x4(
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat3x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat3x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat3x4),
@@ -297,29 +297,29 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat3x4Property, glm::mat3x4, glm::mat3x4(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat4x2Property, glm::mat4x2, glm::mat4x2(0),
                                   glm::mat4x2(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat4x2(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat4x2(
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat4x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat4x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat4x2),
@@ -328,38 +328,38 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat4x2Property, glm::mat4x2, glm::mat4x2(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat4x3Property, glm::mat4x3, glm::mat4x3(0),
                                   glm::mat4x3(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat4x3(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat4x3(
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat4x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat4x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat4x3),
@@ -368,47 +368,47 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat4x3Property, glm::mat4x3, glm::mat4x3(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(Mat4Property, glm::mat4x4, glm::mat4x4(0),
                                   glm::mat4x4(
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest(),
-									numeric_limits<float>::lowest()
-								  ),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest(),
+                                    numeric_limits<float>::lowest()
+                                  ),
                                   glm::mat4x4(
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max(),
-									numeric_limits<float>::max()
-								  ),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max(),
+                                    numeric_limits<float>::max()
+                                  ),
                                   glm::mat4x4(
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f, 
-									0.01f, 0.01f, 0.01f, 0.01f
-								  ),
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f, 
+                                    0.01f, 0.01f, 0.01f, 0.01f
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::mat4x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::mat4x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::mat4x4),
@@ -417,21 +417,21 @@ REGISTER_NUMERICALPROPERTY_SOURCE(Mat4Property, glm::mat4x4, glm::mat4x4(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat2Property, glm::dmat2x2, glm::dmat2x2(0),
                                   glm::dmat2x2(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat2x2(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat2x2(
-									0.01, 0.01, 
-									0.01, 0.01
-								  ),
+                                    0.01, 0.01, 
+                                    0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat2x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat2x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat2x2),
@@ -440,25 +440,25 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat2Property, glm::dmat2x2, glm::dmat2x2(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat2x3Property, glm::dmat2x3, glm::dmat2x3(0),
                                   glm::dmat2x3(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat2x3(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat2x3(
-									0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat2x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat2x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat2x3),
@@ -467,29 +467,29 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat2x3Property, glm::dmat2x3, glm::dmat2x3(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat2x4Property, glm::dmat2x4, glm::dmat2x4(0),
                                   glm::dmat2x4(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat2x4(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat2x4(
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat2x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat2x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat2x4),
@@ -498,25 +498,25 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat2x4Property, glm::dmat2x4, glm::dmat2x4(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat3x2Property, glm::dmat3x2, glm::dmat3x2(0),
                                   glm::dmat3x2(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat3x2(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat3x2(
-									0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat3x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat3x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat3x2),
@@ -525,32 +525,32 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat3x2Property, glm::dmat3x2, glm::dmat3x2(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat3Property, glm::dmat3x3, glm::dmat3x3(0),
                                   glm::dmat3x3(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat3x3(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat3x3(
-									0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat3x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat3x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat3x3),
@@ -559,38 +559,38 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat3Property, glm::dmat3x3, glm::dmat3x3(0),
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat3x4Property, glm::dmat3x4, glm::dmat3x4(0),
                                   glm::dmat3x4(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat3x4(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat3x4(
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat3x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat3x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat3x4),
@@ -599,29 +599,29 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat3x4Property, glm::dmat3x4, glm::dmat3x4(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat4x2Property, glm::dmat4x2, glm::dmat4x2(0),
                                   glm::dmat4x2(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat4x2(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat4x2(
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat4x2),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat4x2),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat4x2),
@@ -630,38 +630,38 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat4x2Property, glm::dmat4x2, glm::dmat4x2(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat4x3Property, glm::dmat4x3, glm::dmat4x3(0),
                                   glm::dmat4x3(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat4x3(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat4x3(
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat4x3),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat4x3),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat4x3),
@@ -670,47 +670,47 @@ REGISTER_NUMERICALPROPERTY_SOURCE(DMat4x3Property, glm::dmat4x3, glm::dmat4x3(0)
 
 REGISTER_NUMERICALPROPERTY_SOURCE(DMat4Property, glm::dmat4x4, glm::dmat4x4(0),
                                   glm::dmat4x4(
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest(),
-									numeric_limits<double>::lowest()
-								  ),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest(),
+                                    numeric_limits<double>::lowest()
+                                  ),
                                   glm::dmat4x4(
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max(),
-									numeric_limits<double>::max()
-								  ),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max(),
+                                    numeric_limits<double>::max()
+                                  ),
                                   glm::dmat4x4(
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01, 
-									0.01, 0.01, 0.01, 0.01
-								  ),
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01, 
+                                    0.01, 0.01, 0.01, 0.01
+                                  ),
                                   DEFAULT_FROM_LUA_LAMBDA(glm::dmat4x4),
                                   DEFAULT_TO_LUA_LAMBDA(glm::dmat4x4),
                                   DEFAULT_FROM_STRING_LAMBDA(glm::dmat4x4),
diff --git a/src/properties/optionproperty.cpp b/src/properties/optionproperty.cpp
index 1e4c62ccef..388bebe61a 100644
--- a/src/properties/optionproperty.cpp
+++ b/src/properties/optionproperty.cpp
@@ -25,69 +25,69 @@
 #include <openspace/properties/optionproperty.h>
 
 namespace {
-	const std::string _loggerCat = "OptionProperty";
+    const std::string _loggerCat = "OptionProperty";
 }
 
 namespace openspace {
 namespace properties {
-	
+    
 const std::string OptionProperty::OptionsKey = "Options";
 
 OptionProperty::OptionProperty(std::string identifier, std::string guiName)
-	: IntProperty(std::move(identifier), std::move(guiName))
+    : IntProperty(std::move(identifier), std::move(guiName))
 {}
 
 std::string OptionProperty::className() const {
-	return "OptionProperty";
+    return "OptionProperty";
 }
 
 const std::vector<OptionProperty::Option>& OptionProperty::options() const {
-	return _options;
+    return _options;
 }
 
 void OptionProperty::addOption(int value, std::string desc) {
-	Option option;
-	option.value = value;
-	option.description = desc;
+    Option option;
+    option.value = value;
+    option.description = desc;
 
-	for (auto o : _options) {
-		if (o.value == option.value) {
-			LWARNING("The value of option {" << o.value << " -> " << o.description <<
-				"} was already registered when trying to add option {" << option.value <<
-				" -> " << option.description << "}");
-			return;
-		}
-	}
-	_options.push_back(std::move(option));
+    for (auto o : _options) {
+        if (o.value == option.value) {
+            LWARNING("The value of option {" << o.value << " -> " << o.description <<
+                "} was already registered when trying to add option {" << option.value <<
+                " -> " << option.description << "}");
+            return;
+        }
+    }
+    _options.push_back(std::move(option));
 }
 
 void OptionProperty::setValue(int value) {
-	// Check if the passed value belongs to any option
-	for (auto o : _options) {
-		if (o.value == value) {
-			// If it does, set it by calling the superclasses setValue method
-			NumericalProperty::setValue(value);
-			return;
-		}
-	}
+    // Check if the passed value belongs to any option
+    for (auto o : _options) {
+        if (o.value == value) {
+            // If it does, set it by calling the superclasses setValue method
+            NumericalProperty::setValue(value);
+            return;
+        }
+    }
 
-	// Otherwise, log an error
-	LERROR("Could not find an option for value '" << value << "' in OptionProperty");
+    // Otherwise, log an error
+    LERROR("Could not find an option for value '" << value << "' in OptionProperty");
 }
 
 std::string OptionProperty::generateAdditionalDescription() const {
-	// @REFACTOR from selectionproperty.cpp, possible refactoring? ---abock
-	std::string result;
-	result += OptionsKey + " = {";
-	for (size_t i = 0; i < _options.size(); ++i) {
-		const Option& o = _options[i];
-		result += "[\"" + std::to_string(o.value) + "\"] = \"" + o.description + "\"";
-		if (i != _options.size() - 1)
-			result += ",";
-	}
+    // @REFACTOR from selectionproperty.cpp, possible refactoring? ---abock
+    std::string result;
+    result += OptionsKey + " = {";
+    for (size_t i = 0; i < _options.size(); ++i) {
+        const Option& o = _options[i];
+        result += "[\"" + std::to_string(o.value) + "\"] = \"" + o.description + "\"";
+        if (i != _options.size() - 1)
+            result += ",";
+    }
 
-	result += "}";
-	return result;
+    result += "}";
+    return result;
 }
 
 } // namespace properties
diff --git a/src/properties/property.cpp b/src/properties/property.cpp
index 9430d40220..4bf82fd209 100644
--- a/src/properties/property.cpp
+++ b/src/properties/property.cpp
@@ -32,13 +32,13 @@ namespace openspace {
 namespace properties {
 
 namespace {
-	const std::string _loggerCat = "Property";
-	const std::string _metaDataKeyGuiName = "guiName";
+    const std::string _loggerCat = "Property";
+    const std::string _metaDataKeyGuiName = "guiName";
     const std::string _metaDataKeyGroup = "Group";
     const std::string _metaDataKeyVisible = "isVisible";
     const std::string _metaDataKeyReadOnly = "isReadOnly";
 
-	const std::string _metaDataKeyViewPrefix = "view.";
+    const std::string _metaDataKeyViewPrefix = "view.";
 }
 
 const std::string Property::ViewOptions::Color = "color";
@@ -52,16 +52,16 @@ const std::string Property::TypeKey = "Type";
 const std::string Property::MetaDataKey = "MetaData";
 
 Property::Property(std::string identifier, std::string guiName)
-	: _owner(nullptr)
+    : _owner(nullptr)
     , _identifier(std::move(identifier))
 {
-	if (_identifier.empty())
-		LWARNING("Property identifier is empty");
-	if (guiName.empty())
-		LWARNING("Property GUI name is empty");
+    if (_identifier.empty())
+        LWARNING("Property identifier is empty");
+    if (guiName.empty())
+        LWARNING("Property GUI name is empty");
 
     setVisible(true);
-	_metaData.setValue(_metaDataKeyGuiName, std::move(guiName));
+    _metaData.setValue(_metaDataKeyGuiName, std::move(guiName));
 }
 
 Property::~Property() {}
@@ -71,15 +71,15 @@ const std::string& Property::identifier() const {
 }
 
 std::string Property::fullyQualifiedIdentifier() const {
-	std::string identifier = _identifier;
-	PropertyOwner* currentOwner = owner();
-	while (currentOwner) {
-		std::string ownerId = currentOwner->name();
+    std::string identifier = _identifier;
+    PropertyOwner* currentOwner = owner();
+    while (currentOwner) {
+        std::string ownerId = currentOwner->name();
         if (!ownerId.empty())
-		    identifier = ownerId + "." + identifier;
-		currentOwner = currentOwner->owner();
-	}
-	return identifier;
+            identifier = ownerId + "." + identifier;
+        currentOwner = currentOwner->owner();
+    }
+    return identifier;
 }
 
 ghoul::any Property::get() const {
@@ -87,13 +87,13 @@ ghoul::any Property::get() const {
 }
 
 bool Property::getLuaValue(lua_State* state) const {
-	return false;
+    return false;
 }
 
 void Property::set(ghoul::any value) {}
 
 bool Property::setLuaValue(lua_State* state) {
-	return false;
+    return false;
 }
 
 const std::type_info& Property::type() const {
@@ -101,7 +101,7 @@ const std::type_info& Property::type() const {
 }
 
 int Property::typeLua() const {
-	return LUA_TNIL;
+    return LUA_TNIL;
 }
 
 bool Property::getStringValue(std::string& value) const {
@@ -113,13 +113,13 @@ bool Property::setStringValue(std::string value) {
 }
 
 std::string Property::guiName() const {
-	std::string result;
-	_metaData.getValue(_metaDataKeyGuiName, result);
+    std::string result;
+    _metaData.getValue(_metaDataKeyGuiName, result);
     return result;
 }
 
 std::string Property::description() const {
-	return "return {" + generateBaseDescription() + "}";
+    return "return {" + generateBaseDescription() + "}";
 }
 
 void Property::setGroupIdentifier(std::string groupId) {
@@ -127,8 +127,8 @@ void Property::setGroupIdentifier(std::string groupId) {
 }
 
 std::string Property::groupIdentifier() const {
-	std::string result;
-	_metaData.getValue(_metaDataKeyGroup, result);
+    std::string result;
+    _metaData.getValue(_metaDataKeyGroup, result);
     return result;
 }
 
@@ -167,33 +167,33 @@ void Property::setPropertyOwner(PropertyOwner* owner)
 }
 
 void Property::notifyListener() {
-	if (_onChangeCallback)
-		_onChangeCallback();
+    if (_onChangeCallback)
+        _onChangeCallback();
 }
 
 std::string Property::generateBaseDescription() const {
-	return
-		TypeKey + " = \"" + className() + "\", " +
-		IdentifierKey + " = \"" + fullyQualifiedIdentifier() + "\", " +
-		NameKey + " = \"" + guiName() + "\", " +
-		generateMetaDataDescription() + ", " + 
-		generateAdditionalDescription();
+    return
+        TypeKey + " = \"" + className() + "\", " +
+        IdentifierKey + " = \"" + fullyQualifiedIdentifier() + "\", " +
+        NameKey + " = \"" + guiName() + "\", " +
+        generateMetaDataDescription() + ", " + 
+        generateAdditionalDescription();
 }
 
 std::string Property::generateMetaDataDescription() const {
-	bool isVisible, isReadOnly;
-	_metaData.getValue(_metaDataKeyVisible, isVisible);
-	_metaData.getValue(_metaDataKeyReadOnly, isReadOnly);
+    bool isVisible, isReadOnly;
+    _metaData.getValue(_metaDataKeyVisible, isVisible);
+    _metaData.getValue(_metaDataKeyReadOnly, isReadOnly);
 
-	return
-		MetaDataKey + " = {" +
-			_metaDataKeyGroup +   " = '" + groupIdentifier() + "'," +
-			_metaDataKeyVisible + " = " + (isVisible  ? "true" : "false") + "," +
-			_metaDataKeyReadOnly +" = " + (isReadOnly ? "true" : "false") + "}";
+    return
+        MetaDataKey + " = {" +
+            _metaDataKeyGroup +   " = '" + groupIdentifier() + "'," +
+            _metaDataKeyVisible + " = " + (isVisible  ? "true" : "false") + "," +
+            _metaDataKeyReadOnly +" = " + (isReadOnly ? "true" : "false") + "}";
 }
 
 std::string Property::generateAdditionalDescription() const {
-	return "";
+    return "";
 }
 
 } // namespace properties
diff --git a/src/properties/propertyowner.cpp b/src/properties/propertyowner.cpp
index 50845eba59..eea4579470 100644
--- a/src/properties/propertyowner.cpp
+++ b/src/properties/propertyowner.cpp
@@ -48,13 +48,13 @@ bool subOwnerLess(PropertyOwner* lhs, PropertyOwner* rhs) {
 
 PropertyOwner::PropertyOwner()
     : _name("")
-	, _owner(nullptr)
+    , _owner(nullptr)
 {
 }
 
 PropertyOwner::~PropertyOwner() {
-	_properties.clear();
-	_subOwners.clear();
+    _properties.clear();
+    _subOwners.clear();
 }
 
 const std::vector<Property*>& PropertyOwner::properties() const {
@@ -62,20 +62,20 @@ const std::vector<Property*>& PropertyOwner::properties() const {
 }
 
 std::vector<Property*> PropertyOwner::propertiesRecursive() const {
-	std::vector<Property*> props = properties();
+    std::vector<Property*> props = properties();
 
-	for (const PropertyOwner* owner : _subOwners) {
-		std::vector<Property*> p = owner->propertiesRecursive();
-		props.insert(props.end(), p.begin(), p.end());
-	}
+    for (const PropertyOwner* owner : _subOwners) {
+        std::vector<Property*> p = owner->propertiesRecursive();
+        props.insert(props.end(), p.begin(), p.end());
+    }
 
-	return props;
+    return props;
 }
 
 Property* PropertyOwner::property(const std::string& id) const {
     assert(std::is_sorted(_properties.begin(), _properties.end(), propertyLess));
 
-	// As the _properties list is sorted, just finding the lower bound is sufficient
+    // As the _properties list is sorted, just finding the lower bound is sufficient
     std::vector<Property*>::const_iterator it
           = std::lower_bound(_properties.begin(), _properties.end(), id,
                              [](Property* prop, const std::string& str) {
@@ -119,7 +119,7 @@ const std::vector<PropertyOwner*>& PropertyOwner::propertySubOwners() const {
 PropertyOwner* PropertyOwner::propertySubOwner(const std::string& name) const {
     assert(std::is_sorted(_subOwners.begin(), _subOwners.end(), subOwnerLess));
     
-	// As the _subOwners list is sorted, getting the lower bound is sufficient
+    // As the _subOwners list is sorted, getting the lower bound is sufficient
     std::vector<PropertyOwner*>::const_iterator it
     = std::lower_bound(_subOwners.begin(), _subOwners.end(), name,
                        [](PropertyOwner* owner, const std::string& str) {
@@ -152,7 +152,7 @@ void PropertyOwner::addProperty(Property* prop)
 {
     assert(prop != nullptr);
     assert(std::is_sorted(_properties.begin(), _properties.end(), propertyLess));
-	assert(std::is_sorted(_subOwners.begin(), _subOwners.end(), subOwnerLess));
+    assert(std::is_sorted(_subOwners.begin(), _subOwners.end(), subOwnerLess));
 
     if (prop->identifier().empty()) {
         LERROR("No property identifier specified");
@@ -160,7 +160,7 @@ void PropertyOwner::addProperty(Property* prop)
     }
 
     // See if we can find the identifier of the property to add in the properties list
-	// The _properties list is sorted, so getting the lower bound is sufficient
+    // The _properties list is sorted, so getting the lower bound is sufficient
     std::vector<Property*>::iterator it
           = std::lower_bound(_properties.begin(), _properties.end(), prop->identifier(),
                              [](Property* prop, const std::string& str) {
@@ -175,17 +175,17 @@ void PropertyOwner::addProperty(Property* prop)
         return;
     } else {
         // Otherwise we still have to look if there is a PropertyOwner with the same name
-		const bool hasOwner = hasPropertySubOwner(prop->identifier());
-		if (hasOwner) {
-			LERROR("Property identifier '" << prop->identifier() << "' already names a"
-				<< "registed PropertyOwner");
-			return;
-		}					
-		else {
-			// now have found the correct position to add it in
-			_properties.insert(it, prop);
-			prop->setPropertyOwner(this);
-		}
+        const bool hasOwner = hasPropertySubOwner(prop->identifier());
+        if (hasOwner) {
+            LERROR("Property identifier '" << prop->identifier() << "' already names a"
+                << "registed PropertyOwner");
+            return;
+        }                    
+        else {
+            // now have found the correct position to add it in
+            _properties.insert(it, prop);
+            prop->setPropertyOwner(this);
+        }
     }
 }
 
@@ -195,7 +195,7 @@ void PropertyOwner::addProperty(Property& prop) {
     
 void PropertyOwner::addPropertySubOwner(openspace::properties::PropertyOwner* owner) {
     assert(owner != nullptr);
-	assert(std::is_sorted(_properties.begin(), _properties.end(), propertyLess));
+    assert(std::is_sorted(_properties.begin(), _properties.end(), propertyLess));
     assert(std::is_sorted(_subOwners.begin(), _subOwners.end(), subOwnerLess));
     
     if (owner->name().empty()) {
@@ -216,18 +216,18 @@ void PropertyOwner::addPropertySubOwner(openspace::properties::PropertyOwner* ow
                << "' already present in PropertyOwner '" << name() << "'");
         return;
     } else {
-		// We still need to check if the PropertyOwners name is used in a Property
-		const bool hasProp = hasProperty(owner->name());
-		if (hasProp) {
-			LERROR("PropertyOwner '" << owner->name() << "'s name already names a "
-				 << "Property");
-			return;
-		}
-		else {
-			// Otherwise we have found the correct position to add it in
-			_subOwners.insert(it, owner);
-			owner->setPropertyOwner(this);
-		}
+        // We still need to check if the PropertyOwners name is used in a Property
+        const bool hasProp = hasProperty(owner->name());
+        if (hasProp) {
+            LERROR("PropertyOwner '" << owner->name() << "'s name already names a "
+                 << "Property");
+            return;
+        }
+        else {
+            // Otherwise we have found the correct position to add it in
+            _subOwners.insert(it, owner);
+            owner->setPropertyOwner(this);
+        }
     }
     
 }
diff --git a/src/properties/scalarproperty.cpp b/src/properties/scalarproperty.cpp
index 20b05115d2..d21ba5b5b6 100644
--- a/src/properties/scalarproperty.cpp
+++ b/src/properties/scalarproperty.cpp
@@ -35,19 +35,19 @@ namespace openspace {
 namespace properties {
 
 #define DEFAULT_FROM_LUA_LAMBDA(TYPE, DEFAULT_VALUE)                                     \
-	[](lua_State* state, bool& success) -> TYPE {                                        \
-		success = (lua_isnumber(state, -1) == 1);                                        \
-		if (success)                                                                     \
-			return static_cast<TYPE>(lua_tonumber(state, -1));                           \
-		else                                                                             \
-			return DEFAULT_VALUE;                                                        \
-	}
+    [](lua_State* state, bool& success) -> TYPE {                                        \
+        success = (lua_isnumber(state, -1) == 1);                                        \
+        if (success)                                                                     \
+            return static_cast<TYPE>(lua_tonumber(state, -1));                           \
+        else                                                                             \
+            return DEFAULT_VALUE;                                                        \
+    }
 
 #define DEFAULT_TO_LUA_LAMBDA(TYPE)                                                      \
-	[](lua_State* state, TYPE value) -> bool {                                           \
-		lua_pushnumber(state, static_cast<lua_Number>(value));                           \
-		return true;                                                                     \
-	}
+    [](lua_State* state, TYPE value) -> bool {                                           \
+        lua_pushnumber(state, static_cast<lua_Number>(value));                           \
+        return true;                                                                     \
+    }
 
 #define DEFAULT_FROM_STRING_LAMBDA(TYPE, DEFAULT_VALUE)                                  \
     [](std::string value, bool& success) -> TYPE {                                       \
@@ -69,24 +69,24 @@ namespace properties {
 // be equal to unsigned short and unsigned int which causes a compile error
 
 REGISTER_TEMPLATEPROPERTY_SOURCE(BoolProperty, bool, false, 
-	[](lua_State* state, bool& success) -> bool {
-		success = (lua_isboolean(state, -1) == 1);
-		if (success)
-			return lua_toboolean(state, -1) == 1;
-		else
-			return false;
-	},
-	[](lua_State* state, bool value) -> bool {
-		lua_pushboolean(state, value);
-		return true;
-	},
+    [](lua_State* state, bool& success) -> bool {
+        success = (lua_isboolean(state, -1) == 1);
+        if (success)
+            return lua_toboolean(state, -1) == 1;
+        else
+            return false;
+    },
+    [](lua_State* state, bool value) -> bool {
+        lua_pushboolean(state, value);
+        return true;
+    },
     DEFAULT_FROM_STRING_LAMBDA(bool, false),
                                  [](std::string& outValue, bool inValue) -> bool {
                                      outValue = inValue ? "true" : "false";
                                      return true;
                                  },
-	LUA_TBOOLEAN
-	);
+    LUA_TBOOLEAN
+    );
 
 REGISTER_NUMERICALPROPERTY_SOURCE(CharProperty, char, char(0),
                                   numeric_limits<char>::lowest(),
diff --git a/src/properties/selectionproperty.cpp b/src/properties/selectionproperty.cpp
index 5b4172b815..9a0e9971b7 100644
--- a/src/properties/selectionproperty.cpp
+++ b/src/properties/selectionproperty.cpp
@@ -25,7 +25,7 @@
 #include <openspace/properties/selectionproperty.h>
 
 namespace {
-	const std::string _loggerCat = "SelectionProperty";
+    const std::string _loggerCat = "SelectionProperty";
 
     const std::string Delimiter = ",";
 }
@@ -36,79 +36,79 @@ namespace properties {
 const std::string SelectionProperty::OptionsKey = "Options";
 
 SelectionProperty::SelectionProperty(std::string identifier, std::string guiName)
-	: TemplateProperty(std::move(identifier), std::move(guiName), std::vector<int>())
+    : TemplateProperty(std::move(identifier), std::move(guiName), std::vector<int>())
 {}
 
 void SelectionProperty::addOption(Option option) {
-	// @REFACTOR from optionproperty.cpp, possible refactoring? ---abock
-	for (const Option& o : _options) {
-		if (o.value == option.value) {
-			LWARNING("The value of option {" << o.value << " -> " << o.description <<
-				"} was already registered when trying to add option {" << option.value <<
-				" -> " << option.description << "}");
-			return;
-		}
-	}
-	_options.push_back(std::move(option));
+    // @REFACTOR from optionproperty.cpp, possible refactoring? ---abock
+    for (const Option& o : _options) {
+        if (o.value == option.value) {
+            LWARNING("The value of option {" << o.value << " -> " << o.description <<
+                "} was already registered when trying to add option {" << option.value <<
+                " -> " << option.description << "}");
+            return;
+        }
+    }
+    _options.push_back(std::move(option));
 }
 
 const std::vector<SelectionProperty::Option>& SelectionProperty::options() const {
-	return _options;
+    return _options;
 }
 
 template <>
 std::string PropertyDelegate<TemplateProperty<std::vector<int>>>::className() {
-	return "SelectionProperty";
+    return "SelectionProperty";
 }
 
 template <>
 template <>
 std::vector<int> PropertyDelegate<TemplateProperty<std::vector<int>>>::fromLuaValue(lua_State* state, bool& success) {
-	static const int KEY = -2;
-	static const int VAL = -1;
+    static const int KEY = -2;
+    static const int VAL = -1;
 
-	std::vector<int> result;
+    std::vector<int> result;
 
-	if (!lua_istable(state, VAL)) {
-		LERROR("Parameter passed to the property is not a table");
-		success = false;
-		return result;
-	}
+    if (!lua_istable(state, VAL)) {
+        LERROR("Parameter passed to the property is not a table");
+        success = false;
+        return result;
+    }
 
-	lua_pushnil(state);
-	while (lua_next(state, KEY) != 0) {
-		if (lua_isnumber(state, VAL)) {
-			int number = static_cast<int>(lua_tonumber(state, VAL));
-			result.push_back(number);
-		}
-		else {
-			success = false;
-			return std::vector<int>();
-		}
+    lua_pushnil(state);
+    while (lua_next(state, KEY) != 0) {
+        if (lua_isnumber(state, VAL)) {
+            int number = static_cast<int>(lua_tonumber(state, VAL));
+            result.push_back(number);
+        }
+        else {
+            success = false;
+            return std::vector<int>();
+        }
 
-		lua_pop(state, 1);
-	}
+        lua_pop(state, 1);
+    }
 
-	success = true;
-	return result;
+    success = true;
+    return result;
 }
 
 template <>
 template <>
 bool PropertyDelegate<TemplateProperty<std::vector<int>>>::toLuaValue(lua_State* state, std::vector<int> value) {
-	//@NOTE Untested ---abock
-	lua_newtable(state);
-	for (int i = 0; i < value.size(); ++i) {
-		int v = value[i];
-		lua_pushinteger(state, v);
-		lua_setfield(state, -2, std::to_string(i).c_str());
-	}
-	return true;
+    //@NOTE Untested ---abock
+    lua_newtable(state);
+    for (int i = 0; i < value.size(); ++i) {
+        int v = value[i];
+        lua_pushinteger(state, v);
+        lua_setfield(state, -2, std::to_string(i).c_str());
+    }
+    return true;
 }
 
 template <>
 int PropertyDelegate<TemplateProperty<std::vector<int>>>::typeLua() {
-	return LUA_TTABLE;
+    return LUA_TTABLE;
 }
 
 template <>
@@ -135,17 +135,17 @@ bool PropertyDelegate<TemplateProperty<std::vector<int>>>::toString(std::string&
 }
 
 std::string SelectionProperty::generateAdditionalDescription() const {
-	std::string result;
-	result += OptionsKey + " = {";
-	for (size_t i = 0; i < _options.size(); ++i) {
-		const Option& o = _options[i];
-		result += "[\"" + std::to_string(o.value) + "\"] = \"" + o.description + "\"";
-		if (i != _options.size() - 1)
-			result += ",";
-	}
+    std::string result;
+    result += OptionsKey + " = {";
+    for (size_t i = 0; i < _options.size(); ++i) {
+        const Option& o = _options[i];
+        result += "[\"" + std::to_string(o.value) + "\"] = \"" + o.description + "\"";
+        if (i != _options.size() - 1)
+            result += ",";
+    }
 
-	result += "}";
-	return result;
+    result += "}";
+    return result;
 }
 
 } // namespace properties
diff --git a/src/properties/stringproperty.cpp b/src/properties/stringproperty.cpp
index 948a132dfd..125469beec 100644
--- a/src/properties/stringproperty.cpp
+++ b/src/properties/stringproperty.cpp
@@ -31,16 +31,16 @@ namespace properties {
 
 REGISTER_TEMPLATEPROPERTY_SOURCE(StringProperty, std::string, "",
 [](lua_State* state, bool& success) -> std::string {
-		success = lua_isstring(state, -1) == 1;
-		if (success)
-			return lua_tostring(state, -1);
-		else
-			return "";
-	},
+        success = lua_isstring(state, -1) == 1;
+        if (success)
+            return lua_tostring(state, -1);
+        else
+            return "";
+    },
 [](lua_State* state, std::string value) -> bool {
-		lua_pushstring(state, value.c_str());
-		return true;
-	},
+        lua_pushstring(state, value.c_str());
+        return true;
+    },
 [](std::string value, bool& success) -> std::string {
     // An incoming string is of the form
     // "value"
diff --git a/src/properties/triggerproperty.cpp b/src/properties/triggerproperty.cpp
index a9b7c4e03d..e0f024f522 100644
--- a/src/properties/triggerproperty.cpp
+++ b/src/properties/triggerproperty.cpp
@@ -28,20 +28,20 @@ namespace openspace {
 namespace properties {
 
 TriggerProperty::TriggerProperty(std::string identifier, std::string guiName)
-	: Property(std::move(identifier), std::move(guiName))
+    : Property(std::move(identifier), std::move(guiName))
 {}
 
 std::string TriggerProperty::className() const {
-	return "TriggerProperty";
+    return "TriggerProperty";
 }
 
 bool TriggerProperty::setLuaValue(lua_State* state) {
-	notifyListener();
-	return true;
+    notifyListener();
+    return true;
 }
 
 void TriggerProperty::set(ghoul::any value) {
-	notifyListener();
+    notifyListener();
 }
 
 } // namespace properties
diff --git a/src/properties/vectorproperty.cpp b/src/properties/vectorproperty.cpp
index 90de82180b..22ce875f6b 100644
--- a/src/properties/vectorproperty.cpp
+++ b/src/properties/vectorproperty.cpp
@@ -45,12 +45,12 @@ namespace properties {
                 success = false;                                                         \
                 return __TYPE__(0);                                                      \
             }                                                                            \
-			if (__TESTFUNC__(state, -1) != 1) {                                          \
+            if (__TESTFUNC__(state, -1) != 1) {                                          \
                 success = false;                                                         \
                 return __TYPE__(0);                                                      \
             } else {                                                                     \
-				result[i] = static_cast<__TYPE__::value_type>(__CONVFUNC__(state, -1));  \
-				lua_pop(state, 1);                                                       \
+                result[i] = static_cast<__TYPE__::value_type>(__CONVFUNC__(state, -1));  \
+                lua_pop(state, 1);                                                       \
             }                                                                            \
         }                                                                                \
         success = true;                                                                  \
@@ -110,8 +110,8 @@ namespace properties {
 
 
 REGISTER_TEMPLATEPROPERTY_SOURCE(BVec2Property, glm::bvec2, glm::bvec2(false),
-								 DEFAULT_FROM_LUA_LAMBDA(glm::bvec2, lua_toboolean,
-														 lua_isboolean),
+                                 DEFAULT_FROM_LUA_LAMBDA(glm::bvec2, lua_toboolean,
+                                                         lua_isboolean),
                                  DEFAULT_TO_LUA_LAMBDA(glm::bvec2),
                                  DEFAULT_FROM_STRING_LAMBDA(glm::bvec2),
                                  DEFAULT_TO_STRING_LAMBDA(glm::bvec2),
diff --git a/src/query/query.cpp b/src/query/query.cpp
index 73f22baa9e..7f1de11750 100644
--- a/src/query/query.cpp
+++ b/src/query/query.cpp
@@ -47,8 +47,8 @@ SceneGraphNode* sceneGraphNode(const std::string& name) {
 }
 
 Renderable* renderable(const std::string& name) {
-	SceneGraphNode* node = sceneGraphNode(name);
-	return node->renderable();
+    SceneGraphNode* node = sceneGraphNode(name);
+    return node->renderable();
 }
 
 properties::Property* property(const std::string& uri) {
diff --git a/src/rendering/abufferrenderer.cpp b/src/rendering/abufferrenderer.cpp
index 0d0dd27d45..5be6bb75b1 100644
--- a/src/rendering/abufferrenderer.cpp
+++ b/src/rendering/abufferrenderer.cpp
@@ -42,7 +42,7 @@
 #include <iterator>
 
 namespace {
-	const std::string _loggerCat = "ABufferRenderer";
+    const std::string _loggerCat = "ABufferRenderer";
     const std::string BoundsFragmentShaderPath = "${SHADERS}/abuffer/boundsabuffer.frag";
     const std::string RenderFragmentShaderPath = "${SHADERS}/abuffer/renderabuffer.frag";
     const int MaxRaycasters = 32;
@@ -70,13 +70,13 @@ void ABufferRenderer::initialize() {
     LINFO("Initializing ABufferRenderer");
     const GLfloat size = 1.0f;
     const GLfloat vertex_data[] = {
-        //	  x      y     s     t
+        //      x      y     s     t
         -size, -size, 0.0f, 1.0f,
-        size,	size, 0.0f, 1.0f, 
+        size,    size, 0.0f, 1.0f, 
         -size,  size, 0.0f, 1.0f, 
         -size, -size, 0.0f, 1.0f, 
         size, -size, 0.0f, 1.0f, 
-        size,	size, 0.0f, 1.0f,
+        size,    size, 0.0f, 1.0f,
     };
 
 
@@ -90,12 +90,12 @@ void ABufferRenderer::initialize() {
     glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, reinterpret_cast<void*>(0));
     glEnableVertexAttribArray(0);
 
-	glGenTextures(1, &_anchorPointerTexture);
-	glGenBuffers(1, &_anchorPointerTextureInitializer);
-	glGenBuffers(1, &_atomicCounterBuffer);
-	glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, _atomicCounterBuffer);
-	glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_DYNAMIC_COPY);
-	glGenBuffers(1, &_fragmentBuffer);
+    glGenTextures(1, &_anchorPointerTexture);
+    glGenBuffers(1, &_anchorPointerTextureInitializer);
+    glGenBuffers(1, &_atomicCounterBuffer);
+    glBindBuffer(GL_ATOMIC_COUNTER_BUFFER, _atomicCounterBuffer);
+    glBufferData(GL_ATOMIC_COUNTER_BUFFER, sizeof(GLuint), NULL, GL_DYNAMIC_COPY);
+    glGenBuffers(1, &_fragmentBuffer);
     glGenTextures(1, &_fragmentTexture);
     
     _nAaSamples = OsEng.windowWrapper().currentNumberOfAaSamples();
@@ -126,12 +126,12 @@ void ABufferRenderer::initialize() {
     
 void ABufferRenderer::deinitialize() {
     LINFO("Deinitializing ABufferRenderer");
-	glDeleteBuffers(1, &_fragmentBuffer);
+    glDeleteBuffers(1, &_fragmentBuffer);
     glDeleteTextures(1, &_fragmentTexture);
 
-	glDeleteTextures(1, &_anchorPointerTexture);
-	glDeleteBuffers(1, &_anchorPointerTextureInitializer);
-	glDeleteBuffers(1, &_atomicCounterBuffer);
+    glDeleteTextures(1, &_anchorPointerTexture);
+    glDeleteBuffers(1, &_anchorPointerTextureInitializer);
+    glDeleteBuffers(1, &_atomicCounterBuffer);
 
     glDeleteBuffers(1, &_vertexPositionBuffer);
     glDeleteVertexArrays(1, &_screenQuad);
@@ -283,42 +283,42 @@ void ABufferRenderer::setResolution(glm::ivec2 res) {
 }
 
 void ABufferRenderer::clear() {
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
-	glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
+    glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
 
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-	static const GLuint zero = 1;
-	glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, _atomicCounterBuffer);
-	glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(zero), &zero);
-	glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, 0);
+    static const GLuint zero = 1;
+    glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, _atomicCounterBuffer);
+    glBufferSubData(GL_ATOMIC_COUNTER_BUFFER, 0, sizeof(zero), &zero);
+    glBindBufferBase(GL_ATOMIC_COUNTER_BUFFER, 0, 0);
 }
 
 void ABufferRenderer::updateResolution() {
     int totalPixels = _resolution.x * _resolution.y;
-	glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
+    glBindTexture(GL_TEXTURE_2D, _anchorPointerTexture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, _resolution.x, _resolution.y, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
 
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, _anchorPointerTextureInitializer);
     glBufferData(GL_PIXEL_UNPACK_BUFFER, totalPixels * sizeof(GLuint), NULL, GL_STATIC_DRAW);
 
-	GLuint* data = (GLuint*)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
-	memset(data, 0x00, totalPixels * sizeof(GLuint));
-	glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
-	glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+    GLuint* data = (GLuint*)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
+    memset(data, 0x00, totalPixels * sizeof(GLuint));
+    glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+    glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
 
-	glBindBuffer(GL_TEXTURE_BUFFER, _fragmentBuffer);
-	glBufferData(GL_TEXTURE_BUFFER, MaxAverageLayers*totalPixels*sizeof(GLuint) * 4, NULL, GL_DYNAMIC_COPY);
+    glBindBuffer(GL_TEXTURE_BUFFER, _fragmentBuffer);
+    glBufferData(GL_TEXTURE_BUFFER, MaxAverageLayers*totalPixels*sizeof(GLuint) * 4, NULL, GL_DYNAMIC_COPY);
 
-	glBindTexture(GL_TEXTURE_BUFFER, _fragmentTexture);
-	glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, _fragmentBuffer);
-	glBindTexture(GL_TEXTURE_BUFFER, 0);
+    glBindTexture(GL_TEXTURE_BUFFER, _fragmentTexture);
+    glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32UI, _fragmentBuffer);
+    glBindTexture(GL_TEXTURE_BUFFER, 0);
 
-	glBindImageTexture(1, _fragmentTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32UI);
+    glBindImageTexture(1, _fragmentTexture, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA32UI);
 
     
     _dirtyResolution = false;
diff --git a/src/rendering/framebufferrenderer.cpp b/src/rendering/framebufferrenderer.cpp
index 00f6a4723a..b2e6d7f809 100644
--- a/src/rendering/framebufferrenderer.cpp
+++ b/src/rendering/framebufferrenderer.cpp
@@ -40,7 +40,7 @@
 #include <ghoul/opengl/programobject.h>
 
 namespace {
-	const std::string _loggerCat = "FramebufferRenderer";
+    const std::string _loggerCat = "FramebufferRenderer";
     const std::string ExitFragmentShaderPath = "${SHADERS}/framebuffer/exitframebuffer.frag";
     const std::string RaycastFragmentShaderPath = "${SHADERS}/framebuffer/raycastframebuffer.frag";
     const std::string RenderFragmentShaderPath = "${SHADERS}/framebuffer/renderframebuffer.frag";
@@ -61,13 +61,13 @@ void FramebufferRenderer::initialize() {
 
     const GLfloat size = 1.0f;
     const GLfloat vertex_data[] = {
-        //	  x      y     s     t
+        //      x      y     s     t
         -size, -size, 0.0f, 1.0f,
-        size,	size, 0.0f, 1.0f,
+        size,    size, 0.0f, 1.0f,
         -size,  size, 0.0f, 1.0f,
         -size, -size, 0.0f, 1.0f,
         size, -size, 0.0f, 1.0f,
-        size,	size, 0.0f, 1.0f
+        size,    size, 0.0f, 1.0f
     };
     
     glGenVertexArrays(1, &_screenQuad);
@@ -80,13 +80,13 @@ void FramebufferRenderer::initialize() {
     glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, reinterpret_cast<void*>(0));
     glEnableVertexAttribArray(0);
 
-	GLint defaultFbo;
-	glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo);
+    GLint defaultFbo;
+    glGetIntegerv(GL_FRAMEBUFFER_BINDING, &defaultFbo);
 
     // Main framebuffer
     glGenTextures(1, &_mainColorTexture);
     glGenTextures(1, &_mainDepthTexture);
-	glGenFramebuffers(1, &_mainFramebuffer);
+    glGenFramebuffers(1, &_mainFramebuffer);
 
     // Exit framebuffer
     glGenTextures(1, &_exitColorTexture);
diff --git a/src/rendering/raycastermanager.cpp b/src/rendering/raycastermanager.cpp
index 19e8572097..0b0f65ef71 100644
--- a/src/rendering/raycastermanager.cpp
+++ b/src/rendering/raycastermanager.cpp
@@ -28,7 +28,7 @@
 #include <string>
 
 namespace {
-	const std::string _loggerCat = "RaycasterManager";
+    const std::string _loggerCat = "RaycasterManager";
 }
 
 namespace openspace {
diff --git a/src/rendering/renderable.cpp b/src/rendering/renderable.cpp
index 812625b755..11ee989c06 100644
--- a/src/rendering/renderable.cpp
+++ b/src/rendering/renderable.cpp
@@ -46,17 +46,17 @@ namespace {
 namespace openspace {
 
 Renderable* Renderable::createFromDictionary(const ghoul::Dictionary& dictionary) {
-	// The name is passed down from the SceneGraphNode
+    // The name is passed down from the SceneGraphNode
     std::string name;
     bool success = dictionary.getValue(SceneGraphNode::KeyName, name);
-	assert(success);
+    assert(success);
 
     std::string renderableType;
     success = dictionary.getValue(KeyType, renderableType);
-	if (!success) {
+    if (!success) {
         LERROR("Renderable '" << name << "' did not have key '" << KeyType << "'");
         return nullptr;
-	}
+    }
 
     ghoul::TemplateFactory<Renderable>* factory
           = FactoryManager::ref().factory<Renderable>();
@@ -70,7 +70,7 @@ Renderable* Renderable::createFromDictionary(const ghoul::Dictionary& dictionary
 }
 
 Renderable::Renderable(const ghoul::Dictionary& dictionary)
-	: _enabled("enabled", "Is Enabled", true)
+    : _enabled("enabled", "Is Enabled", true)
     , _startTime("")
     , _endTime("")
     , _targetBody("")
@@ -79,19 +79,19 @@ Renderable::Renderable(const ghoul::Dictionary& dictionary)
 {
     setName("renderable");
 #ifndef NDEBUG
-	std::string name;
-	ghoul_assert(dictionary.getValue(SceneGraphNode::KeyName, name),
+    std::string name;
+    ghoul_assert(dictionary.getValue(SceneGraphNode::KeyName, name),
                  "Scenegraphnode need to specify '" << SceneGraphNode::KeyName
-		<< "' because renderables is going to use this for debugging!");
+        << "' because renderables is going to use this for debugging!");
 #endif
 
-	dictionary.getValue(keyStart, _startTime);
-	dictionary.getValue(keyEnd, _endTime);
+    dictionary.getValue(keyStart, _startTime);
+    dictionary.getValue(keyEnd, _endTime);
 
-	if (_startTime != "" && _endTime != "")
-		_hasTimeInterval = true;
+    if (_startTime != "" && _endTime != "")
+        _hasTimeInterval = true;
 
-	addProperty(_enabled);
+    addProperty(_enabled);
 }
 
 Renderable::~Renderable() {
@@ -122,58 +122,58 @@ void Renderable::render(const RenderData& data)
 }
 
 void Renderable::setPscUniforms(
-	ghoul::opengl::ProgramObject& program, 
-	const Camera& camera,
-	const PowerScaledCoordinate& position) 
+    ghoul::opengl::ProgramObject& program, 
+    const Camera& camera,
+    const PowerScaledCoordinate& position) 
 {
-	program.setUniform("campos", camera.position().vec4());
-	program.setUniform("objpos", position.vec4());
-	program.setUniform("camrot", camera.viewRotationMatrix());
-	program.setUniform("scaling", camera.scaling());
+    program.setUniform("campos", camera.position().vec4());
+    program.setUniform("objpos", position.vec4());
+    program.setUniform("camrot", camera.viewRotationMatrix());
+    program.setUniform("scaling", camera.scaling());
 }
 
 bool Renderable::isVisible() const {
-	return _enabled;
+    return _enabled;
 }
 
 bool Renderable::hasTimeInterval() {
-	return _hasTimeInterval;
+    return _hasTimeInterval;
 }
 
 bool Renderable::hasBody() {
-	return _hasBody;
+    return _hasBody;
 }
 
 bool Renderable::getInterval(double& start, double& end) {
-	if (_startTime != "" && _endTime != "") {
+    if (_startTime != "" && _endTime != "") {
         start = SpiceManager::ref().ephemerisTimeFromDate(_startTime);
         end = SpiceManager::ref().ephemerisTimeFromDate(_endTime);
         return true;
-	}
-	else
-		return false;
+    }
+    else
+        return false;
 }
 
 bool Renderable::getBody(std::string& body) {
-	if (_hasBody) {
-		body = _targetBody;
-		return true;
-	}
-	else
-		return false;
+    if (_hasBody) {
+        body = _targetBody;
+        return true;
+    }
+    else
+        return false;
 }
 
 void Renderable::setBody(std::string& body) {
-	_targetBody = body;
-	_hasBody = true;
+    _targetBody = body;
+    _hasBody = true;
 }
 
 bool Renderable::isReady() const {
-	return true;
+    return true;
 }
 
 bool Renderable::isEnabled() const {
-	return _enabled;
+    return _enabled;
 }
 
 void Renderable::onEnabledChange(std::function<void(bool)> callback) {
diff --git a/src/rendering/renderengine.cpp b/src/rendering/renderengine.cpp
index c14dbe8565..f7249dd8fd 100644
--- a/src/rendering/renderengine.cpp
+++ b/src/rendering/renderengine.cpp
@@ -214,7 +214,7 @@ bool RenderEngine::initialize() {
 
 bool RenderEngine::initializeGL() {
     // TODO:    Fix the power scaled coordinates in such a way that these 
-    //			values can be set to more realistic values
+    //            values can be set to more realistic values
 
     // set the close clip plane and the far clip plane to extreme values while in
     // development
@@ -240,7 +240,7 @@ bool RenderEngine::initializeGL() {
     // ---abock
     
     
-//	sgct::Engine::instance()->setNearAndFarClippingPlanes(0.001f, 1000.0f);
+//    sgct::Engine::instance()->setNearAndFarClippingPlanes(0.001f, 1000.0f);
     // sgct::Engine::instance()->setNearAndFarClippingPlanes(0.1f, 30.0f);
 
     // calculating the maximum field of view for the camera, used to
@@ -274,7 +274,7 @@ bool RenderEngine::initializeGL() {
   //      corners[3] = glm::vec3(corners[2][0], corners[0][1], corners[2][2]);
   //       
   //      const glm::vec3 center = (corners[0] + corners[1] + corners[2] + corners[3]);
-        ////	
+        ////    
         //const glm::vec3 eyePosition = sgct_core::ClusterManager::instance()->getDefaultUserPtr()->getPos();
         ////// get viewdirection, stores the direction in the camera, used for culling
         //const glm::vec3 viewdir = glm::normalize(eyePosition - center);
@@ -293,15 +293,15 @@ bool RenderEngine::initializeGL() {
 
         //// for each corner
         //for (int i = 0; i < 4; ++i) {
-        //	// calculate radians to corner
-        //	glm::vec3 dir = glm::normalize(eyePosition - corners[i]);
-        //	float radsbetween = acos(glm::dot(viewdir, dir))
-        //		/ (glm::length(viewdir) * glm::length(dir));
+        //    // calculate radians to corner
+        //    glm::vec3 dir = glm::normalize(eyePosition - corners[i]);
+        //    float radsbetween = acos(glm::dot(viewdir, dir))
+        //        / (glm::length(viewdir) * glm::length(dir));
 
-        //	// the angle to a corner is larger than the current maxima
-        //	if (radsbetween > maxFov) {
-        //		maxFov = radsbetween;
-        //	}
+        //    // the angle to a corner is larger than the current maxima
+        //    if (radsbetween > maxFov) {
+        //        maxFov = radsbetween;
+        //    }
         //}
         _mainCamera->setMaxFov(maxFov);
     //}
@@ -817,23 +817,23 @@ void RenderEngine::changeViewPoint(std::string origin) {
         //
         //ghoul::Dictionary vestaDictionary =
         //{
-        //	  { std::string("Type"), std::string("Spice") },
-        //	  { std::string("Body"), std::string("VESTA") },
-        //	  { std::string("Reference"), std::string("GALACTIC") },
-        //	  { std::string("Observer"), std::string("PLUTO BARYCENTER") },
-        //	  { std::string("Kernels"), ghoul::Dictionary() }
+        //      { std::string("Type"), std::string("Spice") },
+        //      { std::string("Body"), std::string("VESTA") },
+        //      { std::string("Reference"), std::string("GALACTIC") },
+        //      { std::string("Observer"), std::string("PLUTO BARYCENTER") },
+        //      { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //vestaNode->setEphemeris(new SpiceEphemeris(vestaDictionary));
 
         
         //ghoul::Dictionary newHorizonsGhostDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("NEW HORIZONS") },
-        //	{ std::string("EphmerisGhosting"), std::string("TRUE") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("PLUTO BARYCENTER") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("NEW HORIZONS") },
+        //    { std::string("EphmerisGhosting"), std::string("TRUE") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("PLUTO BARYCENTER") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
         
@@ -886,33 +886,33 @@ void RenderEngine::changeViewPoint(std::string origin) {
         
         //ghoul::Dictionary dawnDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("DAWN") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("SUN") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("DAWN") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("SUN") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //dawnNode->setEphemeris(new SpiceEphemeris(dawnDictionary));
         //
         //ghoul::Dictionary vestaDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("VESTA") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("SUN") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("VESTA") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("SUN") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //vestaNode->setEphemeris(new SpiceEphemeris(vestaDictionary));
         
         
         //ghoul::Dictionary newHorizonsGhostDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("NEW HORIZONS") },
-        //	{ std::string("EphmerisGhosting"), std::string("TRUE") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("NEW HORIZONS") },
+        //    { std::string("EphmerisGhosting"), std::string("TRUE") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("JUPITER BARYCENTER") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
         
@@ -972,21 +972,21 @@ void RenderEngine::changeViewPoint(std::string origin) {
 
         //ghoul::Dictionary dawnDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("DAWN") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("DAWN") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("JUPITER BARYCENTER") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //dawnNode->setEphemeris(new SpiceEphemeris(dawnDictionary));
         //
         //ghoul::Dictionary vestaDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("VESTA") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("VESTA") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("JUPITER BARYCENTER") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //vestaNode->setEphemeris(new SpiceEphemeris(vestaDictionary));
 
@@ -994,12 +994,12 @@ void RenderEngine::changeViewPoint(std::string origin) {
         
         //ghoul::Dictionary newHorizonsGhostDictionary =
         //{
-        //	{ std::string("Type"), std::string("Spice") },
-        //	{ std::string("Body"), std::string("NEW HORIZONS") },
-        //	{ std::string("EphmerisGhosting"), std::string("TRUE") },
-        //	{ std::string("Reference"), std::string("GALACTIC") },
-        //	{ std::string("Observer"), std::string("JUPITER BARYCENTER") },
-        //	{ std::string("Kernels"), ghoul::Dictionary() }
+        //    { std::string("Type"), std::string("Spice") },
+        //    { std::string("Body"), std::string("NEW HORIZONS") },
+        //    { std::string("EphmerisGhosting"), std::string("TRUE") },
+        //    { std::string("Reference"), std::string("GALACTIC") },
+        //    { std::string("Observer"), std::string("JUPITER BARYCENTER") },
+        //    { std::string("Kernels"), ghoul::Dictionary() }
         //};
         //newHorizonsGhostNode->setEphemeris(new SpiceEphemeris(newHorizonsGhostDictionary));
         //newHorizonsGhostNode->setParent(jupiterBarycenterNode);
@@ -1008,69 +1008,69 @@ void RenderEngine::changeViewPoint(std::string origin) {
         return;
     }
     //if (origin == "Vesta") {
-    //	
-    //	vestaNode->setParent(scene()->sceneGraphNode("SolarSystem"));
-    //	vestaNode->setEphemeris(new StaticEphemeris);
+    //    
+    //    vestaNode->setParent(scene()->sceneGraphNode("SolarSystem"));
+    //    vestaNode->setEphemeris(new StaticEphemeris);
     //
-    //	solarSystemBarycenterNode->setParent(vestaNode);
-    //	newHorizonsNode->setParent(vestaNode);
+    //    solarSystemBarycenterNode->setParent(vestaNode);
+    //    newHorizonsNode->setParent(vestaNode);
     //
-    //	dawnNode->setParent(vestaNode);
-    //	plutoBarycenterNode->setParent(vestaNode);
+    //    dawnNode->setParent(vestaNode);
+    //    plutoBarycenterNode->setParent(vestaNode);
     //
     //
-    //	ghoul::Dictionary plutoDictionary =
-    //	{
-    //		{ std::string("Type"), std::string("Spice") },
-    //		{ std::string("Body"), std::string("PLUTO BARYCENTER") },
-    //		{ std::string("Reference"), std::string("GALACTIC") },
-    //		{ std::string("Observer"), std::string("VESTA") },
-    //		{ std::string("Kernels"), ghoul::Dictionary() }
-    //	};
-    //	ghoul::Dictionary solarDictionary =
-    //	{
-    //		{ std::string("Type"), std::string("Spice") },
-    //		{ std::string("Body"), std::string("SUN") },
-    //		{ std::string("Reference"), std::string("GALACTIC") },
-    //		{ std::string("Observer"), std::string("VESTA") },
-    //		{ std::string("Kernels"), ghoul::Dictionary() }
-    //	};
+    //    ghoul::Dictionary plutoDictionary =
+    //    {
+    //        { std::string("Type"), std::string("Spice") },
+    //        { std::string("Body"), std::string("PLUTO BARYCENTER") },
+    //        { std::string("Reference"), std::string("GALACTIC") },
+    //        { std::string("Observer"), std::string("VESTA") },
+    //        { std::string("Kernels"), ghoul::Dictionary() }
+    //    };
+    //    ghoul::Dictionary solarDictionary =
+    //    {
+    //        { std::string("Type"), std::string("Spice") },
+    //        { std::string("Body"), std::string("SUN") },
+    //        { std::string("Reference"), std::string("GALACTIC") },
+    //        { std::string("Observer"), std::string("VESTA") },
+    //        { std::string("Kernels"), ghoul::Dictionary() }
+    //    };
     //
-    //	ghoul::Dictionary jupiterDictionary =
-    //	{
-    //		{ std::string("Type"), std::string("Spice") },
-    //		{ std::string("Body"), std::string("JUPITER BARYCENTER") },
-    //		{ std::string("Reference"), std::string("GALACTIC") },
-    //		{ std::string("Observer"), std::string("VESTA") },
-    //		{ std::string("Kernels"), ghoul::Dictionary() }
-    //	};
+    //    ghoul::Dictionary jupiterDictionary =
+    //    {
+    //        { std::string("Type"), std::string("Spice") },
+    //        { std::string("Body"), std::string("JUPITER BARYCENTER") },
+    //        { std::string("Reference"), std::string("GALACTIC") },
+    //        { std::string("Observer"), std::string("VESTA") },
+    //        { std::string("Kernels"), ghoul::Dictionary() }
+    //    };
     //
-    //	solarSystemBarycenterNode->setEphemeris(new SpiceEphemeris(solarDictionary));
-    //	plutoBarycenterNode->setEphemeris(new SpiceEphemeris(plutoDictionary));
-    //	jupiterBarycenterNode->setEphemeris(new SpiceEphemeris(jupiterDictionary));
+    //    solarSystemBarycenterNode->setEphemeris(new SpiceEphemeris(solarDictionary));
+    //    plutoBarycenterNode->setEphemeris(new SpiceEphemeris(plutoDictionary));
+    //    jupiterBarycenterNode->setEphemeris(new SpiceEphemeris(jupiterDictionary));
     //
-    //	ghoul::Dictionary newHorizonsDictionary =
-    //	{
-    //		{ std::string("Type"), std::string("Spice") },
-    //		{ std::string("Body"), std::string("NEW HORIZONS") },
-    //		{ std::string("Reference"), std::string("GALACTIC") },
-    //		{ std::string("Observer"), std::string("VESTA") },
-    //		{ std::string("Kernels"), ghoul::Dictionary() }
-    //	};
-    //	newHorizonsNode->setEphemeris(new SpiceEphemeris(newHorizonsDictionary));
+    //    ghoul::Dictionary newHorizonsDictionary =
+    //    {
+    //        { std::string("Type"), std::string("Spice") },
+    //        { std::string("Body"), std::string("NEW HORIZONS") },
+    //        { std::string("Reference"), std::string("GALACTIC") },
+    //        { std::string("Observer"), std::string("VESTA") },
+    //        { std::string("Kernels"), ghoul::Dictionary() }
+    //    };
+    //    newHorizonsNode->setEphemeris(new SpiceEphemeris(newHorizonsDictionary));
     //
-    //	ghoul::Dictionary dawnDictionary =
-    //	{
-    //		{ std::string("Type"), std::string("Spice") },
-    //		{ std::string("Body"), std::string("DAWN") },
-    //		{ std::string("Reference"), std::string("GALACTIC") },
-    //		{ std::string("Observer"), std::string("VESTA") },
-    //		{ std::string("Kernels"), ghoul::Dictionary() }
-    //	};
-    //	dawnNode->setEphemeris(new SpiceEphemeris(dawnDictionary));
-    //	vestaNode->setEphemeris(new StaticEphemeris);
+    //    ghoul::Dictionary dawnDictionary =
+    //    {
+    //        { std::string("Type"), std::string("Spice") },
+    //        { std::string("Body"), std::string("DAWN") },
+    //        { std::string("Reference"), std::string("GALACTIC") },
+    //        { std::string("Observer"), std::string("VESTA") },
+    //        { std::string("Kernels"), ghoul::Dictionary() }
+    //    };
+    //    dawnNode->setEphemeris(new SpiceEphemeris(dawnDictionary));
+    //    vestaNode->setEphemeris(new StaticEphemeris);
     //
-    //	return;
+    //    return;
     //}
 
     if (origin == "67P") {
@@ -1358,11 +1358,11 @@ void RenderEngine::renderScreenLog() {
     //                if (entries.size() > max)
 
     //ScreenLog::const_range ScreenLog::last(size_t n) {
-    //	if (_entries.size() > n) {
-    //		return std::make_pair(_entries.rbegin(), _entries.rbegin() + n);
-    //	} else {
-    //		return std::make_pair(_entries.rbegin(), _entries.rend());
-    //	}
+    //    if (_entries.size() > n) {
+    //        return std::make_pair(_entries.rbegin(), _entries.rbegin() + n);
+    //    } else {
+    //        return std::make_pair(_entries.rbegin(), _entries.rend());
+    //    }
     //}
 
     //                auto entries = _log->last(max);
@@ -1400,10 +1400,10 @@ void RenderEngine::renderScreenLog() {
         RenderFont(*_fontLog,
             glm::vec2(10.f, _fontLog->pointSize() * nr * 2),
             white * alpha,
-            "%-14s %s%s",									// Format
-            e->timeString.c_str(),							// Time string
+            "%-14s %s%s",                                    // Format
+            e->timeString.c_str(),                            // Time string
             e->category.substr(0, category_length).c_str(), // Category string (up to category_length)
-            e->category.length() > 20 ? "..." : "");		// Pad category with "..." if exceeds category_length
+            e->category.length() > 20 ? "..." : "");        // Pad category with "..." if exceeds category_length
 
         glm::vec4 color = white;
         if (e->level == ghoul::logging::LogManager::LogLevel::Debug)
@@ -1419,14 +1419,14 @@ void RenderEngine::renderScreenLog() {
         RenderFont(*_fontLog,
             glm::vec2(static_cast<float>(10 + 39 * _fontLog->pointSize()), _fontLog->pointSize() * nr * 2),
             color * alpha,
-            "%s",									// Format
-            lvl.c_str());		// Pad category with "..." if exceeds category_length
+            "%s",                                    // Format
+            lvl.c_str());        // Pad category with "..." if exceeds category_length
 
         RenderFont(*_fontLog,
             glm::vec2(static_cast<float>(10 + 53 * _fontLog->pointSize()), _fontLog->pointSize() * nr * 2),
             white * alpha,
-            "%s",									// Format
-            message.c_str());		// Pad category with "..." if exceeds category_length
+            "%s",                                    // Format
+            message.c_str());        // Pad category with "..." if exceeds category_length
         ++nr;
     }
 }
diff --git a/src/scene/scene.cpp b/src/scene/scene.cpp
index b33bbebdbb..5fd2c0a9f1 100644
--- a/src/scene/scene.cpp
+++ b/src/scene/scene.cpp
@@ -59,8 +59,8 @@
 namespace {
     const std::string _loggerCat = "Scene";
     const std::string _moduleExtension = ".mod";
-	const std::string _defaultCommonDirectory = "common";
-	const std::string _commonModuleToken = "${COMMON_MODULE}";
+    const std::string _defaultCommonDirectory = "common";
+    const std::string _commonModuleToken = "${COMMON_MODULE}";
 
     const std::string KeyCamera = "Camera";
     const std::string KeyFocusObject = "Focus";
@@ -84,28 +84,28 @@ bool Scene::initialize() {
    
     std::unique_ptr<ProgramObject> tmpProgram;
 
-	// fboPassthrough program
+    // fboPassthrough program
     tmpProgram = ProgramObject::Build(
         "fboPassProgram",
-		"${SHADERS}/fboPass_vs.glsl",
-		"${SHADERS}/fboPass_fs.glsl");
-	if (!tmpProgram)
+        "${SHADERS}/fboPass_vs.glsl",
+        "${SHADERS}/fboPass_fs.glsl");
+    if (!tmpProgram)
         return false;
 
     tmpProgram->setIgnoreSubroutineUniformLocationError(ProgramObject::IgnoreError::Yes);
-	OsEng.configurationManager().setValue("fboPassProgram", tmpProgram.get());
+    OsEng.configurationManager().setValue("fboPassProgram", tmpProgram.get());
 
     return true;
 }
 
 bool Scene::deinitialize() {
-	clearSceneGraph();
+    clearSceneGraph();
     return true;
 }
 
 void Scene::update(const UpdateData& data) {
-	if (!_sceneGraphToLoad.empty()) {
-		OsEng.renderEngine().scene()->clearSceneGraph();
+    if (!_sceneGraphToLoad.empty()) {
+        OsEng.renderEngine().scene()->clearSceneGraph();
         try {
             loadSceneInternal(_sceneGraphToLoad);
             _sceneGraphToLoad = "";
@@ -115,7 +115,7 @@ void Scene::update(const UpdateData& data) {
             _sceneGraphToLoad = "";
             return;
         }
-	}
+    }
     for (SceneGraphNode* node : _graph.nodes()) {
         try {
             node->update(data);
@@ -129,7 +129,7 @@ void Scene::update(const UpdateData& data) {
 void Scene::evaluate(Camera* camera) {
     for (SceneGraphNode* node : _graph.nodes())
         node->evaluate(camera);
-	//_root->evaluate(camera);
+    //_root->evaluate(camera);
 }
 
 void Scene::render(const RenderData& data, RendererTasks& tasks) {
@@ -139,17 +139,17 @@ void Scene::render(const RenderData& data, RendererTasks& tasks) {
 }
 
 void Scene::scheduleLoadSceneFile(const std::string& sceneDescriptionFilePath) {
-	_sceneGraphToLoad = sceneDescriptionFilePath;
+    _sceneGraphToLoad = sceneDescriptionFilePath;
 }
 
 void Scene::clearSceneGraph() {
-	// deallocate the scene graph. Recursive deallocation will occur
+    // deallocate the scene graph. Recursive deallocation will occur
     _graph.clear();
-	//if (_root) {
-	//	_root->deinitialize();
-	//	delete _root;
-	//	_root = nullptr;
-	//}
+    //if (_root) {
+    //    _root->deinitialize();
+    //    delete _root;
+    //    _root = nullptr;
+    //}
 
  //   _nodes.erase(_nodes.begin(), _nodes.end());
  //   _allNodes.erase(_allNodes.begin(), _allNodes.end());
@@ -206,9 +206,9 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
     }
 
     // update the position of all nodes
-	// TODO need to check this; unnecessary? (ab)
-	for (SceneGraphNode* node : _graph.nodes()) {
-		node->update({ Time::ref().currentTime() });
+    // TODO need to check this; unnecessary? (ab)
+    for (SceneGraphNode* node : _graph.nodes()) {
+        node->update({ Time::ref().currentTime() });
     }
 
     for (auto it = _graph.nodes().rbegin(); it != _graph.nodes().rend(); ++it)
@@ -219,7 +219,7 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
     //_root->calculateBoundingSphere();
 
     // set the camera position
-	Camera* c = OsEng.ref().renderEngine().camera();
+    Camera* c = OsEng.ref().renderEngine().camera();
     //auto focusIterator = _allNodes.find(_focus);
     auto focusIterator = std::find_if(
                 _graph.nodes().begin(),
@@ -229,8 +229,8 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
     }
     );
 
-	glm::vec2 cameraScaling(1);
-	psc cameraPosition(0,0,1,0);
+    glm::vec2 cameraScaling(1);
+    psc cameraPosition(0,0,1,0);
 
     //if (_focus->)
     if (focusIterator != _graph.nodes().end()) {
@@ -242,26 +242,26 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
         // TODO: Set distance and camera direction in some more smart way
         // TODO: Set scaling dependent on the position and distance
         // set position for camera
-		const PowerScaledScalar bound = focusNode->calculateBoundingSphere();
+        const PowerScaledScalar bound = focusNode->calculateBoundingSphere();
 
         // this part is full of magic!
-		glm::vec2 boundf = bound.vec2();
+        glm::vec2 boundf = bound.vec2();
         //glm::vec2 scaling{1.0f, -boundf[1]};
-		cameraScaling = glm::vec2(1.f, -boundf[1]);
+        cameraScaling = glm::vec2(1.f, -boundf[1]);
         boundf[0] *= 5.0f;
         
-		//psc cameraPosition = focusNode->position();
+        //psc cameraPosition = focusNode->position();
         //cameraPosition += psc(glm::vec4(0.f, 0.f, boundf));
 
-		//cameraPosition = psc(glm::vec4(0.f, 0.f, 1.f,0.f));
+        //cameraPosition = psc(glm::vec4(0.f, 0.f, 1.f,0.f));
 
-		cameraPosition = focusNode->position();
-		cameraPosition += psc(glm::vec4(0.f, 0.f, boundf));
-		
-		//why this line? (JK)
-		//cameraPosition = psc(glm::vec4(0.f, 0.f, 1.f, 0.f));
+        cameraPosition = focusNode->position();
+        cameraPosition += psc(glm::vec4(0.f, 0.f, boundf));
+        
+        //why this line? (JK)
+        //cameraPosition = psc(glm::vec4(0.f, 0.f, 1.f, 0.f));
 
-		//c->setPosition(cameraPosition);
+        //c->setPosition(cameraPosition);
        // c->setCameraDirection(glm::vec3(0, 0, -1));
       //  c->setScaling(scaling);
 
@@ -271,7 +271,7 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
     else
         OsEng.interactionHandler().setFocusNode(_graph.rootNode());
 
-	glm::vec4 position;
+    glm::vec4 position;
     if (cameraDictionary.hasKeyAndValue<glm::vec4>(KeyPositionObject)) {
         try {
             position = cameraDictionary.value<glm::vec4>(KeyPositionObject);
@@ -287,32 +287,32 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
         catch (const ghoul::Dictionary::DictionaryError& e) {
             LERROR("Error loading Camera location: " << e.what());
         }
-	}
+    }
 
-	// the camera position
-	const SceneGraphNode* fn = OsEng.interactionHandler().focusNode();
+    // the camera position
+    const SceneGraphNode* fn = OsEng.interactionHandler().focusNode();
     // Check crash for when fn == nullptr
 
-	glm::mat4 la = glm::lookAt(cameraPosition.vec3(), fn->worldPosition().vec3(), c->lookUpVector());
+    glm::mat4 la = glm::lookAt(cameraPosition.vec3(), fn->worldPosition().vec3(), c->lookUpVector());
 
-	c->setRotation(la);
-	c->setPosition(cameraPosition);
-	c->setScaling(cameraScaling);
+    c->setRotation(la);
+    c->setPosition(cameraPosition);
+    c->setScaling(cameraScaling);
 
-	glm::vec3 viewOffset;
-	if (cameraDictionary.hasKey(KeyViewOffset)
-		&& cameraDictionary.getValue(KeyViewOffset, viewOffset)) {
-	    glm::quat rot = glm::quat(viewOffset);
-	    c->rotate(rot);
-	}
+    glm::vec3 viewOffset;
+    if (cameraDictionary.hasKey(KeyViewOffset)
+        && cameraDictionary.getValue(KeyViewOffset, viewOffset)) {
+        glm::quat rot = glm::quat(viewOffset);
+        c->rotate(rot);
+    }
 
 
-	for (SceneGraphNode* node : _graph.nodes()) {
-		std::vector<properties::Property*> properties = node->propertiesRecursive();
-		for (properties::Property* p : properties) {
+    for (SceneGraphNode* node : _graph.nodes()) {
+        std::vector<properties::Property*> properties = node->propertiesRecursive();
+        for (properties::Property* p : properties) {
             OsEng.gui()._property.registerProperty(p);
-		}
-	}
+        }
+    }
 
     // If a LuaDocumentationFile was specified, generate it now
     const bool hasType = OsEng.configurationManager().hasKey(ConfigurationManager::KeyPropertyDocumentationType);
@@ -336,34 +336,34 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 }
 
 //void Scene::loadModules(
-//	const std::string& directory, 
-//	const ghoul::Dictionary& dictionary) 
+//    const std::string& directory, 
+//    const ghoul::Dictionary& dictionary) 
 //{
-//	// Struct containing dependencies and nodes
-//	LoadMaps m;
+//    // Struct containing dependencies and nodes
+//    LoadMaps m;
 //
-//	// Get the common directory
-//	std::string commonDirectory(_defaultCommonDirectory);
-//	dictionary.getValue(constants::scenegraph::keyCommonFolder, commonDirectory);
-//	FileSys.registerPathToken(_commonModuleToken, commonDirectory);
+//    // Get the common directory
+//    std::string commonDirectory(_defaultCommonDirectory);
+//    dictionary.getValue(constants::scenegraph::keyCommonFolder, commonDirectory);
+//    FileSys.registerPathToken(_commonModuleToken, commonDirectory);
 //
 //    lua_State* state = ghoul::lua::createNewLuaState();
 //    OsEng.scriptEngine()->initializeLuaState(state);
 //
-//	LDEBUG("Loading common module folder '" << commonDirectory << "'");
-//	// Load common modules into LoadMaps struct
-//	loadModule(m, FileSys.pathByAppendingComponent(directory, commonDirectory), state);
+//    LDEBUG("Loading common module folder '" << commonDirectory << "'");
+//    // Load common modules into LoadMaps struct
+//    loadModule(m, FileSys.pathByAppendingComponent(directory, commonDirectory), state);
 //
-//	// Load the rest of the modules into LoadMaps struct
+//    // Load the rest of the modules into LoadMaps struct
 //    ghoul::Dictionary moduleDictionary;
 //    if (dictionary.getValue(constants::scenegraph::keyModules, moduleDictionary)) {
 //        std::vector<std::string> keys = moduleDictionary.keys();
 //        std::sort(keys.begin(), keys.end());
 //        for (const std::string& key : keys) {
 //            std::string moduleFolder;
-//			if (moduleDictionary.getValue(key, moduleFolder)) {
+//            if (moduleDictionary.getValue(key, moduleFolder)) {
 //                loadModule(m, FileSys.pathByAppendingComponent(directory, moduleFolder), state);
-//			}
+//            }
 //        }
 //    }
 //
@@ -372,19 +372,19 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 //
 //    // Remove loaded nodes from dependency list
 //    for(const auto& name: m.loadedNodes) {
-//    	m.dependencies.erase(name);
+//        m.dependencies.erase(name);
 //    }
 //
 //    // Check to see what dependencies are not resolved.
 //    for(auto& node: m.dependencies) {
-//    	LWARNING(
-//    		"'" << node.second << "'' not loaded, parent '" 
-//    		<< node.first << "' not defined!");
+//        LWARNING(
+//            "'" << node.second << "'' not loaded, parent '" 
+//            << node.first << "' not defined!");
 //    }
 //}
 
 //void Scene::loadModule(LoadMaps& m,const std::string& modulePath, lua_State* state) {
-//	auto pos = modulePath.find_last_of(ghoul::filesystem::FileSystem::PathSeparator);
+//    auto pos = modulePath.find_last_of(ghoul::filesystem::FileSystem::PathSeparator);
 //    if (pos == modulePath.npos) {
 //        LERROR("Bad format for module path: " << modulePath);
 //        return;
@@ -411,33 +411,33 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 //        std::string parentName;
 //
 //        moduleDictionary.getValue(key, element);
-//		element.setValue(constants::scenegraph::keyPathModule, modulePath);
+//        element.setValue(constants::scenegraph::keyPathModule, modulePath);
 //
-//		element.getValue(constants::scenegraphnode::keyName, nodeName);
-//		element.getValue(constants::scenegraphnode::keyParentName, parentName);
+//        element.getValue(constants::scenegraphnode::keyName, nodeName);
+//        element.getValue(constants::scenegraphnode::keyParentName, parentName);
 //
-//		m.nodes[nodeName] = element;
-//		m.dependencies.emplace(parentName,nodeName);
+//        m.nodes[nodeName] = element;
+//        m.dependencies.emplace(parentName,nodeName);
 //    }
 //
 //    FileSys.setCurrentDirectory(oldDirectory);
 //}
 
 //void Scene::loadNodes(const std::string& parentName, LoadMaps& m) {
-//	auto eqRange = m.dependencies.equal_range(parentName);
-//	for (auto it = eqRange.first; it != eqRange.second; ++it) {
-//		auto node = m.nodes.find((*it).second);
-//		loadNode(node->second);
-//		loadNodes((*it).second, m);
-//	}
-//	m.loadedNodes.emplace_back(parentName);
+//    auto eqRange = m.dependencies.equal_range(parentName);
+//    for (auto it = eqRange.first; it != eqRange.second; ++it) {
+//        auto node = m.nodes.find((*it).second);
+//        loadNode(node->second);
+//        loadNodes((*it).second, m);
+//    }
+//    m.loadedNodes.emplace_back(parentName);
 //}
 //
 //void Scene::loadNode(const ghoul::Dictionary& dictionary) {
 //    SceneGraphNode* node = SceneGraphNode::createFromDictionary(dictionary);
 //    if(node) {
-//    	_allNodes.emplace(node->name(), node);
-//    	_nodes.push_back(node);
+//        _allNodes.emplace(node->name(), node);
+//        _nodes.push_back(node);
 //    }
 //}
 
@@ -469,7 +469,7 @@ bool Scene::loadSceneInternal(const std::string& sceneDescriptionFilePath) {
 //
 //        element.setValue(constants::scenegraph::keyPathModule, modulePath);
 //
-//		//each element in this new dictionary becomes a scenegraph node. 
+//        //each element in this new dictionary becomes a scenegraph node. 
 //        SceneGraphNode* node = SceneGraphNode::createFromDictionary(element);
 //
 //        _allNodes.emplace(node->name(), node);
@@ -491,7 +491,7 @@ SceneGraphNode* Scene::sceneGraphNode(const std::string& name) const {
 }
 
 std::vector<SceneGraphNode*> Scene::allSceneGraphNodes() {
-	return _graph.nodes();
+    return _graph.nodes();
 }
 
 void Scene::writePropertyDocumentation(const std::string& filename, const std::string& type) {
@@ -522,34 +522,34 @@ void Scene::writePropertyDocumentation(const std::string& filename, const std::s
 }
 
 scripting::ScriptEngine::LuaLibrary Scene::luaLibrary() {
-	return {
-		"",
-		{
-			{
-				"setPropertyValue",
-				&luascriptfunctions::property_setValue,
-				"string, *",
-				"Sets a property identified by the URI in "
-				"the first argument. The second argument can be any type, but it has to "
-				" agree with the type that the property expects",
+    return {
+        "",
+        {
+            {
+                "setPropertyValue",
+                &luascriptfunctions::property_setValue,
+                "string, *",
+                "Sets a property identified by the URI in "
+                "the first argument. The second argument can be any type, but it has to "
+                " agree with the type that the property expects",
                 true
-			},
-			{
-				"getPropertyValue",
-				&luascriptfunctions::property_getValue,
-				"string",
-				"Returns the value the property, identified by "
-				"the provided URI."
-			},
-			{
-				"loadScene",
-				&luascriptfunctions::loadScene,
-				"string",
-				"Loads the scene found at the file passed as an "
-				"argument. If a scene is already loaded, it is unloaded first"
-			}
-		}
-	};
+            },
+            {
+                "getPropertyValue",
+                &luascriptfunctions::property_getValue,
+                "string",
+                "Returns the value the property, identified by "
+                "the provided URI."
+            },
+            {
+                "loadScene",
+                &luascriptfunctions::loadScene,
+                "string",
+                "Loads the scene found at the file passed as an "
+                "argument. If a scene is already loaded, it is unloaded first"
+            }
+        }
+    };
 }
 
 }  // namespace openspace
diff --git a/src/scene/scenegraphnode.cpp b/src/scene/scenegraphnode.cpp
index 2f8d0fa86c..21d2343a24 100644
--- a/src/scene/scenegraphnode.cpp
+++ b/src/scene/scenegraphnode.cpp
@@ -156,8 +156,8 @@ bool SceneGraphNode::deinitialize() {
     _ephemeris = nullptr;
 
  //   for (SceneGraphNode* child : _children) {
-    //	child->deinitialize();
-    //	delete child;
+    //    child->deinitialize();
+    //    delete child;
     //}
     _children.clear();
 
@@ -290,14 +290,14 @@ void SceneGraphNode::addChild(SceneGraphNode* child) {
 
 //not used anymore @AA
 //bool SceneGraphNode::abandonChild(SceneGraphNode* child) {
-//	std::vector < SceneGraphNode* >::iterator it = std::find(_children.begin(), _children.end(), child);
+//    std::vector < SceneGraphNode* >::iterator it = std::find(_children.begin(), _children.end(), child);
 //
-//	if (it != _children.end()){
-//		_children.erase(it);
-//		return true;
-//	}
+//    if (it != _children.end()){
+//        _children.erase(it);
+//        return true;
+//    }
 //
-//	return false;
+//    return false;
 //}
 
 const psc& SceneGraphNode::position() const
diff --git a/src/scripting/scriptengine.cpp b/src/scripting/scriptengine.cpp
index 753d0db2fb..ae6760e394 100644
--- a/src/scripting/scriptengine.cpp
+++ b/src/scripting/scriptengine.cpp
@@ -52,7 +52,7 @@ namespace {
 }
 
 bool ScriptEngine::LuaLibrary::operator<(const LuaLibrary& rhs) const {
-	return name < rhs.name;
+    return name < rhs.name;
 }
 
 void ScriptEngine::initialize() {
@@ -61,7 +61,7 @@ void ScriptEngine::initialize() {
     LDEBUG("Creating new Lua state");
     _state = ghoul::lua::createNewLuaState();
     LDEBUG("Initializing Lua state");
-	initializeLuaState(_state);
+    initializeLuaState(_state);
     LDEBUG("Remapping Print functions");
     remapPrintFunction();
 }
@@ -84,46 +84,46 @@ void ScriptEngine::initializeLuaState(lua_State* state) {
 }
 
 void ScriptEngine::addLibrary(LuaLibrary library) {
-	auto sortFunc = [](const LuaLibrary::Function& lhs, const LuaLibrary::Function& rhs)
-	{
-		return lhs.name < rhs.name;
-	};
+    auto sortFunc = [](const LuaLibrary::Function& lhs, const LuaLibrary::Function& rhs)
+    {
+        return lhs.name < rhs.name;
+    };
 
-	// do we have a library with the same name as the incoming one
-	auto it = std::find_if(_registeredLibraries.begin(), _registeredLibraries.end(),
-		[&library](const LuaLibrary& lib) { return lib.name == library.name; });
+    // do we have a library with the same name as the incoming one
+    auto it = std::find_if(_registeredLibraries.begin(), _registeredLibraries.end(),
+        [&library](const LuaLibrary& lib) { return lib.name == library.name; });
 
-	if (it == _registeredLibraries.end()) {
-		// If not, we can add it after we sorted it
-		std::sort(library.functions.begin(), library.functions.end(), sortFunc);
-		_registeredLibraries.insert(std::move(library));
-	}
-	else {
-		// otherwise, we merge the libraries
+    if (it == _registeredLibraries.end()) {
+        // If not, we can add it after we sorted it
+        std::sort(library.functions.begin(), library.functions.end(), sortFunc);
+        _registeredLibraries.insert(std::move(library));
+    }
+    else {
+        // otherwise, we merge the libraries
 
-		LuaLibrary merged = *it;
-		for (const LuaLibrary::Function& fun : library.functions) {
-			auto it = std::find_if(merged.functions.begin(), merged.functions.end(),
-				[&fun](const LuaLibrary::Function& function) {
-					return fun.name == function.name;
-			});
-			if (it != merged.functions.end()) {
-				// the function with the desired name is already present, but we don't
-				// want to overwrite it
-				LERROR("Lua function '" << fun.name << "' in library '" << library.name <<
-					"' has been defined twice");
-				return;
-			}
-			else
-				merged.functions.push_back(fun);
-		}
+        LuaLibrary merged = *it;
+        for (const LuaLibrary::Function& fun : library.functions) {
+            auto it = std::find_if(merged.functions.begin(), merged.functions.end(),
+                [&fun](const LuaLibrary::Function& function) {
+                    return fun.name == function.name;
+            });
+            if (it != merged.functions.end()) {
+                // the function with the desired name is already present, but we don't
+                // want to overwrite it
+                LERROR("Lua function '" << fun.name << "' in library '" << library.name <<
+                    "' has been defined twice");
+                return;
+            }
+            else
+                merged.functions.push_back(fun);
+        }
 
-		_registeredLibraries.erase(it);
+        _registeredLibraries.erase(it);
 
-		// Sort the merged library before inserting it
-		std::sort(merged.functions.begin(), merged.functions.end(), sortFunc);
-		_registeredLibraries.insert(std::move(merged));
-	}
+        // Sort the merged library before inserting it
+        std::sort(merged.functions.begin(), merged.functions.end(), sortFunc);
+        _registeredLibraries.insert(std::move(merged));
+    }
 }
 
 bool ScriptEngine::hasLibrary(const std::string& name) {
@@ -136,10 +136,10 @@ bool ScriptEngine::hasLibrary(const std::string& name) {
 }
 
 bool ScriptEngine::runScript(const std::string& script) {
-	if (script.empty()){
-		LWARNING("Script was empty");
-		return false;
-	}
+    if (script.empty()){
+        LWARNING("Script was empty");
+        return false;
+    }
     
     try {
         ghoul::lua::runScript(_state, script);
@@ -154,13 +154,13 @@ bool ScriptEngine::runScript(const std::string& script) {
     }
     
     // if we're currently hosting the parallel session, find out if script should be synchronized.
-	if (OsEng.parallelConnection().isHost()) {
-		std::string lib, func;
-		if (parseLibraryAndFunctionNames(lib, func, script) && shouldScriptBeSent(lib, func)){
+    if (OsEng.parallelConnection().isHost()) {
+        std::string lib, func;
+        if (parseLibraryAndFunctionNames(lib, func, script) && shouldScriptBeSent(lib, func)){
 //            OsEng.parallelConnection()->sendScript(script);
 //            cacheScript(lib, func, script);
-		}
-	}
+        }
+    }
     
     return true;
 }
@@ -235,55 +235,55 @@ std::vector<std::string> ScriptEngine::cachedScripts(){
         for(innerIt = outerIt->second.cbegin();
             innerIt != outerIt->second.cend();
             ++innerIt){
-			retVal.push_back(innerIt->second);
+            retVal.push_back(innerIt->second);
         }
     }
     
     _cachedScriptsMutex.unlock();
 
-	return retVal;
+    return retVal;
 }
     
 bool ScriptEngine::parseLibraryAndFunctionNames(std::string &library, std::string &function, const std::string &script){
-	
-	//"deconstruct the script to find library and function name
-	//assuming a script looks like: "openspace.library.function()"
-	//or openspace.funcion()
-	std::string sub;
-	library.clear();
-	function.clear();
-	//find first "."
-	std::size_t pos = script.find(".");
-	
-	if (pos != std::string::npos){
-		//strip "openspace."
-		sub = script.substr(pos + 1, script.size());
-		pos = sub.find(".");
-		//one more "." was found, if the "." comes before first "(" we have a library name
-		if (pos != std::string::npos && pos < sub.find("(")){
-			//assing library name
-			library = sub.substr(0, pos);
-			//strip "library."
-			sub = sub.substr(pos + 1, sub.size());
+    
+    //"deconstruct the script to find library and function name
+    //assuming a script looks like: "openspace.library.function()"
+    //or openspace.funcion()
+    std::string sub;
+    library.clear();
+    function.clear();
+    //find first "."
+    std::size_t pos = script.find(".");
+    
+    if (pos != std::string::npos){
+        //strip "openspace."
+        sub = script.substr(pos + 1, script.size());
+        pos = sub.find(".");
+        //one more "." was found, if the "." comes before first "(" we have a library name
+        if (pos != std::string::npos && pos < sub.find("(")){
+            //assing library name
+            library = sub.substr(0, pos);
+            //strip "library."
+            sub = sub.substr(pos + 1, sub.size());
 
-			pos = sub.find("(");
-			if (pos != std::string::npos && pos > 0){
-				//strip the () and we're left with function name
-				function = sub.substr(0, pos);
-			}
-		}
-		else{
-			//no more "." was found, we have the case of "openspace.funcion()"
-			pos = sub.find("(");
-			if (pos != std::string::npos && pos > 0){
-				//strip the () and we're left with function name
-				function = sub.substr(0, pos);
-			}
-		}
-	}
+            pos = sub.find("(");
+            if (pos != std::string::npos && pos > 0){
+                //strip the () and we're left with function name
+                function = sub.substr(0, pos);
+            }
+        }
+        else{
+            //no more "." was found, we have the case of "openspace.funcion()"
+            pos = sub.find("(");
+            if (pos != std::string::npos && pos > 0){
+                //strip the () and we're left with function name
+                function = sub.substr(0, pos);
+            }
+        }
+    }
 
-	//if we found a function all is good
-	return !function.empty();
+    //if we found a function all is good
+    return !function.empty();
 }
 
 bool ScriptEngine::isLibraryNameAllowed(lua_State* state, const std::string& name) {
@@ -336,26 +336,26 @@ bool ScriptEngine::isLibraryNameAllowed(lua_State* state, const std::string& nam
 }
 
 void ScriptEngine::addLibraryFunctions(lua_State* state, const LuaLibrary& library, bool replace) {
-	assert(state);
+    assert(state);
     for (LuaLibrary::Function p : library.functions) {
         if (!replace) {
-			//ghoul::lua::logStack(_state);
+            //ghoul::lua::logStack(_state);
             lua_getfield(state, -1, p.name.c_str());
-			//ghoul::lua::logStack(_state);
+            //ghoul::lua::logStack(_state);
             const bool isNil = lua_isnil(state, -1);
             if (!isNil) {
                 LERROR("Function name '" << p.name << "' was already assigned");
                 return;
             }
-			lua_pop(state, 1);
+            lua_pop(state, 1);
         }
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         lua_pushstring(state, p.name.c_str());
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         lua_pushcfunction(state, p.function);
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         lua_settable(state, _setTableOffset);
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
     }
 }
     
@@ -364,105 +364,105 @@ void ScriptEngine::addBaseLibrary() {
         "",
         {
             {
-				"printDebug",
-				&luascriptfunctions::printDebug,
-				"*",
-				"Logs the passed value to the installed LogManager with a "
-				"LogLevel of 'Debug'"
-			},
-			{
-				"printInfo",
-				&luascriptfunctions::printInfo,
-				"*",
-				"Logs the passed value to the installed LogManager with a "
-				" LogLevel of 'Info'"
-			},
-			{
-				"printWarning",
-				&luascriptfunctions::printWarning,
-				"*",
-				"Logs the passed value to the installed LogManager with "
-				"a LogLevel of 'Warning'"
-			},
-			{
-				"printError",
-				&luascriptfunctions::printError,
-				"*",
-				"Logs the passed value to the installed LogManager with a "
-				"LogLevel of 'Error'"
-			},
-			{
-				"printFatal",
-				&luascriptfunctions::printFatal,
-				"*",
-				"Logs the passed value to the installed LogManager with a "
-				"LogLevel of 'Fatal'"
-			},
-			{
-				"absPath",
-				&luascriptfunctions::absolutePath,
-				"string",
-				"Returns the absolute path to the passed path, resolving"
-				" path tokens as well as resolving relative paths"
-			},
-			{
-				"setPathToken",
-				&luascriptfunctions::setPathToken,
-				"string, string",
-				"Registers a new path token provided by the"
-				" first argument to the path provided in the second argument"
-			}
+                "printDebug",
+                &luascriptfunctions::printDebug,
+                "*",
+                "Logs the passed value to the installed LogManager with a "
+                "LogLevel of 'Debug'"
+            },
+            {
+                "printInfo",
+                &luascriptfunctions::printInfo,
+                "*",
+                "Logs the passed value to the installed LogManager with a "
+                " LogLevel of 'Info'"
+            },
+            {
+                "printWarning",
+                &luascriptfunctions::printWarning,
+                "*",
+                "Logs the passed value to the installed LogManager with "
+                "a LogLevel of 'Warning'"
+            },
+            {
+                "printError",
+                &luascriptfunctions::printError,
+                "*",
+                "Logs the passed value to the installed LogManager with a "
+                "LogLevel of 'Error'"
+            },
+            {
+                "printFatal",
+                &luascriptfunctions::printFatal,
+                "*",
+                "Logs the passed value to the installed LogManager with a "
+                "LogLevel of 'Fatal'"
+            },
+            {
+                "absPath",
+                &luascriptfunctions::absolutePath,
+                "string",
+                "Returns the absolute path to the passed path, resolving"
+                " path tokens as well as resolving relative paths"
+            },
+            {
+                "setPathToken",
+                &luascriptfunctions::setPathToken,
+                "string, string",
+                "Registers a new path token provided by the"
+                " first argument to the path provided in the second argument"
+            }
         }
     };
     addLibrary(lib);
 }
     
 void ScriptEngine::remapPrintFunction() {
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
  //   lua_getglobal(_state, _luaGlobalNamespace.c_str());
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
  //   lua_pushstring(_state, _printFunctionName.c_str());
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
  //   lua_pushcfunction(_state, _printFunctionReplacement);
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
  //   lua_settable(_state, _setTableOffset);
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
 }
 
 bool ScriptEngine::registerLuaLibrary(lua_State* state, const LuaLibrary& library) {
-	assert(state);
+    assert(state);
     if (library.functions.empty()) {
         LERROR("Lua library '" << library.name << "' does not have any functions");
         return false;
     }
 
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
     lua_getglobal(state, _openspaceLibraryName.c_str());
-	//ghoul::lua::logStack(_state);
+    //ghoul::lua::logStack(_state);
     if (library.name.empty()) {
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         addLibraryFunctions(state, library, true);
-		//ghoul::lua::logStack(_state);
-		lua_pop(state, 1);
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
+        lua_pop(state, 1);
+        //ghoul::lua::logStack(_state);
     }
     else {
         const bool allowed = isLibraryNameAllowed(state, library.name);
         if (!allowed)
             return false;
         
-		//ghoul::lua::logStack(_state);
-		
+        //ghoul::lua::logStack(_state);
+        
         lua_pushstring(state, library.name.c_str());
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         lua_newtable(state);
-		//ghoul::lua::logStack(_state);
+        //ghoul::lua::logStack(_state);
         addLibraryFunctions(state, library, false);
         lua_settable(state, _setTableOffset);
         //ghoul::lua::logStack(_state);
 
         //_registeredLibraries.insert(library);
-		//_registeredLibraries.push_back(library);
+        //_registeredLibraries.push_back(library);
     }
     return true;
 }
@@ -484,138 +484,138 @@ std::vector<std::string> ScriptEngine::allLuaFunctions() const {
 }
 
 bool ScriptEngine::writeDocumentation(const std::string& filename, const std::string& type) const {
-	if (type == "text") {
-		// The additional space between the longest function name and the descriptions
-		LDEBUG("Writing Lua documentation of type '" << type <<
-			"' to file '" << filename << "'");
-		std::ofstream file(filename);
-		if (!file.good()) {
-			LERROR("Could not open file '" << filename << "' for writing documentation");
-			return false;
-		}
+    if (type == "text") {
+        // The additional space between the longest function name and the descriptions
+        LDEBUG("Writing Lua documentation of type '" << type <<
+            "' to file '" << filename << "'");
+        std::ofstream file(filename);
+        if (!file.good()) {
+            LERROR("Could not open file '" << filename << "' for writing documentation");
+            return false;
+        }
 
-		auto concatenate = [](std::string library, std::string function) {
-			std::string total = "openspace.";
-			if (!library.empty())
-				total += std::move(library) + ".";
-			total += std::move(function);
-			return total;
-		};
+        auto concatenate = [](std::string library, std::string function) {
+            std::string total = "openspace.";
+            if (!library.empty())
+                total += std::move(library) + ".";
+            total += std::move(function);
+            return total;
+        };
 
-		// Settings
-		const unsigned int lineWidth = 80;
-		static const std::string whitespace = " \t";
-		static const std::string padding = "    ";
-		const bool commandListArguments = true;
+        // Settings
+        const unsigned int lineWidth = 80;
+        static const std::string whitespace = " \t";
+        static const std::string padding = "    ";
+        const bool commandListArguments = true;
 
-		file << "Available commands:\n";
-		// Now write out the functions
-		for (const LuaLibrary& library : _registeredLibraries) {
-			for (const LuaLibrary::Function& function : library.functions) {
+        file << "Available commands:\n";
+        // Now write out the functions
+        for (const LuaLibrary& library : _registeredLibraries) {
+            for (const LuaLibrary::Function& function : library.functions) {
 
-				std::string functionName = concatenate(library.name, function.name);
-				file << padding << functionName;
-				if (commandListArguments)
-					file << "(" << function.argumentText << ")";
-				file << std::endl;
-			}
-		}
-		file << std::endl;
+                std::string functionName = concatenate(library.name, function.name);
+                file << padding << functionName;
+                if (commandListArguments)
+                    file << "(" << function.argumentText << ")";
+                file << std::endl;
+            }
+        }
+        file << std::endl;
 
-		// Now write out the functions definitions
-		for (const LuaLibrary& library : _registeredLibraries) {
-			for (const LuaLibrary::Function& function : library.functions) {
+        // Now write out the functions definitions
+        for (const LuaLibrary& library : _registeredLibraries) {
+            for (const LuaLibrary::Function& function : library.functions) {
 
-				std::string functionName = concatenate(library.name, function.name);
-				file << functionName << "(" << function.argumentText << "):" << std::endl;
+                std::string functionName = concatenate(library.name, function.name);
+                file << functionName << "(" << function.argumentText << "):" << std::endl;
 
-				std::string remainingHelptext = function.helpText;
+                std::string remainingHelptext = function.helpText;
 
-				// @CLEANUP This needs to become a bit prettier ---abock
-				while (!remainingHelptext.empty()) {
-					const auto length = remainingHelptext.length();
-					const auto paddingLength = padding.length();
-					if ((length + paddingLength) > lineWidth) {
-						auto lastSpace = remainingHelptext.find_last_of(whitespace, lineWidth - 1 - paddingLength);
-						if (lastSpace == remainingHelptext.npos)
-							lastSpace = lineWidth;
-						file << padding << remainingHelptext.substr(0, lastSpace) << std::endl;
-						auto firstNotSpace = remainingHelptext.find_first_not_of(whitespace, lastSpace);
-						if (firstNotSpace == remainingHelptext.npos)
-							firstNotSpace = lastSpace;
-						remainingHelptext = remainingHelptext.substr(firstNotSpace);
-					}
-					else {
-						file << padding << remainingHelptext << std::endl;
-						remainingHelptext = "";
-					}
-				}
-				file << std::endl;
-			}
-		}
-		return true;
-	}
-	else {
-		LERROR("Undefined type '" << type << "' for Lua documentation");
-		return false;
-	}
+                // @CLEANUP This needs to become a bit prettier ---abock
+                while (!remainingHelptext.empty()) {
+                    const auto length = remainingHelptext.length();
+                    const auto paddingLength = padding.length();
+                    if ((length + paddingLength) > lineWidth) {
+                        auto lastSpace = remainingHelptext.find_last_of(whitespace, lineWidth - 1 - paddingLength);
+                        if (lastSpace == remainingHelptext.npos)
+                            lastSpace = lineWidth;
+                        file << padding << remainingHelptext.substr(0, lastSpace) << std::endl;
+                        auto firstNotSpace = remainingHelptext.find_first_not_of(whitespace, lastSpace);
+                        if (firstNotSpace == remainingHelptext.npos)
+                            firstNotSpace = lastSpace;
+                        remainingHelptext = remainingHelptext.substr(firstNotSpace);
+                    }
+                    else {
+                        file << padding << remainingHelptext << std::endl;
+                        remainingHelptext = "";
+                    }
+                }
+                file << std::endl;
+            }
+        }
+        return true;
+    }
+    else {
+        LERROR("Undefined type '" << type << "' for Lua documentation");
+        return false;
+    }
 }
 
 void ScriptEngine::serialize(SyncBuffer* syncBuffer){
-	syncBuffer->encode(_currentSyncedScript);
-	_currentSyncedScript.clear();
+    syncBuffer->encode(_currentSyncedScript);
+    _currentSyncedScript.clear();
 }
 
 void ScriptEngine::deserialize(SyncBuffer* syncBuffer){
-	syncBuffer->decode(_currentSyncedScript);
+    syncBuffer->decode(_currentSyncedScript);
 
-	if (!_currentSyncedScript.empty()){
-		_mutex.lock();
-		_receivedScripts.push_back(_currentSyncedScript);
-		_mutex.unlock();
-	}
+    if (!_currentSyncedScript.empty()){
+        _mutex.lock();
+        _receivedScripts.push_back(_currentSyncedScript);
+        _mutex.unlock();
+    }
 }
 
 void ScriptEngine::postSynchronizationPreDraw(){
-	
-	std::vector<std::string> scripts;
+    
+    std::vector<std::string> scripts;
 
-	_mutex.lock();
-	scripts.assign(_receivedScripts.begin(), _receivedScripts.end());
-	_receivedScripts.clear();
-	_mutex.unlock();
-	
-	while (!scripts.empty()){
-		runScript(scripts.back());
-		scripts.pop_back();
-	}
-	
+    _mutex.lock();
+    scripts.assign(_receivedScripts.begin(), _receivedScripts.end());
+    _receivedScripts.clear();
+    _mutex.unlock();
+    
+    while (!scripts.empty()){
+        runScript(scripts.back());
+        scripts.pop_back();
+    }
+    
 }
 
 void ScriptEngine::preSynchronization(){
-	
-	_mutex.lock();
-	
-	if (!_queuedScripts.empty()){
-		_currentSyncedScript = _queuedScripts.back();
-		_queuedScripts.pop_back();
-		
-		//Not really a received script but the master also needs to run the script...
-		_receivedScripts.push_back(_currentSyncedScript);
-	}
-	
-	_mutex.unlock();
+    
+    _mutex.lock();
+    
+    if (!_queuedScripts.empty()){
+        _currentSyncedScript = _queuedScripts.back();
+        _queuedScripts.pop_back();
+        
+        //Not really a received script but the master also needs to run the script...
+        _receivedScripts.push_back(_currentSyncedScript);
+    }
+    
+    _mutex.unlock();
 }
 
 void ScriptEngine::queueScript(const std::string &script){
-	if (script.empty())
-		return;
+    if (script.empty())
+        return;
     
-	_mutex.lock();
+    _mutex.lock();
 
-	_queuedScripts.insert(_queuedScripts.begin(), script);
+    _queuedScripts.insert(_queuedScripts.begin(), script);
 
-	_mutex.unlock();
+    _mutex.unlock();
 }
 
 } // namespace scripting
diff --git a/src/util/camera.cpp b/src/util/camera.cpp
index 388bb36cbd..7cf0f1d1ad 100644
--- a/src/util/camera.cpp
+++ b/src/util/camera.cpp
@@ -32,26 +32,26 @@
 namespace openspace {
     
 Camera::Camera()
-	: _maxFov(0.f)
-	, _sinMaxFov(0.f)
-	, _viewProjectionMatrix()
-	, _modelMatrix()
-	, _viewMatrix()
-	, _projectionMatrix()
+    : _maxFov(0.f)
+    , _sinMaxFov(0.f)
+    , _viewProjectionMatrix()
+    , _modelMatrix()
+    , _viewMatrix()
+    , _projectionMatrix()
     , _dirtyViewProjectionMatrix(true)
-	, _viewDirection(0,0,-1)
+    , _viewDirection(0,0,-1)
     , _cameraDirection(0.f, 0.f, 0.f)
     , _focusPosition()
-	//, _viewRotation(glm::quat(glm::vec3(0.f, 0.f, 0.f)))
-	, _localViewRotationMatrix(1.f)
+    //, _viewRotation(glm::quat(glm::vec3(0.f, 0.f, 0.f)))
+    , _localViewRotationMatrix(1.f)
     , _localScaling(1.f, 0.f)
     , _localPosition()
     , _sharedScaling(1.f, 0.f)
-	, _sharedPosition()
-	, _sharedViewRotationMatrix(1.f)
-	, _syncedScaling(1.f, 0.f)
+    , _sharedPosition()
+    , _sharedViewRotationMatrix(1.f)
+    , _syncedScaling(1.f, 0.f)
     , _syncedPosition()
-	, _syncedViewRotationMatrix(1.f)
+    , _syncedViewRotationMatrix(1.f)
 {
 }
 
@@ -62,45 +62,45 @@ Camera::~Camera()
 void Camera::setPosition(psc pos)
 {
     std::lock_guard<std::mutex> _lock(_mutex);
-	_localPosition = std::move(pos);
+    _localPosition = std::move(pos);
 }
 
 const psc& Camera::position() const
 {
-	return _syncedPosition;
+    return _syncedPosition;
 }
 
 const psc& Camera::unsynchedPosition() const{
-	return _localPosition;
+    return _localPosition;
 }
 
 void Camera::setModelMatrix(glm::mat4 modelMatrix){
     std::lock_guard<std::mutex> _lock(_mutex);
-	_modelMatrix = std::move(modelMatrix);
+    _modelMatrix = std::move(modelMatrix);
 }
 
 const glm::mat4& Camera::modelMatrix() const{
-	return _modelMatrix;
+    return _modelMatrix;
 }
 
 void Camera::setViewMatrix(glm::mat4 viewMatrix){
     std::lock_guard<std::mutex> _lock(_mutex);
-	_viewMatrix = std::move(viewMatrix);
+    _viewMatrix = std::move(viewMatrix);
     _dirtyViewProjectionMatrix = true;
 }
 
 const glm::mat4& Camera::viewMatrix() const{
-	return _viewMatrix;
+    return _viewMatrix;
 }
 
 void Camera::setProjectionMatrix(glm::mat4 projectionMatrix){
     std::lock_guard<std::mutex> _lock(_mutex);
-	_projectionMatrix = std::move(projectionMatrix);
+    _projectionMatrix = std::move(projectionMatrix);
     _dirtyViewProjectionMatrix = true;
 }
 
 const glm::mat4& Camera::projectionMatrix() const{
-	return _projectionMatrix;
+    return _projectionMatrix;
 }
     
 const glm::mat4& Camera::viewProjectionMatrix() const {
@@ -125,13 +125,13 @@ glm::vec3 Camera::cameraDirection() const
 
 void Camera::setViewRotationMatrix(glm::mat4 m) {
     std::lock_guard<std::mutex> _lock(_mutex);
-	_localViewRotationMatrix = m;
+    _localViewRotationMatrix = m;
 }
 
 const glm::mat4& Camera::viewRotationMatrix() const
 {
-	//return _localViewRotationMatrix;
-	return _syncedViewRotationMatrix;
+    //return _localViewRotationMatrix;
+    return _syncedViewRotationMatrix;
 }
 
 void Camera::compileViewRotationMatrix()
@@ -142,16 +142,16 @@ void Camera::compileViewRotationMatrix()
 
     // the camera matrix needs to be rotated inverse to the world
    // _viewDirection = glm::rotate(glm::inverse(_viewRotation), _cameraDirection);
-	//_viewDirection = (glm::inverse(_localViewRotationMatrix) * glm::vec4(_cameraDirection, 0.f)).xyz;
-	_viewDirection = (glm::inverse(_localViewRotationMatrix) * glm::vec4(_cameraDirection, 0.f)).xyz();
+    //_viewDirection = (glm::inverse(_localViewRotationMatrix) * glm::vec4(_cameraDirection, 0.f)).xyz;
+    _viewDirection = (glm::inverse(_localViewRotationMatrix) * glm::vec4(_cameraDirection, 0.f)).xyz();
     _viewDirection = glm::normalize(_viewDirection);
 }
 
 void Camera::rotate(const glm::quat& rotation)
 {
     std::lock_guard<std::mutex> _lock(_mutex);
-	glm::mat4 tmp = glm::mat4_cast(rotation);
-	_localViewRotationMatrix = _localViewRotationMatrix * tmp;
+    glm::mat4 tmp = glm::mat4_cast(rotation);
+    _localViewRotationMatrix = _localViewRotationMatrix * tmp;
     //_viewRotation = rotation * _viewRotation;
     //_viewRotation = glm::normalize(_viewRotation);
 }
@@ -160,13 +160,13 @@ void Camera::setRotation(glm::quat rotation)
 {
     std::lock_guard<std::mutex> _lock(_mutex);
     //_viewRotation = glm::normalize(std::move(rotation));
-	_localViewRotationMatrix = glm::mat4_cast(rotation);
+    _localViewRotationMatrix = glm::mat4_cast(rotation);
 }
 
 void Camera::setRotation(glm::mat4 rotation)
 {
     std::lock_guard<std::mutex> _lock(_mutex);
-	_localViewRotationMatrix = std::move(rotation);
+    _localViewRotationMatrix = std::move(rotation);
 }
 
 //const glm::quat& Camera::rotation() const
@@ -176,11 +176,11 @@ void Camera::setRotation(glm::mat4 rotation)
 
 void Camera::setFocusPosition(psc pos){
     std::lock_guard<std::mutex> _lock(_mutex);
-	_focusPosition = pos;
+    _focusPosition = pos;
 }
 
 const psc& Camera::focusPosition() const{
-	return _focusPosition;
+    return _focusPosition;
 }
 
 
@@ -209,13 +209,13 @@ void Camera::setMaxFov(float fov)
 void Camera::setScaling(glm::vec2 scaling)
 {
     std::lock_guard<std::mutex> _lock(_mutex);
-	_localScaling = std::move(scaling);
+    _localScaling = std::move(scaling);
 }
 
 const glm::vec2& Camera::scaling() const
 {
-	//return _localScaling;
-	return _syncedScaling;
+    //return _localScaling;
+    return _syncedScaling;
 }
 
 void Camera::setLookUpVector(glm::vec3 lookUp)
@@ -230,43 +230,43 @@ const glm::vec3& Camera::lookUpVector() const
 }
 
 void Camera::serialize(SyncBuffer* syncBuffer){
-	_mutex.lock();
+    _mutex.lock();
 
-	syncBuffer->encode(_sharedViewRotationMatrix);
-	syncBuffer->encode(_sharedPosition);
-	syncBuffer->encode(_sharedScaling);
+    syncBuffer->encode(_sharedViewRotationMatrix);
+    syncBuffer->encode(_sharedPosition);
+    syncBuffer->encode(_sharedScaling);
 
-	_mutex.unlock();
+    _mutex.unlock();
 }
 
-void Camera::deserialize(SyncBuffer* syncBuffer){	
-	_mutex.lock();
+void Camera::deserialize(SyncBuffer* syncBuffer){    
+    _mutex.lock();
 
-	syncBuffer->decode(_sharedViewRotationMatrix);
-	syncBuffer->decode(_sharedPosition);
-	syncBuffer->decode(_sharedScaling);
+    syncBuffer->decode(_sharedViewRotationMatrix);
+    syncBuffer->decode(_sharedPosition);
+    syncBuffer->decode(_sharedScaling);
 
-	_mutex.unlock();
+    _mutex.unlock();
 }
 
 void Camera::postSynchronizationPreDraw(){
-	_mutex.lock();
+    _mutex.lock();
 
-	_syncedViewRotationMatrix = _sharedViewRotationMatrix;
-	_syncedPosition = _sharedPosition;
-	_syncedScaling = _sharedScaling;
+    _syncedViewRotationMatrix = _sharedViewRotationMatrix;
+    _syncedPosition = _sharedPosition;
+    _syncedScaling = _sharedScaling;
 
-	_mutex.unlock();
+    _mutex.unlock();
 }
 
 void Camera::preSynchronization(){
-	_mutex.lock();
+    _mutex.lock();
 
-	_sharedViewRotationMatrix = _localViewRotationMatrix;
-	_sharedPosition = _localPosition;
-	_sharedScaling = _localScaling;
+    _sharedViewRotationMatrix = _localViewRotationMatrix;
+    _sharedPosition = _localPosition;
+    _sharedScaling = _localScaling;
 
-	_mutex.unlock();
+    _mutex.unlock();
 }
 
 //
diff --git a/src/util/powerscaledcoordinate.cpp b/src/util/powerscaledcoordinate.cpp
index 32be6fb7f3..c86544d48f 100644
--- a/src/util/powerscaledcoordinate.cpp
+++ b/src/util/powerscaledcoordinate.cpp
@@ -64,7 +64,7 @@ PowerScaledCoordinate::PowerScaledCoordinate(float f1, float f2, float f3, float
 }
 
 PowerScaledCoordinate::PowerScaledCoordinate(const PowerScaledCoordinate& rhs) {
-	_vec = rhs._vec;
+    _vec = rhs._vec;
 
 }
 
@@ -89,15 +89,15 @@ PowerScaledCoordinate
 #endif
     size_t digits = strlen(buff);
 
-	//digits += 3;
+    //digits += 3;
 
     // rescale and return
     double tp = 1.0 / pow(k, digits);
     return PowerScaledCoordinate(
-		static_cast<float>(d1 * tp), 
-		static_cast<float>(d2 * tp), 
-		static_cast<float>(d3 * tp), 
-		static_cast<float>(digits));
+        static_cast<float>(d1 * tp), 
+        static_cast<float>(d2 * tp), 
+        static_cast<float>(d3 * tp), 
+        static_cast<float>(digits));
 }
 
 const glm::vec4& PowerScaledCoordinate::vec4() const
@@ -113,14 +113,14 @@ glm::vec3 PowerScaledCoordinate::vec3() const
 
 glm::dvec4 PowerScaledCoordinate::dvec4() const
 {
-	//return _vec;
-	return glm::dvec4(_vec);
+    //return _vec;
+    return glm::dvec4(_vec);
 }
 
 glm::dvec3 PowerScaledCoordinate::dvec3() const
 {
-	return glm::dvec3(_vec[0] * pow(k, _vec[3]), _vec[1] * pow(k, _vec[3]),
-		_vec[2] * pow(k, _vec[3]));
+    return glm::dvec3(_vec[0] * pow(k, _vec[3]), _vec[1] * pow(k, _vec[3]),
+        _vec[2] * pow(k, _vec[3]));
 }
 
 PowerScaledScalar PowerScaledCoordinate::length() const
@@ -176,14 +176,14 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator+=(const PowerScaledCoordi
     double ds = _vec[3] - rhs._vec[3];
     if (ds >= 0.0) {
         double p = pow(k, -ds);
-		*this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] * p + _vec[0]),
-									  static_cast<float>(rhs._vec[1] * p + _vec[1]),
-									  static_cast<float>(rhs._vec[2] * p + _vec[2]), _vec[3]);
+        *this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] * p + _vec[0]),
+                                      static_cast<float>(rhs._vec[1] * p + _vec[1]),
+                                      static_cast<float>(rhs._vec[2] * p + _vec[2]), _vec[3]);
     } else {
         double p = pow(k, ds);
-		*this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] + _vec[0] * p),
+        *this = PowerScaledCoordinate(static_cast<float>(rhs._vec[0] + _vec[0] * p),
                                       static_cast<float>(rhs._vec[1] + _vec[1] * p),
-									  static_cast<float>(rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
+                                      static_cast<float>(rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
     }
 
     return *this;
@@ -200,14 +200,14 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator-=(const PowerScaledCoordi
     double ds = this->_vec[3] - rhs._vec[3];
     if (ds >= 0.0) {
         double p = pow(k, -ds);
-		*this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] * p + _vec[0]),
+        *this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] * p + _vec[0]),
                                       static_cast<float>(-rhs._vec[1] * p + _vec[1]),
-									  static_cast<float>(-rhs._vec[2] * p + _vec[2]), _vec[3]);
+                                      static_cast<float>(-rhs._vec[2] * p + _vec[2]), _vec[3]);
     } else {
         double p = pow(k, ds);
-		*this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] + _vec[0] * p),
+        *this = PowerScaledCoordinate(static_cast<float>(-rhs._vec[0] + _vec[0] * p),
                                       static_cast<float>(-rhs._vec[1] + _vec[1] * p),
-									  static_cast<float>(-rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
+                                      static_cast<float>(-rhs._vec[2] + _vec[2] * p), rhs._vec[3]);
     }
 
     return *this;
@@ -215,9 +215,9 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator-=(const PowerScaledCoordi
 
 PowerScaledCoordinate PowerScaledCoordinate::operator*(const double& rhs) const
 {
-	return PowerScaledCoordinate(static_cast<float>(_vec[0] * rhs), 
-								 static_cast<float>(_vec[1] * rhs), 
-								 static_cast<float>(_vec[2] * rhs), _vec[3]);
+    return PowerScaledCoordinate(static_cast<float>(_vec[0] * rhs), 
+                                 static_cast<float>(_vec[1] * rhs), 
+                                 static_cast<float>(_vec[2] * rhs), _vec[3]);
 }
 
 PowerScaledCoordinate PowerScaledCoordinate::operator*(const float& rhs) const
@@ -231,15 +231,15 @@ PowerScaledCoordinate& PowerScaledCoordinate::operator*=(const PowerScaledScalar
     if (ds >= 0.0) {
         double p = pow(k, -ds);
         *this = PowerScaledCoordinate(
-			static_cast<float>(rhs._data[0] * p * _vec[0]), 
-			static_cast<float>(rhs._data[0] * p * _vec[1]),
-			static_cast<float>(rhs._data[0] * p * _vec[2]), this->_vec[3] + _vec[3]);
+            static_cast<float>(rhs._data[0] * p * _vec[0]), 
+            static_cast<float>(rhs._data[0] * p * _vec[1]),
+            static_cast<float>(rhs._data[0] * p * _vec[2]), this->_vec[3] + _vec[3]);
     } else {
         double p = pow(k, ds);
         *this = PowerScaledCoordinate(
-			static_cast<float>(rhs._data[0] * _vec[0] * p), 
-			static_cast<float>(rhs._data[0] * _vec[1] * p),
-			static_cast<float>(rhs._data[0] * _vec[2] * p), rhs._data[1] + rhs._data[1]);
+            static_cast<float>(rhs._data[0] * _vec[0] * p), 
+            static_cast<float>(rhs._data[0] * _vec[1] * p),
+            static_cast<float>(rhs._data[0] * _vec[2] * p), rhs._data[1] + rhs._data[1]);
     }
     return *this;
 }
diff --git a/src/util/powerscaledscalar.cpp b/src/util/powerscaledscalar.cpp
index 8ffe681b7b..321542c4c5 100644
--- a/src/util/powerscaledscalar.cpp
+++ b/src/util/powerscaledscalar.cpp
@@ -42,222 +42,222 @@ PowerScaledScalar::PowerScaledScalar() : _data(0.f) {
 }
 
 PowerScaledScalar::PowerScaledScalar(const glm::vec2 &v) {
-	_data = std::move(v);
+    _data = std::move(v);
 }
 
 PowerScaledScalar::PowerScaledScalar(float f1, float f2) {
-	_data = glm::vec2(f1, f2);
+    _data = glm::vec2(f1, f2);
 }
 
 PowerScaledScalar PowerScaledScalar::CreatePSS(double d1) {
-	char buff[30];
+    char buff[30];
 
-	// find the number with maximum number of digits
+    // find the number with maximum number of digits
     double ad1 = std::abs(d1);
 
-	// find out how many digits
+    // find out how many digits
 #ifdef _MSC_VER
     sprintf_s(buff, 30, "%.0f", ad1);
 #else
     sprintf(buff, "%.0f", ad1);
 #endif
-	size_t digits = strlen(buff)-1;
+    size_t digits = strlen(buff)-1;
 
-	// rescale and return
-	double tp = 1.0 / pow(k, digits);
-	return PowerScaledScalar(static_cast<float>(d1*tp), static_cast<float>(digits));
+    // rescale and return
+    double tp = 1.0 / pow(k, digits);
+    return PowerScaledScalar(static_cast<float>(d1*tp), static_cast<float>(digits));
 }
 
 const glm::vec2& PowerScaledScalar::vec2() const {
-	return _data;
+    return _data;
 }
 
 float PowerScaledScalar::lengthf() const {
-	return static_cast<float>(_data[0] * pow(k,_data[1]));
+    return static_cast<float>(_data[0] * pow(k,_data[1]));
 }
 
 PowerScaledScalar& PowerScaledScalar::operator=(const PowerScaledScalar &rhs) {
-	if (this != &rhs){
-		this->_data = rhs._data;
-	}
-	return *this;  // Return a reference to myself.
+    if (this != &rhs){
+        this->_data = rhs._data;
+    }
+    return *this;  // Return a reference to myself.
 }
 
 PowerScaledScalar & PowerScaledScalar::operator=(const glm::vec2 &rhs) {
-	this->_data = glm::vec2(rhs);
-	return *this;  // Return a reference to myself.
+    this->_data = glm::vec2(rhs);
+    return *this;  // Return a reference to myself.
 }
 
 PowerScaledScalar & PowerScaledScalar::operator=(float rhs) {
-	this->_data = glm::vec2(rhs,0.0);
-	return *this;  // Return a reference to myself.
+    this->_data = glm::vec2(rhs,0.0);
+    return *this;  // Return a reference to myself.
 }
 
 PowerScaledScalar & PowerScaledScalar::operator+=(const PowerScaledScalar &rhs) {
 
-	double ds = this->_data[1] - rhs._data[1];
-	if(ds >= 0.0) {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs._data[0] * pow(k, -ds) + this->_data[0]), 
-			this->_data[1]);
-	} else {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs._data[0] + this->_data[0] * pow(k, ds)), 
-			rhs._data[1]);
-	}
+    double ds = this->_data[1] - rhs._data[1];
+    if(ds >= 0.0) {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs._data[0] * pow(k, -ds) + this->_data[0]), 
+            this->_data[1]);
+    } else {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs._data[0] + this->_data[0] * pow(k, ds)), 
+            rhs._data[1]);
+    }
 
-	return *this;
+    return *this;
 }
 
 const PowerScaledScalar PowerScaledScalar::operator+(const PowerScaledScalar &rhs) const {
-	return PowerScaledScalar(*this) += rhs;
+    return PowerScaledScalar(*this) += rhs;
 }
 
 PowerScaledScalar & PowerScaledScalar::operator-=(const PowerScaledScalar &rhs) {
 
-	double ds = this->_data[1] - rhs._data[1];
-	if(ds >= 0.0) {
-		*this = PowerScaledScalar(
-			static_cast<float>(-rhs._data[0] * pow(k, -ds) + this->_data[0]), 
-			this->_data[1]);
-	} else {
-		*this = PowerScaledScalar(
-			static_cast<float>(-rhs._data[0] + this->_data[0] * pow(k, ds)), 
-			rhs._data[1]);
-	}
+    double ds = this->_data[1] - rhs._data[1];
+    if(ds >= 0.0) {
+        *this = PowerScaledScalar(
+            static_cast<float>(-rhs._data[0] * pow(k, -ds) + this->_data[0]), 
+            this->_data[1]);
+    } else {
+        *this = PowerScaledScalar(
+            static_cast<float>(-rhs._data[0] + this->_data[0] * pow(k, ds)), 
+            rhs._data[1]);
+    }
 
-	return *this;
+    return *this;
 }
 
 const PowerScaledScalar PowerScaledScalar::operator-(const PowerScaledScalar &rhs) const {
-	return PowerScaledScalar(*this) -= rhs;
+    return PowerScaledScalar(*this) -= rhs;
 }
 
 PowerScaledScalar & PowerScaledScalar::operator*=(const PowerScaledScalar &rhs) {
-	double ds = this->_data[1] - rhs._data[1];
-	if(ds >= 0.0) {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs._data[0] * pow(k, -ds) * this->_data[0]), 
-			this->_data[1] + this->_data[1]);
-	} else {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs._data[0] * this->_data[0] * pow(k, ds)), 
-			rhs._data[1] + rhs._data[1]);
-	}
+    double ds = this->_data[1] - rhs._data[1];
+    if(ds >= 0.0) {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs._data[0] * pow(k, -ds) * this->_data[0]), 
+            this->_data[1] + this->_data[1]);
+    } else {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs._data[0] * this->_data[0] * pow(k, ds)), 
+            rhs._data[1] + rhs._data[1]);
+    }
 
-	return *this;
+    return *this;
 }
 
 
 const PowerScaledScalar PowerScaledScalar::operator*(const PowerScaledScalar &rhs) const {
-	return PowerScaledScalar(*this) *= rhs;
+    return PowerScaledScalar(*this) *= rhs;
 }
 
 
 PowerScaledScalar & PowerScaledScalar::operator*=(const float &rhs) {
-	double ds = this->_data[1];
-	if(ds >= 0) {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs*pow(k, -ds) * this->_data[0]), 
-			this->_data[1] + this->_data[1]);
-	} else {
-		*this = PowerScaledScalar(
-			static_cast<float>(rhs * this->_data[0] * pow(k, ds)), 0.0f);
-	}
+    double ds = this->_data[1];
+    if(ds >= 0) {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs*pow(k, -ds) * this->_data[0]), 
+            this->_data[1] + this->_data[1]);
+    } else {
+        *this = PowerScaledScalar(
+            static_cast<float>(rhs * this->_data[0] * pow(k, ds)), 0.0f);
+    }
 
-	return *this;
+    return *this;
 }
 
 const PowerScaledScalar PowerScaledScalar::operator*(const float &rhs) const {
-	return PowerScaledScalar(*this) *= rhs;
+    return PowerScaledScalar(*this) *= rhs;
 }
 
 float& PowerScaledScalar::operator[](unsigned int idx) {
-	return _data[idx];
+    return _data[idx];
 }
 
 float PowerScaledScalar::operator[](unsigned int idx) const {
-	return _data[idx];
+    return _data[idx];
 }
 
 bool PowerScaledScalar::operator==(const PowerScaledScalar &other) const {
-	return _data == other._data;
+    return _data == other._data;
 }
 
 bool PowerScaledScalar::operator<(const PowerScaledScalar &other) const {
-	double ds = this->_data[1] - other._data[1];
-	if(ds >= 0) {
-		double upscaled = other._data[0]*pow(k,-ds);
+    double ds = this->_data[1] - other._data[1];
+    if(ds >= 0) {
+        double upscaled = other._data[0]*pow(k,-ds);
         return _data[0] < upscaled;
         /*
         bool retur =(vec_[0] < upscaled);
         std::printf("this: %f, upscaled: %f, this<upscaled: %i\n", vec_[0], upscaled, retur);
-		return retur;
+        return retur;
         */
-	} else {
-		double upscaled = _data[0]*pow(k,-ds);
-		return other._data[0] > upscaled;
-	}
+    } else {
+        double upscaled = _data[0]*pow(k,-ds);
+        return other._data[0] > upscaled;
+    }
 }
 
 bool PowerScaledScalar::operator>(const PowerScaledScalar &other) const {
-	double ds = this->_data[1] - other._data[1];
-	if(ds >= 0) {
-		double upscaled = other._data[0]*pow(k,-ds);
-		return _data[0] > upscaled;
-	} else {
-		double upscaled = _data[0]*pow(k,-ds);
-		return other._data[0] < upscaled;
-	}
+    double ds = this->_data[1] - other._data[1];
+    if(ds >= 0) {
+        double upscaled = other._data[0]*pow(k,-ds);
+        return _data[0] > upscaled;
+    } else {
+        double upscaled = _data[0]*pow(k,-ds);
+        return other._data[0] < upscaled;
+    }
 }
 
 bool PowerScaledScalar::operator<=(const PowerScaledScalar &other) const {
-	return *this < other || *this == other;
+    return *this < other || *this == other;
 }
 
 bool PowerScaledScalar::operator>=(const PowerScaledScalar &other) const {
-	return *this > other || *this == other;
+    return *this > other || *this == other;
 }
 
 bool PowerScaledScalar::operator==(double other) const {
-	double ds = this->_data[1];
-	if(ds >= 0) {
-		double upscaled = other*pow(k,-ds);
-		return _data[0] == upscaled;
-	} else {
-		double upscaled = _data[0]*pow(k,-ds);
-		return other == upscaled;
-	}
+    double ds = this->_data[1];
+    if(ds >= 0) {
+        double upscaled = other*pow(k,-ds);
+        return _data[0] == upscaled;
+    } else {
+        double upscaled = _data[0]*pow(k,-ds);
+        return other == upscaled;
+    }
 }
 
 bool PowerScaledScalar::operator<(double other) const {
-	double ds = this->_data[1];
-	if(ds >= 0) {
-		double upscaled = other*pow(k,-ds);
-		return _data[0] < upscaled;
-	} else {
-		double upscaled = _data[0]*pow(k,-ds);
-		return other > upscaled;
-	}
+    double ds = this->_data[1];
+    if(ds >= 0) {
+        double upscaled = other*pow(k,-ds);
+        return _data[0] < upscaled;
+    } else {
+        double upscaled = _data[0]*pow(k,-ds);
+        return other > upscaled;
+    }
 }
 
 bool PowerScaledScalar::operator>(double other) const {
-	double ds = this->_data[1];
-	if(ds >= 0) {
-		double upscaled = other*pow(k,-ds);
-		return _data[0] > upscaled;
-	} else {
-		double upscaled = _data[0]*pow(k,-ds);
-		return other < upscaled;
-	}
+    double ds = this->_data[1];
+    if(ds >= 0) {
+        double upscaled = other*pow(k,-ds);
+        return _data[0] > upscaled;
+    } else {
+        double upscaled = _data[0]*pow(k,-ds);
+        return other < upscaled;
+    }
 }
 
 bool PowerScaledScalar::operator<=(double other) const {
-	return *this < other || *this == other;
+    return *this < other || *this == other;
 }
 
 bool PowerScaledScalar::operator>=(double other) const {
-	return *this > other || *this == other;
+    return *this > other || *this == other;
 }
 
 std::ostream& operator<<(::std::ostream& os, const PowerScaledScalar& rhs) {
diff --git a/src/util/powerscaledsphere.cpp b/src/util/powerscaledsphere.cpp
index 099d3bbade..8a8106a177 100644
--- a/src/util/powerscaledsphere.cpp
+++ b/src/util/powerscaledsphere.cpp
@@ -74,7 +74,7 @@ PowerScaledSphere::PowerScaledSphere(const PowerScaledScalar& radius, int segmen
             const float t1 = fj / fsegments;
             const float t2 = fi / fsegments;
 
-			//double tp = 1.0 / pow(10, static_cast<GLfloat>(radius[1]));
+            //double tp = 1.0 / pow(10, static_cast<GLfloat>(radius[1]));
 
             _varray[nr].location[0] = x;
             _varray[nr].location[1] = y;
@@ -108,37 +108,37 @@ PowerScaledSphere::PowerScaledSphere(const PowerScaledScalar& radius, int segmen
             ++nr;
             _iarray[nr] = t * (i - 1) + j + 1; //6
             ++nr;
-			
-			/*
-			_iarray[nr] = t * (i - 1) + j + 0; //1
-			++nr;
-			_iarray[nr] = t * (i + 0) + j + 0; //2 
-			++nr;
-			_iarray[nr] = t * (i + 0) + j + 1; //3
-			++nr;
-			_iarray[nr] = t * (i - 1) + j + 1; //6
-			++nr;
-			_iarray[nr] = t * (i - 1) + j + 0; //4 
-			++nr;
-			*/
+            
+            /*
+            _iarray[nr] = t * (i - 1) + j + 0; //1
+            ++nr;
+            _iarray[nr] = t * (i + 0) + j + 0; //2 
+            ++nr;
+            _iarray[nr] = t * (i + 0) + j + 1; //3
+            ++nr;
+            _iarray[nr] = t * (i - 1) + j + 1; //6
+            ++nr;
+            _iarray[nr] = t * (i - 1) + j + 0; //4 
+            ++nr;
+            */
         }
     }
 }
 
 // Alternative Constructor for using accurate triaxial ellipsoid 
 PowerScaledSphere::PowerScaledSphere(properties::Vec4Property &radius, int segments, std::string planetName)
-	: _vaoID(0)
-	, _vBufferID(0)
-	, _iBufferID(0)
-	, _isize(6 * segments * segments)
-	, _vsize((segments + 1) * (segments + 1))
-	, _varray(new Vertex[_vsize])
-	, _iarray(new int[_isize])
+    : _vaoID(0)
+    , _vBufferID(0)
+    , _iBufferID(0)
+    , _isize(6 * segments * segments)
+    , _vsize((segments + 1) * (segments + 1))
+    , _varray(new Vertex[_vsize])
+    , _iarray(new int[_isize])
 {
-	static_assert(sizeof(Vertex) == 64,
-		"The size of the Vertex needs to be 64 for performance");
+    static_assert(sizeof(Vertex) == 64,
+        "The size of the Vertex needs to be 64 for performance");
 
-	float a, b, c, powerscale;
+    float a, b, c, powerscale;
     bool accutareRadius;
     try {
         glm::dvec3 radii;
@@ -153,85 +153,85 @@ PowerScaledSphere::PowerScaledSphere(properties::Vec4Property &radius, int segme
         accutareRadius = false;
     }
     
-	if (accutareRadius) {
-		PowerScaledCoordinate powerScaledRadii = psc::CreatePowerScaledCoordinate(a, b, c);
-		powerScaledRadii[3] += 3; // SPICE returns radii in km
-		
-		std::swap(powerScaledRadii[1], powerScaledRadii[2]); // c is equivalent to y in our coordinate system
-		radius.set(powerScaledRadii.vec4());
-		a = powerScaledRadii[0];
-		b = powerScaledRadii[1];
-		c = powerScaledRadii[2];
-		powerscale = powerScaledRadii[3];
-	}
-	else {
+    if (accutareRadius) {
+        PowerScaledCoordinate powerScaledRadii = psc::CreatePowerScaledCoordinate(a, b, c);
+        powerScaledRadii[3] += 3; // SPICE returns radii in km
+        
+        std::swap(powerScaledRadii[1], powerScaledRadii[2]); // c is equivalent to y in our coordinate system
+        radius.set(powerScaledRadii.vec4());
+        a = powerScaledRadii[0];
+        b = powerScaledRadii[1];
+        c = powerScaledRadii[2];
+        powerscale = powerScaledRadii[3];
+    }
+    else {
         ghoul::any r = radius.get();
-		glm::vec4 modRadius = ghoul::any_cast<glm::vec4>(r);
-		a = modRadius[0];
-		b = modRadius[1];
-		c = modRadius[2];
-		powerscale = modRadius[3];
-	}
+        glm::vec4 modRadius = ghoul::any_cast<glm::vec4>(r);
+        a = modRadius[0];
+        b = modRadius[1];
+        c = modRadius[2];
+        powerscale = modRadius[3];
+    }
 
-	int nr = 0;
-	const float fsegments = static_cast<float>(segments);
+    int nr = 0;
+    const float fsegments = static_cast<float>(segments);
 
-	for (int i = 0; i <= segments; i++) {
-		// define an extra vertex around the y-axis due to texture mapping
-		for (int j = 0; j <= segments; j++) {
-			const float fi = static_cast<float>(i);
-			const float fj = static_cast<float>(j);
-			// inclination angle (north to south)
-			const float theta = fi * float(M_PI) / fsegments;  // 0 -> PI
-			// azimuth angle (east to west)
-			const float phi = fj * float(M_PI) * 2.0f / fsegments;  // 0 -> 2*PI
+    for (int i = 0; i <= segments; i++) {
+        // define an extra vertex around the y-axis due to texture mapping
+        for (int j = 0; j <= segments; j++) {
+            const float fi = static_cast<float>(i);
+            const float fj = static_cast<float>(j);
+            // inclination angle (north to south)
+            const float theta = fi * float(M_PI) / fsegments;  // 0 -> PI
+            // azimuth angle (east to west)
+            const float phi = fj * float(M_PI) * 2.0f / fsegments;  // 0 -> 2*PI
 
-			const float x = a * sin(phi) * sin(theta);  //
-			const float y = b * cos(theta);             // up
-			const float z = c * cos(phi) * sin(theta);  //
+            const float x = a * sin(phi) * sin(theta);  //
+            const float y = b * cos(theta);             // up
+            const float z = c * cos(phi) * sin(theta);  //
 
-			_varray[nr].location[0] = x;
-			_varray[nr].location[1] = y;
-			_varray[nr].location[2] = z;
-			_varray[nr].location[3] = powerscale;
+            _varray[nr].location[0] = x;
+            _varray[nr].location[1] = y;
+            _varray[nr].location[2] = z;
+            _varray[nr].location[3] = powerscale;
 
-			glm::vec3 normal = glm::vec3(x, y, z);
-			if (!(x == 0.f && y == 0.f && z == 0.f))
-				normal = glm::normalize(normal);
+            glm::vec3 normal = glm::vec3(x, y, z);
+            if (!(x == 0.f && y == 0.f && z == 0.f))
+                normal = glm::normalize(normal);
 
-			_varray[nr].normal[0] = normal[0];
-			_varray[nr].normal[1] = normal[1];
-			_varray[nr].normal[2] = normal[2];
+            _varray[nr].normal[0] = normal[0];
+            _varray[nr].normal[1] = normal[1];
+            _varray[nr].normal[2] = normal[2];
 
-			const float t1 = fj / fsegments;
-			const float t2 = fi / fsegments;
+            const float t1 = fj / fsegments;
+            const float t2 = fi / fsegments;
 
-			_varray[nr].tex[0] = t1;
-			_varray[nr].tex[1] = t2;
-			++nr;
-		}
-	}
+            _varray[nr].tex[0] = t1;
+            _varray[nr].tex[1] = t2;
+            ++nr;
+        }
+    }
 
-	nr = 0;
-	// define indices for all triangles
-	for (int i = 1; i <= segments; ++i) {
-		for (int j = 0; j < segments; ++j) {
-			const int t = segments + 1;
-			_iarray[nr] = t * (i - 1) + j + 0; //1
-			++nr;
-			_iarray[nr] = t * (i + 0) + j + 0; //2 
-			++nr;
-			_iarray[nr] = t * (i + 0) + j + 1; //3
-			++nr;
+    nr = 0;
+    // define indices for all triangles
+    for (int i = 1; i <= segments; ++i) {
+        for (int j = 0; j < segments; ++j) {
+            const int t = segments + 1;
+            _iarray[nr] = t * (i - 1) + j + 0; //1
+            ++nr;
+            _iarray[nr] = t * (i + 0) + j + 0; //2 
+            ++nr;
+            _iarray[nr] = t * (i + 0) + j + 1; //3
+            ++nr;
 
-			_iarray[nr] = t * (i - 1) + j + 0; //4 
-			++nr;
-			_iarray[nr] = t * (i + 0) + j + 1; //5
-			++nr;
-			_iarray[nr] = t * (i - 1) + j + 1; //6
-			++nr;
-		}
-	}
+            _iarray[nr] = t * (i - 1) + j + 0; //4 
+            ++nr;
+            _iarray[nr] = t * (i + 0) + j + 1; //5
+            ++nr;
+            _iarray[nr] = t * (i - 1) + j + 1; //6
+            ++nr;
+        }
+    }
 }
 
 PowerScaledSphere::PowerScaledSphere(const PowerScaledSphere& cpy) 
@@ -250,13 +250,13 @@ PowerScaledSphere::PowerScaledSphere(const PowerScaledSphere& cpy)
 }
 
 PowerScaledSphere::~PowerScaledSphere() {
-	if (_varray)
-	    delete[] _varray;
-	if (_iarray)
-	    delete[] _iarray;
+    if (_varray)
+        delete[] _varray;
+    if (_iarray)
+        delete[] _iarray;
 
-	_varray = 0;
-	_iarray = 0;
+    _varray = 0;
+    _iarray = 0;
 
     glDeleteBuffers(1, &_vBufferID);
     glDeleteBuffers(1, &_iBufferID);
diff --git a/src/util/progressbar.cpp b/src/util/progressbar.cpp
index 72e84af2b4..0b667d713c 100644
--- a/src/util/progressbar.cpp
+++ b/src/util/progressbar.cpp
@@ -29,30 +29,30 @@
 namespace openspace {
 
 ProgressBar::ProgressBar(int end, int width, std::ostream& stream)
-	: _width(width)
-	, _previous(-1)
-	, _end(end)
-	, _stream(stream) 
+    : _width(width)
+    , _previous(-1)
+    , _end(end)
+    , _stream(stream) 
 {
-	print(0);
+    print(0);
 }
 
 ProgressBar::~ProgressBar() {
-	_stream << "\n";
+    _stream << "\n";
 }
 
 void ProgressBar::print(int current) {
-	float progress = static_cast<float>(current) / static_cast<float>(_end - 1);
-	int iprogress = static_cast<int>(progress*100.0f);
-	if (iprogress != _previous) {
-		int pos = static_cast<int>(static_cast<float>(_width)* progress);
-		int eqWidth = pos + 1;
-		int spWidth = _width - pos + 2;
-		_stream << "[" << std::setfill('=') << std::setw(eqWidth)
-			<< ">" << std::setfill(' ') << std::setw(spWidth)
-			<< "] " << std::setfill(' ') << std::setw(3) << iprogress << " %  \r" << std::flush;
-	}
-	_previous = iprogress;
+    float progress = static_cast<float>(current) / static_cast<float>(_end - 1);
+    int iprogress = static_cast<int>(progress*100.0f);
+    if (iprogress != _previous) {
+        int pos = static_cast<int>(static_cast<float>(_width)* progress);
+        int eqWidth = pos + 1;
+        int spWidth = _width - pos + 2;
+        _stream << "[" << std::setfill('=') << std::setw(eqWidth)
+            << ">" << std::setfill(' ') << std::setw(spWidth)
+            << "] " << std::setfill(' ') << std::setw(3) << iprogress << " %  \r" << std::flush;
+    }
+    _previous = iprogress;
 };
 
 } // namespace openspace
\ No newline at end of file
diff --git a/src/util/spicemanager.cpp b/src/util/spicemanager.cpp
index a212f752d0..1b65a8329e 100644
--- a/src/util/spicemanager.cpp
+++ b/src/util/spicemanager.cpp
@@ -919,7 +919,7 @@ void SpiceManager::findSpkCoverage(const std::string& path) {
             _spkCoverageTimes[obj].insert(e);
             _spkCoverageTimes[obj].insert(b);
             _spkIntervals[obj].emplace_back(b, e);
-        }		
+        }        
     }
 }
     
diff --git a/src/util/syncbuffer.cpp b/src/util/syncbuffer.cpp
index d0a7645454..1d58478e52 100644
--- a/src/util/syncbuffer.cpp
+++ b/src/util/syncbuffer.cpp
@@ -27,25 +27,25 @@
 namespace openspace {
 
 SyncBuffer::SyncBuffer(size_t n)
-	: _n(n)
-	, _encodeOffset(0)
-	, _decodeOffset(0)
+    : _n(n)
+    , _encodeOffset(0)
+    , _decodeOffset(0)
 {
-	_dataStream.resize(_n);
+    _dataStream.resize(_n);
 }
 
 void SyncBuffer::write() {
-	_synchronizationBuffer.setVal(_dataStream);
-	sgct::SharedData::instance()->writeVector(&_synchronizationBuffer);
-	_encodeOffset = 0;
-	_decodeOffset = 0;
+    _synchronizationBuffer.setVal(_dataStream);
+    sgct::SharedData::instance()->writeVector(&_synchronizationBuffer);
+    _encodeOffset = 0;
+    _decodeOffset = 0;
 }
 
 void SyncBuffer::read() {
-	sgct::SharedData::instance()->readVector(&_synchronizationBuffer);
-	_dataStream = std::move(_synchronizationBuffer.getVal());
-	_encodeOffset = 0;
-	_decodeOffset = 0;
+    sgct::SharedData::instance()->readVector(&_synchronizationBuffer);
+    _dataStream = std::move(_synchronizationBuffer.getVal());
+    _encodeOffset = 0;
+    _decodeOffset = 0;
 }
 
 } // namespace openspace
\ No newline at end of file
diff --git a/src/util/time.cpp b/src/util/time.cpp
index 79303a668c..eb6b61efa8 100644
--- a/src/util/time.cpp
+++ b/src/util/time.cpp
@@ -53,31 +53,31 @@ Time& Time::ref() {
 }
 
 bool Time::isInitialized() {
-	return (_instance != nullptr);
+    return (_instance != nullptr);
 }
 
 void Time::setTime(double value, bool requireJump) {
-	_time = value;
-	_timeJumped = requireJump;
+    _time = value;
+    _timeJumped = requireJump;
 }
 
 double Time::currentTime() const {
-	return _syncedTime;
+    return _syncedTime;
 }
 
 double Time::advanceTime(double tickTime) {
     if (_timePaused)
         return _time;
     else
-	    return _time += _dt * tickTime;
+        return _time += _dt * tickTime;
 }
 
 void Time::setDeltaTime(double deltaT) {
-	_dt = deltaT;
+    _dt = deltaT;
 }
 
 double Time::deltaTime() const {
-	return _syncedDt;
+    return _syncedDt;
 }
 
 void Time::setPause(bool pause) {
@@ -91,7 +91,7 @@ bool Time::togglePause() {
 
 void Time::setTime(std::string time, bool requireJump) {
     _time = SpiceManager::ref().ephemerisTimeFromDate(std::move(time));
-	_timeJumped = requireJump;
+    _timeJumped = requireJump;
 }
 
 std::string Time::currentTimeUTC() const {
@@ -99,33 +99,33 @@ std::string Time::currentTimeUTC() const {
 }
 
 void Time::serialize(SyncBuffer* syncBuffer) {
-	_syncMutex.lock();
+    _syncMutex.lock();
 
-	syncBuffer->encode(_sharedTime);
-	syncBuffer->encode(_sharedDt);
-	syncBuffer->encode(_sharedTimeJumped);
+    syncBuffer->encode(_sharedTime);
+    syncBuffer->encode(_sharedDt);
+    syncBuffer->encode(_sharedTimeJumped);
 
-	_syncMutex.unlock();
+    _syncMutex.unlock();
 }
 
 void Time::deserialize(SyncBuffer* syncBuffer) {
-	_syncMutex.lock();
+    _syncMutex.lock();
 
-	syncBuffer->decode(_sharedTime);
-	syncBuffer->decode(_sharedDt);
-	syncBuffer->decode(_sharedTimeJumped);
+    syncBuffer->decode(_sharedTime);
+    syncBuffer->decode(_sharedDt);
+    syncBuffer->decode(_sharedTimeJumped);
 
     if (_sharedTimeJumped)
         _jockeHasToFixThisLater = true;
 
-	_syncMutex.unlock();
+    _syncMutex.unlock();
 }
 
 void Time::postSynchronizationPreDraw() {
-	_syncMutex.lock();
+    _syncMutex.lock();
 
-	_syncedTime = _sharedTime;
-	_syncedDt = _sharedDt;
+    _syncedTime = _sharedTime;
+    _syncedDt = _sharedDt;
     _syncedTimeJumped = _sharedTimeJumped;
 
     if (_jockeHasToFixThisLater) {
@@ -133,25 +133,25 @@ void Time::postSynchronizationPreDraw() {
         _jockeHasToFixThisLater = false;
     }
 
-	_syncMutex.unlock();	
+    _syncMutex.unlock();    
 }
 
 void Time::preSynchronization() {
-	_syncMutex.lock();
+    _syncMutex.lock();
 
-	_sharedTime = _time;
-	_sharedDt = _dt;
-	_sharedTimeJumped = _timeJumped;
+    _sharedTime = _time;
+    _sharedDt = _dt;
+    _sharedTimeJumped = _timeJumped;
 
-	_syncMutex.unlock();
+    _syncMutex.unlock();
 }
 
 bool Time::timeJumped() const {
-	return _syncedTimeJumped;
+    return _syncedTimeJumped;
 }
 
 void Time::setTimeJumped(bool jumped) {
-	_timeJumped = jumped;
+    _timeJumped = jumped;
 }
     
 bool Time::paused() const {
@@ -159,24 +159,24 @@ bool Time::paused() const {
 }
 
 scripting::ScriptEngine::LuaLibrary Time::luaLibrary() {
-	scripting::ScriptEngine::LuaLibrary timeLibrary = {
-		"time",
-		{
-			{
-				"setDeltaTime",
-				&luascriptfunctions::time_setDeltaTime,
-				"number",
-				"Sets the amount of simulation time that happens "
-				"in one second of real time",
+    scripting::ScriptEngine::LuaLibrary timeLibrary = {
+        "time",
+        {
+            {
+                "setDeltaTime",
+                &luascriptfunctions::time_setDeltaTime,
+                "number",
+                "Sets the amount of simulation time that happens "
+                "in one second of real time",
                 true
-			},
-			{
-				"deltaTime",
-				&luascriptfunctions::time_deltaTime,
-				"",
-				"Returns the amount of simulated time that passes in one "
-				"second of real time"
-			},
+            },
+            {
+                "deltaTime",
+                &luascriptfunctions::time_deltaTime,
+                "",
+                "Returns the amount of simulated time that passes in one "
+                "second of real time"
+            },
             {
                 "setPause",
                 &luascriptfunctions::time_setPause,
@@ -192,33 +192,33 @@ scripting::ScriptEngine::LuaLibrary Time::luaLibrary() {
                 " and restoring it afterwards",
                 true
             },
-			{
-				"setTime",
-				&luascriptfunctions::time_setTime,
-				"{number, string}",
-				"Sets the current simulation time to the "
-				"specified value. If the parameter is a number, the value is the number "
-				"of seconds past the J2000 epoch. If it is a string, it has to be a "
-				"valid ISO 8601 date string (YYYY-MM-DDTHH:MN:SS)",
+            {
+                "setTime",
+                &luascriptfunctions::time_setTime,
+                "{number, string}",
+                "Sets the current simulation time to the "
+                "specified value. If the parameter is a number, the value is the number "
+                "of seconds past the J2000 epoch. If it is a string, it has to be a "
+                "valid ISO 8601 date string (YYYY-MM-DDTHH:MN:SS)",
                 true
-			},
-			{
-				"currentTime",
-				&luascriptfunctions::time_currentTime,
-				"",
-				"Returns the current time as the number of seconds since "
-				"the J2000 epoch"
-			},
-			{
-				"currentTimeUTC",
-				&luascriptfunctions::time_currentTimeUTC,
-				"",
-				"Returns the current time as an ISO 8601 date string "
-				"(YYYY-MM-DDTHH:MN:SS)"
-			}
-		}
-	};
-	return timeLibrary;
+            },
+            {
+                "currentTime",
+                &luascriptfunctions::time_currentTime,
+                "",
+                "Returns the current time as the number of seconds since "
+                "the J2000 epoch"
+            },
+            {
+                "currentTimeUTC",
+                &luascriptfunctions::time_currentTimeUTC,
+                "",
+                "Returns the current time as an ISO 8601 date string "
+                "(YYYY-MM-DDTHH:MN:SS)"
+            }
+        }
+    };
+    return timeLibrary;
 }
 
 } // namespace openspace