ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

8 files changed, 1480 insertions, 1406 deletions

diff --git a/source/blender/freestyle/intern/application/AppCanvas.cpp b/source/blender/freestyle/intern/application/AppCanvas.cpp
index 7097dd80128..8248266bbf5 100644
--- a/source/blender/freestyle/intern/application/AppCanvas.cpp
+++ b/source/blender/freestyle/intern/application/AppCanvas.cpp
@@ -31,176 +31,174 @@
 
 namespace Freestyle {
 
-AppCanvas::AppCanvas()
-:Canvas()
+AppCanvas::AppCanvas() : Canvas()
 {
-	_pViewer = 0;
-	_MapsPath = Config::Path::getInstance()->getMapsDir().c_str();
+  _pViewer = 0;
+  _MapsPath = Config::Path::getInstance()->getMapsDir().c_str();
 }
 
-AppCanvas::AppCanvas(AppView *iViewer)
-:Canvas()
+AppCanvas::AppCanvas(AppView *iViewer) : Canvas()
 {
-	_pViewer = iViewer;
+  _pViewer = iViewer;
 }
 
-AppCanvas::AppCanvas(const AppCanvas& iBrother)
-:Canvas(iBrother)
+AppCanvas::AppCanvas(const AppCanvas &iBrother) : Canvas(iBrother)
 {
-	_pViewer = iBrother._pViewer;
+  _pViewer = iBrother._pViewer;
 }
 
 AppCanvas::~AppCanvas()
 {
-	_pViewer = 0;
+  _pViewer = 0;
 }
 
 void AppCanvas::setViewer(AppView *iViewer)
 {
-	_pViewer = iViewer;
+  _pViewer = iViewer;
 }
 
 int AppCanvas::width() const
 {
-	return _pViewer->width();
+  return _pViewer->width();
 }
 
 int AppCanvas::height() const
 {
-	return _pViewer->height();
+  return _pViewer->height();
 }
 
 BBox<Vec2i> AppCanvas::border() const
 {
-	return _pViewer->border();
+  return _pViewer->border();
 }
 
 float AppCanvas::thickness() const
 {
-	return _pViewer->thickness();
+  return _pViewer->thickness();
 }
 
 BBox<Vec3r> AppCanvas::scene3DBBox() const
 {
-	return _pViewer->scene3DBBox();
+  return _pViewer->scene3DBBox();
 }
 
 void AppCanvas::preDraw()
 {
-	Canvas::preDraw();
+  Canvas::preDraw();
 }
 
 void AppCanvas::init()
 {
 #if 0
-	static bool firsttime = true;
-	if (firsttime) {
-		_Renderer = new BlenderStrokeRenderer;
-		if (!StrokeRenderer::loadTextures()) {
-			cerr << "unable to load stroke textures" << endl;
-			return;
-		}
-	}
+  static bool firsttime = true;
+  if (firsttime) {
+    _Renderer = new BlenderStrokeRenderer;
+    if (!StrokeRenderer::loadTextures()) {
+      cerr << "unable to load stroke textures" << endl;
+      return;
+    }
+  }
 #endif
 }
 
 void AppCanvas::postDraw()
 {
-	for (unsigned int i = 0; i < _StyleModules.size(); i++) {
-		if (!_StyleModules[i]->getDisplayed() || !_Layers[i])
-			continue;
-		_Layers[i]->ScaleThickness(thickness());
-	}
-	Canvas::postDraw();
+  for (unsigned int i = 0; i < _StyleModules.size(); i++) {
+    if (!_StyleModules[i]->getDisplayed() || !_Layers[i])
+      continue;
+    _Layers[i]->ScaleThickness(thickness());
+  }
+  Canvas::postDraw();
 }
 
 void AppCanvas::Erase()
 {
-	Canvas::Erase();
+  Canvas::Erase();
 }
 
 // Abstract
 
-void AppCanvas::readColorPixels(int x, int y, int w, int h, RGBImage& oImage) const
-{
-	float *rgb = new float[3 * w * h];
-	memset(rgb, 0, sizeof(float) * 3 * w * h);
-	int xsch = width();
-	int ysch = height();
-	if (_pass_diffuse.buf) {
-		int xmin = border().getMin().x();
-		int ymin = border().getMin().y();
-		int xmax = border().getMax().x();
-		int ymax = border().getMax().y();
-		int rectx = _pass_diffuse.width;
-		int recty = _pass_diffuse.height;
-		float xfac = ((float)rectx) / ((float)(xmax - xmin));
-		float yfac = ((float)recty) / ((float)(ymax - ymin));
+void AppCanvas::readColorPixels(int x, int y, int w, int h, RGBImage &oImage) const
+{
+  float *rgb = new float[3 * w * h];
+  memset(rgb, 0, sizeof(float) * 3 * w * h);
+  int xsch = width();
+  int ysch = height();
+  if (_pass_diffuse.buf) {
+    int xmin = border().getMin().x();
+    int ymin = border().getMin().y();
+    int xmax = border().getMax().x();
+    int ymax = border().getMax().y();
+    int rectx = _pass_diffuse.width;
+    int recty = _pass_diffuse.height;
+    float xfac = ((float)rectx) / ((float)(xmax - xmin));
+    float yfac = ((float)recty) / ((float)(ymax - ymin));
 #if 0
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			printf("readColorPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
-			       xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
-		}
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      printf("readColorPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
+             xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
+    }
 #endif
-		int ii, jj;
-		for (int j = 0; j < h; j++) {
-			jj = (int)((y - ymin + j) * yfac);
-			if (jj < 0 || jj >= recty)
-				continue;
-			for (int i = 0; i < w; i++) {
-				ii = (int)((x - xmin + i) * xfac);
-				if (ii < 0 || ii >= rectx)
-					continue;
-				memcpy(rgb + (w * j + i) * 3, _pass_diffuse.buf + (rectx * jj + ii) * 3, sizeof(float) * 3);
-			}
-		}
-	}
-	oImage.setArray(rgb, xsch, ysch, w, h, x, y, false);
-}
-
-void AppCanvas::readDepthPixels(int x, int y, int w, int h, GrayImage& oImage) const
-{
-	float *z = new float[w * h];
-	memset(z, 0, sizeof(float) * w * h);
-	int xsch = width();
-	int ysch = height();
-	if (_pass_z.buf) {
-		int xmin = border().getMin().x();
-		int ymin = border().getMin().y();
-		int xmax = border().getMax().x();
-		int ymax = border().getMax().y();
-		int rectx = _pass_z.width;
-		int recty = _pass_z.height;
-		float xfac = ((float)rectx) / ((float)(xmax - xmin));
-		float yfac = ((float)recty) / ((float)(ymax - ymin));
+    int ii, jj;
+    for (int j = 0; j < h; j++) {
+      jj = (int)((y - ymin + j) * yfac);
+      if (jj < 0 || jj >= recty)
+        continue;
+      for (int i = 0; i < w; i++) {
+        ii = (int)((x - xmin + i) * xfac);
+        if (ii < 0 || ii >= rectx)
+          continue;
+        memcpy(
+            rgb + (w * j + i) * 3, _pass_diffuse.buf + (rectx * jj + ii) * 3, sizeof(float) * 3);
+      }
+    }
+  }
+  oImage.setArray(rgb, xsch, ysch, w, h, x, y, false);
+}
+
+void AppCanvas::readDepthPixels(int x, int y, int w, int h, GrayImage &oImage) const
+{
+  float *z = new float[w * h];
+  memset(z, 0, sizeof(float) * w * h);
+  int xsch = width();
+  int ysch = height();
+  if (_pass_z.buf) {
+    int xmin = border().getMin().x();
+    int ymin = border().getMin().y();
+    int xmax = border().getMax().x();
+    int ymax = border().getMax().y();
+    int rectx = _pass_z.width;
+    int recty = _pass_z.height;
+    float xfac = ((float)rectx) / ((float)(xmax - xmin));
+    float yfac = ((float)recty) / ((float)(ymax - ymin));
 #if 0
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			printf("readDepthPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
-			       xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
-		}
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      printf("readDepthPixels %d x %d @ (%d, %d) in %d x %d [%d x %d] -- %d x %d @ %d%%\n", w, h, x, y,
+             xsch, ysch, xmax - xmin, ymax - ymin, rectx, recty, (int)(xfac * 100.0f));
+    }
 #endif
-		int ii, jj;
-		for (int j = 0; j < h; j++) {
-			jj = (int)((y - ymin + j) * yfac);
-			if (jj < 0 || jj >= recty)
-				continue;
-			for (int i = 0; i < w; i++) {
-				ii = (int)((x - xmin + i) * xfac);
-				if (ii < 0 || ii >= rectx)
-					continue;
-				z[w * j + i] = _pass_z.buf[rectx * jj + ii];
-			}
-		}
-	}
-	oImage.setArray(z, xsch, ysch, w, h, x, y, false);
+    int ii, jj;
+    for (int j = 0; j < h; j++) {
+      jj = (int)((y - ymin + j) * yfac);
+      if (jj < 0 || jj >= recty)
+        continue;
+      for (int i = 0; i < w; i++) {
+        ii = (int)((x - xmin + i) * xfac);
+        if (ii < 0 || ii >= rectx)
+          continue;
+        z[w * j + i] = _pass_z.buf[rectx * jj + ii];
+      }
+    }
+  }
+  oImage.setArray(z, xsch, ysch, w, h, x, y, false);
 }
 
 void AppCanvas::RenderStroke(Stroke *iStroke)
 {
-	if (_basic)
-		iStroke->RenderBasic(_Renderer);
-	else
-		iStroke->Render(_Renderer);
+  if (_basic)
+    iStroke->RenderBasic(_Renderer);
+  else
+    iStroke->Render(_Renderer);
 }
 
 void AppCanvas::update()
diff --git a/source/blender/freestyle/intern/application/AppCanvas.h b/source/blender/freestyle/intern/application/AppCanvas.h
index e891a661606..9d1e2458564 100644
--- a/source/blender/freestyle/intern/application/AppCanvas.h
+++ b/source/blender/freestyle/intern/application/AppCanvas.h
@@ -26,69 +26,72 @@
 
 namespace Freestyle {
 
-class AppCanvas : public Canvas
-{
-public:
-	AppCanvas();
-	AppCanvas(AppView *iViewer);
-	AppCanvas(const AppCanvas& iBrother);
-	virtual ~AppCanvas();
-
-	/*! operations that need to be done before a draw */
-	virtual void preDraw();
-
-	/*! operations that need to be done after a draw */
-	virtual void postDraw();
-
-	/*! Erases the layers and clears the canvas */
-	virtual void Erase();
-
-	/* init the canvas */
-	virtual void init();
-
-	/*! Reads a pixel area from the canvas */
-	virtual void readColorPixels(int x, int y, int w, int h, RGBImage& oImage) const;
-	/*! Reads a depth pixel area from the canvas */
-	virtual void readDepthPixels(int x, int y, int w, int h, GrayImage& oImage) const;
-
-	virtual BBox<Vec3r> scene3DBBox() const;
-
-	/* abstract */
-	virtual void RenderStroke(Stroke *);
-	virtual void update();
-
-
-	/*! accessors */
-	virtual int width() const;
-	virtual int height() const;
-	virtual BBox<Vec2i> border() const;
-	virtual float thickness() const;
-
-	AppView *_pViewer;
-	inline const AppView *viewer() const {return _pViewer;}
-
-	/*! modifiers */
-	void setViewer(AppView *iViewer);
-
-	/* soc */
-	void setPassDiffuse(float *buf, int width, int height) {
-		_pass_diffuse.buf = buf;
-		_pass_diffuse.width = width;
-		_pass_diffuse.height = height;
-	}
-	void setPassZ(float *buf, int width, int height) {
-		_pass_z.buf = buf;
-		_pass_z.width = width;
-		_pass_z.height = height;
-	}
-
-private:
-	struct {
-		float *buf;
-		int width, height;
-	} _pass_diffuse, _pass_z;
+class AppCanvas : public Canvas {
+ public:
+  AppCanvas();
+  AppCanvas(AppView *iViewer);
+  AppCanvas(const AppCanvas &iBrother);
+  virtual ~AppCanvas();
+
+  /*! operations that need to be done before a draw */
+  virtual void preDraw();
+
+  /*! operations that need to be done after a draw */
+  virtual void postDraw();
+
+  /*! Erases the layers and clears the canvas */
+  virtual void Erase();
+
+  /* init the canvas */
+  virtual void init();
+
+  /*! Reads a pixel area from the canvas */
+  virtual void readColorPixels(int x, int y, int w, int h, RGBImage &oImage) const;
+  /*! Reads a depth pixel area from the canvas */
+  virtual void readDepthPixels(int x, int y, int w, int h, GrayImage &oImage) const;
+
+  virtual BBox<Vec3r> scene3DBBox() const;
+
+  /* abstract */
+  virtual void RenderStroke(Stroke *);
+  virtual void update();
+
+  /*! accessors */
+  virtual int width() const;
+  virtual int height() const;
+  virtual BBox<Vec2i> border() const;
+  virtual float thickness() const;
+
+  AppView *_pViewer;
+  inline const AppView *viewer() const
+  {
+    return _pViewer;
+  }
+
+  /*! modifiers */
+  void setViewer(AppView *iViewer);
+
+  /* soc */
+  void setPassDiffuse(float *buf, int width, int height)
+  {
+    _pass_diffuse.buf = buf;
+    _pass_diffuse.width = width;
+    _pass_diffuse.height = height;
+  }
+  void setPassZ(float *buf, int width, int height)
+  {
+    _pass_z.buf = buf;
+    _pass_z.width = width;
+    _pass_z.height = height;
+  }
+
+ private:
+  struct {
+    float *buf;
+    int width, height;
+  } _pass_diffuse, _pass_z;
 };
 
 } /* namespace Freestyle */
 
-#endif // __APPCANVAS_H__
+#endif  // __APPCANVAS_H__
diff --git a/source/blender/freestyle/intern/application/AppConfig.cpp b/source/blender/freestyle/intern/application/AppConfig.cpp
index 20d8c68ef0e..3e3a939a8fe 100644
--- a/source/blender/freestyle/intern/application/AppConfig.cpp
+++ b/source/blender/freestyle/intern/application/AppConfig.cpp
@@ -37,61 +37,62 @@ namespace Config {
 Path *Path::_pInstance = 0;
 Path::Path()
 {
-	// get the root directory
-	// soc
-	setRootDir(BKE_appdir_folder_id(BLENDER_SYSTEM_SCRIPTS, NULL));
+  // get the root directory
+  // soc
+  setRootDir(BKE_appdir_folder_id(BLENDER_SYSTEM_SCRIPTS, NULL));
 
-	_pInstance = this;
+  _pInstance = this;
 }
 
-void Path::setRootDir(const string& iRootDir)
+void Path::setRootDir(const string &iRootDir)
 {
-	_ProjectDir = iRootDir + string(DIR_SEP.c_str()) + "freestyle";
-	_ModelsPath = "";
-	_PatternsPath = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) + "textures" +
-	                string(DIR_SEP.c_str()) + "variation_patterns" + string(DIR_SEP.c_str());
-	_BrushesPath = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) + "textures" +
-	               string(DIR_SEP.c_str()) + "brushes" + string(DIR_SEP.c_str());
-	_PythonPath = _ProjectDir + string(DIR_SEP.c_str()) + "modules" + string(DIR_SEP.c_str());
-	if (getenv("PYTHONPATH")) {
-		_PythonPath += string(PATH_SEP.c_str()) + string(getenv("PYTHONPATH"));
-	}
-	_EnvMapDir = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) + "env_map" +
-	             string(DIR_SEP.c_str());
-	_MapsDir = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) + "maps" +
-	           string(DIR_SEP.c_str());
+  _ProjectDir = iRootDir + string(DIR_SEP.c_str()) + "freestyle";
+  _ModelsPath = "";
+  _PatternsPath = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) +
+                  "textures" + string(DIR_SEP.c_str()) + "variation_patterns" +
+                  string(DIR_SEP.c_str());
+  _BrushesPath = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) +
+                 "textures" + string(DIR_SEP.c_str()) + "brushes" + string(DIR_SEP.c_str());
+  _PythonPath = _ProjectDir + string(DIR_SEP.c_str()) + "modules" + string(DIR_SEP.c_str());
+  if (getenv("PYTHONPATH")) {
+    _PythonPath += string(PATH_SEP.c_str()) + string(getenv("PYTHONPATH"));
+  }
+  _EnvMapDir = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) +
+               "env_map" + string(DIR_SEP.c_str());
+  _MapsDir = _ProjectDir + string(DIR_SEP.c_str()) + "data" + string(DIR_SEP.c_str()) + "maps" +
+             string(DIR_SEP.c_str());
 }
 
-void Path::setHomeDir(const string& iHomeDir)
+void Path::setHomeDir(const string &iHomeDir)
 {
-	_HomeDir = iHomeDir;
+  _HomeDir = iHomeDir;
 }
 
 Path::~Path()
 {
-	_pInstance = 0;
+  _pInstance = 0;
 }
 
 Path *Path::getInstance()
 {
-	return _pInstance;
+  return _pInstance;
 }
 
-string Path::getEnvVar(const string& iEnvVarName)
+string Path::getEnvVar(const string &iEnvVarName)
 {
-	string value;
-	if (!getenv(iEnvVarName.c_str())) {
-		cerr << "Warning: You may want to set the $" << iEnvVarName <<
-		        " environment variable to use Freestyle." << endl <<
-		        "         Otherwise, the current directory will be used instead." << endl;
-		value = ".";
-	}
-	else {
-		value = getenv(iEnvVarName.c_str());
-	}
-	return value;
+  string value;
+  if (!getenv(iEnvVarName.c_str())) {
+    cerr << "Warning: You may want to set the $" << iEnvVarName
+         << " environment variable to use Freestyle." << endl
+         << "         Otherwise, the current directory will be used instead." << endl;
+    value = ".";
+  }
+  else {
+    value = getenv(iEnvVarName.c_str());
+  }
+  return value;
 }
 
-} // End of namepace Config
+}  // namespace Config
 
 } /* namespace Freestyle */
diff --git a/source/blender/freestyle/intern/application/AppConfig.h b/source/blender/freestyle/intern/application/AppConfig.h
index c9eeca457eb..cc2a3962ecd 100644
--- a/source/blender/freestyle/intern/application/AppConfig.h
+++ b/source/blender/freestyle/intern/application/AppConfig.h
@@ -27,7 +27,7 @@
 #include "../system/Precision.h"
 
 #ifdef WITH_CXX_GUARDEDALLOC
-#include "MEM_guardedalloc.h"
+#  include "MEM_guardedalloc.h"
 #endif
 
 using namespace std;
@@ -37,38 +37,62 @@ namespace Freestyle {
 namespace Config {
 
 class Path {
-protected:
-	static Path *_pInstance;
-	string _ProjectDir;
-	string _ModelsPath;
-	string _PatternsPath;
-	string _BrushesPath;
-	string _PythonPath;
-	string _EnvMapDir;
-	string _MapsDir;
-	string _HomeDir;
-
-public:
-	Path();
-	virtual ~Path();
-	static Path *getInstance();
-
-	void setRootDir(const string& iRootDir);
-	void setHomeDir(const string& iHomeDir);
-
-	const string& getProjectDir() const {return _ProjectDir;}
-	const string& getModelsPath() const {return _ModelsPath;}
-	const string& getPatternsPath() const {return _PatternsPath;}
-	const string& getBrushesPath() const {return _BrushesPath;}
-	const string& getPythonPath() const {return _PythonPath;}
-	const string& getEnvMapDir() const {return _EnvMapDir;}
-	const string& getMapsDir() const {return _MapsDir;}
-	const string& getHomeDir() const {return _HomeDir;}
-
-	static string getEnvVar(const string& iEnvVarName);
+ protected:
+  static Path *_pInstance;
+  string _ProjectDir;
+  string _ModelsPath;
+  string _PatternsPath;
+  string _BrushesPath;
+  string _PythonPath;
+  string _EnvMapDir;
+  string _MapsDir;
+  string _HomeDir;
+
+ public:
+  Path();
+  virtual ~Path();
+  static Path *getInstance();
+
+  void setRootDir(const string &iRootDir);
+  void setHomeDir(const string &iHomeDir);
+
+  const string &getProjectDir() const
+  {
+    return _ProjectDir;
+  }
+  const string &getModelsPath() const
+  {
+    return _ModelsPath;
+  }
+  const string &getPatternsPath() const
+  {
+    return _PatternsPath;
+  }
+  const string &getBrushesPath() const
+  {
+    return _BrushesPath;
+  }
+  const string &getPythonPath() const
+  {
+    return _PythonPath;
+  }
+  const string &getEnvMapDir() const
+  {
+    return _EnvMapDir;
+  }
+  const string &getMapsDir() const
+  {
+    return _MapsDir;
+  }
+  const string &getHomeDir() const
+  {
+    return _HomeDir;
+  }
+
+  static string getEnvVar(const string &iEnvVarName);
 
 #ifdef WITH_CXX_GUARDEDALLOC
-	MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Config:Path")
+  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Config:Path")
 #endif
 };
 
@@ -100,8 +124,8 @@ static const string OPTIONS_QGLVIEWER_FILE("qglviewer.xml");
 static const real DEFAULT_SPHERE_RADIUS = 1.0;
 static const real DEFAULT_DKR_EPSILON = 0.0;
 
-} // End of namepace Config
+}  // namespace Config
 
 } /* namespace Freestyle */
 
-#endif // __APP_CONFIG_H__
+#endif  // __APP_CONFIG_H__
diff --git a/source/blender/freestyle/intern/application/AppView.cpp b/source/blender/freestyle/intern/application/AppView.cpp
index 12b4f3db93a..e352e77f7ea 100644
--- a/source/blender/freestyle/intern/application/AppView.cpp
+++ b/source/blender/freestyle/intern/application/AppView.cpp
@@ -38,7 +38,7 @@ extern "C" {
 #include "IMB_imbuf.h"
 #include "IMB_imbuf_types.h"
 
-#if 1 // FRS_antialiasing
+#if 1  // FRS_antialiasing
 #  include "BKE_global.h"
 #  include "DNA_scene_types.h"
 #endif
@@ -50,136 +50,126 @@ namespace Freestyle {
 
 AppView::AppView(const char * /*iName*/)
 {
-	_Fovy = DEG2RADF(30.0f);
-	_ModelRootNode = new NodeDrawingStyle;
-	_SilhouetteRootNode = new NodeDrawingStyle;
-	_DebugRootNode = new NodeDrawingStyle;
+  _Fovy = DEG2RADF(30.0f);
+  _ModelRootNode = new NodeDrawingStyle;
+  _SilhouetteRootNode = new NodeDrawingStyle;
+  _DebugRootNode = new NodeDrawingStyle;
 
-	_RootNode.AddChild(_ModelRootNode);
-	_SilhouetteRootNode->setStyle(DrawingStyle::LINES);
-	_SilhouetteRootNode->setLightingEnabled(false);
-	_SilhouetteRootNode->setLineWidth(2.0f);
-	_SilhouetteRootNode->setPointSize(3.0f);
+  _RootNode.AddChild(_ModelRootNode);
+  _SilhouetteRootNode->setStyle(DrawingStyle::LINES);
+  _SilhouetteRootNode->setLightingEnabled(false);
+  _SilhouetteRootNode->setLineWidth(2.0f);
+  _SilhouetteRootNode->setPointSize(3.0f);
 
-	_RootNode.AddChild(_SilhouetteRootNode);
+  _RootNode.AddChild(_SilhouetteRootNode);
 
-	_DebugRootNode->setStyle(DrawingStyle::LINES);
-	_DebugRootNode->setLightingEnabled(false);
-	_DebugRootNode->setLineWidth(1.0f);
+  _DebugRootNode->setStyle(DrawingStyle::LINES);
+  _DebugRootNode->setLightingEnabled(false);
+  _DebugRootNode->setLineWidth(1.0f);
 
-	_RootNode.AddChild(_DebugRootNode);
+  _RootNode.AddChild(_DebugRootNode);
 
-	_minBBox = std::min(std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
-	                    _ModelRootNode->bbox().getMin()[2]);
-	_maxBBox = std::max(std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
-	                    _ModelRootNode->bbox().getMax()[2]);
+  _minBBox = std::min(
+      std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
+      _ModelRootNode->bbox().getMin()[2]);
+  _maxBBox = std::max(
+      std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
+      _ModelRootNode->bbox().getMax()[2]);
 
-	_maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
-	_minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
+  _maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
+  _minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
 
-	_p2DSelectionNode = new NodeDrawingStyle;
-	_p2DSelectionNode->setLightingEnabled(false);
-	_p2DSelectionNode->setStyle(DrawingStyle::LINES);
-	_p2DSelectionNode->setLineWidth(5.0f);
+  _p2DSelectionNode = new NodeDrawingStyle;
+  _p2DSelectionNode->setLightingEnabled(false);
+  _p2DSelectionNode->setStyle(DrawingStyle::LINES);
+  _p2DSelectionNode->setLineWidth(5.0f);
 
-	_p2DNode.AddChild(_p2DSelectionNode);
+  _p2DNode.AddChild(_p2DSelectionNode);
 
-	NodeLight *light = new NodeLight;
-	_Light.AddChild(light);
+  NodeLight *light = new NodeLight;
+  _Light.AddChild(light);
 }
 
 AppView::~AppView()
 {
-	/*int ref =*/ /* UNUSED */ _RootNode.destroy();
+  /*int ref =*//* UNUSED */ _RootNode.destroy();
 
-	_Light.destroy();
-	/*ref =*/ /* UNUSED */ _p2DNode.destroy();
+  _Light.destroy();
+  /*ref =*//* UNUSED */ _p2DNode.destroy();
 }
 
 real AppView::distanceToSceneCenter()
 {
-	BBox<Vec3r> bbox = _ModelRootNode->bbox();
+  BBox<Vec3r> bbox = _ModelRootNode->bbox();
 
-	Vec3r v(UNPACK3(g_freestyle.viewpoint));
-	v -= 0.5 * (bbox.getMin() + bbox.getMax());
+  Vec3r v(UNPACK3(g_freestyle.viewpoint));
+  v -= 0.5 * (bbox.getMin() + bbox.getMax());
 
-	return v.norm();
+  return v.norm();
 }
 
 real AppView::znear()
 {
-	BBox<Vec3r> bbox = _ModelRootNode->bbox();
-	Vec3r u = bbox.getMin();
-	Vec3r v = bbox.getMax();
-	Vec3r cameraCenter(UNPACK3(g_freestyle.viewpoint));
-
-	Vec3r w1(u[0], u[1], u[2]);
-	Vec3r w2(v[0], u[1], u[2]);
-	Vec3r w3(u[0], v[1], u[2]);
-	Vec3r w4(v[0], v[1], u[2]);
-	Vec3r w5(u[0], u[1], v[2]);
-	Vec3r w6(v[0], u[1], v[2]);
-	Vec3r w7(u[0], v[1], v[2]);
-	Vec3r w8(v[0], v[1], v[2]);
-
-	real _znear = std::min((w1 - cameraCenter).norm(),
-	                       std::min((w2 - cameraCenter).norm(),
-	                                std::min((w3 - cameraCenter).norm(),
-	                                         std::min((w4 - cameraCenter).norm(),
-	                                                  std::min((w5 - cameraCenter).norm(),
-	                                                           std::min((w6 - cameraCenter).norm(),
-	                                                                    std::min((w7 - cameraCenter).norm(),
-	                                                                             (w8 - cameraCenter).norm()
-	                                                                            )
-	                                                                   )
-	                                                          )
-	                                                 )
-	                                        )
-	                               )
-	                      );
-
-	return std::max(_znear, 0.001);
+  BBox<Vec3r> bbox = _ModelRootNode->bbox();
+  Vec3r u = bbox.getMin();
+  Vec3r v = bbox.getMax();
+  Vec3r cameraCenter(UNPACK3(g_freestyle.viewpoint));
+
+  Vec3r w1(u[0], u[1], u[2]);
+  Vec3r w2(v[0], u[1], u[2]);
+  Vec3r w3(u[0], v[1], u[2]);
+  Vec3r w4(v[0], v[1], u[2]);
+  Vec3r w5(u[0], u[1], v[2]);
+  Vec3r w6(v[0], u[1], v[2]);
+  Vec3r w7(u[0], v[1], v[2]);
+  Vec3r w8(v[0], v[1], v[2]);
+
+  real _znear = std::min(
+      (w1 - cameraCenter).norm(),
+      std::min((w2 - cameraCenter).norm(),
+               std::min((w3 - cameraCenter).norm(),
+                        std::min((w4 - cameraCenter).norm(),
+                                 std::min((w5 - cameraCenter).norm(),
+                                          std::min((w6 - cameraCenter).norm(),
+                                                   std::min((w7 - cameraCenter).norm(),
+                                                            (w8 - cameraCenter).norm())))))));
+
+  return std::max(_znear, 0.001);
 }
 
 real AppView::zfar()
 {
-	BBox<Vec3r> bbox = _ModelRootNode->bbox();
-	Vec3r u = bbox.getMin();
-	Vec3r v = bbox.getMax();
-	Vec3r cameraCenter(UNPACK3(g_freestyle.viewpoint));
-
-	Vec3r w1(u[0], u[1], u[2]);
-	Vec3r w2(v[0], u[1], u[2]);
-	Vec3r w3(u[0], v[1], u[2]);
-	Vec3r w4(v[0], v[1], u[2]);
-	Vec3r w5(u[0], u[1], v[2]);
-	Vec3r w6(v[0], u[1], v[2]);
-	Vec3r w7(u[0], v[1], v[2]);
-	Vec3r w8(v[0], v[1], v[2]);
-
-	real _zfar = std::max((w1 - cameraCenter).norm(),
-	                      std::max((w2 - cameraCenter).norm(),
-	                               std::max((w3 - cameraCenter).norm(),
-	                                        std::max((w4 - cameraCenter).norm(),
-	                                                 std::max((w5 - cameraCenter).norm(),
-	                                                          std::max((w6 - cameraCenter).norm(),
-	                                                                   std::max((w7 - cameraCenter).norm(),
-	                                                                            (w8 - cameraCenter).norm()
-	                                                                           )
-	                                                                  )
-	                                                         )
-	                                                )
-	                                       )
-	                              )
-	                     );
-
-	return _zfar;
+  BBox<Vec3r> bbox = _ModelRootNode->bbox();
+  Vec3r u = bbox.getMin();
+  Vec3r v = bbox.getMax();
+  Vec3r cameraCenter(UNPACK3(g_freestyle.viewpoint));
+
+  Vec3r w1(u[0], u[1], u[2]);
+  Vec3r w2(v[0], u[1], u[2]);
+  Vec3r w3(u[0], v[1], u[2]);
+  Vec3r w4(v[0], v[1], u[2]);
+  Vec3r w5(u[0], u[1], v[2]);
+  Vec3r w6(v[0], u[1], v[2]);
+  Vec3r w7(u[0], v[1], v[2]);
+  Vec3r w8(v[0], v[1], v[2]);
+
+  real _zfar = std::max(
+      (w1 - cameraCenter).norm(),
+      std::max((w2 - cameraCenter).norm(),
+               std::max((w3 - cameraCenter).norm(),
+                        std::max((w4 - cameraCenter).norm(),
+                                 std::max((w5 - cameraCenter).norm(),
+                                          std::max((w6 - cameraCenter).norm(),
+                                                   std::max((w7 - cameraCenter).norm(),
+                                                            (w8 - cameraCenter).norm())))))));
+
+  return _zfar;
 }
 
 real AppView::GetFocalLength()
 {
-	real Near = std::max(0.1, (real)(-2.0f * _maxAbs + distanceToSceneCenter()));
-	return Near;
+  real Near = std::max(0.1, (real)(-2.0f * _maxAbs + distanceToSceneCenter()));
+  return Near;
 }
 
 } /* namespace Freestyle */
diff --git a/source/blender/freestyle/intern/application/AppView.h b/source/blender/freestyle/intern/application/AppView.h
index 3939d96cf16..0b029895b8c 100644
--- a/source/blender/freestyle/intern/application/AppView.h
+++ b/source/blender/freestyle/intern/application/AppView.h
@@ -30,212 +30,246 @@
 #include "BLI_math.h"
 
 #ifdef WITH_CXX_GUARDEDALLOC
-#include "MEM_guardedalloc.h"
+#  include "MEM_guardedalloc.h"
 #endif
 
 namespace Freestyle {
 
 using namespace Geometry;
 
-class AppView
-{
-public:
-	AppView(const char *iName = 0);
-	virtual ~AppView();
-
-public:
-	//inherited
-	inline unsigned int width() {return _width;}
-	inline unsigned int height() {return _height;}
-	inline BBox<Vec2i> border() {return _border;}
-	inline float thickness() {return _thickness;}
-	inline void setWidth(unsigned int width) {_width = width;}
-	inline void setHeight(unsigned int height) {_height = height;}
-	inline void setBorder(int xmin, int ymin, int xmax, int ymax) {
-		_border = BBox<Vec2i>(Vec2i(xmin, ymin), Vec2i(xmax, ymax));
-	}
-	inline void setThickness(float thickness) {_thickness = thickness;}
-
-protected:
-	unsigned int _width, _height;
-	BBox<Vec2i> _border;
-	float _thickness;
-
-public:
-	/*! Sets the model to draw in the viewer
-	 *  iModel
-	 *    The Root Node of the model
-	 */
-	inline void setModel(NodeGroup *iModel)
-	{
-		if (0 != _ModelRootNode->numberOfChildren()) {
-			_ModelRootNode->DetachChildren();
-			_ModelRootNode->clearBBox();
-		}
-
-		AddModel(iModel);
-	}
-
-	/*! Adds a model for displaying in the viewer */
-	inline void AddModel(NodeGroup *iModel)
-	{
-		_ModelRootNode->AddChild(iModel);
-		_ModelRootNode->UpdateBBox();
-
-		_minBBox = std::min(std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
-		                    _ModelRootNode->bbox().getMin()[2]);
-		_maxBBox = std::max(std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
-		                    _ModelRootNode->bbox().getMax()[2]);
-
-		_maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
-		_minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
-	}
-
-	inline void AddSilhouette(NodeGroup *iSilhouette)
-	{
-		_SilhouetteRootNode->AddChild(iSilhouette);
-	}
-
-	inline void Add2DSilhouette(NodeGroup * /*iSilhouette*/)
-	{
-		//_pFENode->AddChild(iSilhouette);
-	}
-
-	inline void Add2DVisibleSilhouette(NodeGroup * /*iVSilhouette*/)
-	{
-		//_pVisibleSilhouetteNode->AddChild(iVSilhouette);
-	}
-
-	inline void setDebug(NodeGroup *iDebug)
-	{
-		if (0 != _DebugRootNode->numberOfChildren()) {
-			_DebugRootNode->DetachChildren();
-			_DebugRootNode->clearBBox();
-		}
-
-		AddDebug(iDebug);
-	}
-
-	inline void AddDebug(NodeGroup *iDebug)
-	{
-		_DebugRootNode->AddChild(iDebug);
-	}
-
-	inline void DetachModel(Node *iModel)
-	{
-		_ModelRootNode->DetachChild(iModel);
-		_ModelRootNode->UpdateBBox();
-
-		_minBBox = std::min(std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
-		                    _ModelRootNode->bbox().getMin()[2]);
-		_maxBBox = std::max(std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
-		                    _ModelRootNode->bbox().getMax()[2]);
-
-		_maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
-		_minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
-	}
-
-	inline void DetachModel()
-	{
-		_ModelRootNode->DetachChildren();
-		_ModelRootNode->clearBBox();
+class AppView {
+ public:
+  AppView(const char *iName = 0);
+  virtual ~AppView();
+
+ public:
+  //inherited
+  inline unsigned int width()
+  {
+    return _width;
+  }
+  inline unsigned int height()
+  {
+    return _height;
+  }
+  inline BBox<Vec2i> border()
+  {
+    return _border;
+  }
+  inline float thickness()
+  {
+    return _thickness;
+  }
+  inline void setWidth(unsigned int width)
+  {
+    _width = width;
+  }
+  inline void setHeight(unsigned int height)
+  {
+    _height = height;
+  }
+  inline void setBorder(int xmin, int ymin, int xmax, int ymax)
+  {
+    _border = BBox<Vec2i>(Vec2i(xmin, ymin), Vec2i(xmax, ymax));
+  }
+  inline void setThickness(float thickness)
+  {
+    _thickness = thickness;
+  }
+
+ protected:
+  unsigned int _width, _height;
+  BBox<Vec2i> _border;
+  float _thickness;
+
+ public:
+  /*! Sets the model to draw in the viewer
+   *  iModel
+   *    The Root Node of the model
+   */
+  inline void setModel(NodeGroup *iModel)
+  {
+    if (0 != _ModelRootNode->numberOfChildren()) {
+      _ModelRootNode->DetachChildren();
+      _ModelRootNode->clearBBox();
+    }
+
+    AddModel(iModel);
+  }
+
+  /*! Adds a model for displaying in the viewer */
+  inline void AddModel(NodeGroup *iModel)
+  {
+    _ModelRootNode->AddChild(iModel);
+    _ModelRootNode->UpdateBBox();
+
+    _minBBox = std::min(
+        std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
+        _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = std::max(
+        std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
+        _ModelRootNode->bbox().getMax()[2]);
+
+    _maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
+    _minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
+  }
+
+  inline void AddSilhouette(NodeGroup *iSilhouette)
+  {
+    _SilhouetteRootNode->AddChild(iSilhouette);
+  }
+
+  inline void Add2DSilhouette(NodeGroup * /*iSilhouette*/)
+  {
+    //_pFENode->AddChild(iSilhouette);
+  }
+
+  inline void Add2DVisibleSilhouette(NodeGroup * /*iVSilhouette*/)
+  {
+    //_pVisibleSilhouetteNode->AddChild(iVSilhouette);
+  }
+
+  inline void setDebug(NodeGroup *iDebug)
+  {
+    if (0 != _DebugRootNode->numberOfChildren()) {
+      _DebugRootNode->DetachChildren();
+      _DebugRootNode->clearBBox();
+    }
+
+    AddDebug(iDebug);
+  }
+
+  inline void AddDebug(NodeGroup *iDebug)
+  {
+    _DebugRootNode->AddChild(iDebug);
+  }
+
+  inline void DetachModel(Node *iModel)
+  {
+    _ModelRootNode->DetachChild(iModel);
+    _ModelRootNode->UpdateBBox();
+
+    _minBBox = std::min(
+        std::min(_ModelRootNode->bbox().getMin()[0], _ModelRootNode->bbox().getMin()[1]),
+        _ModelRootNode->bbox().getMin()[2]);
+    _maxBBox = std::max(
+        std::max(_ModelRootNode->bbox().getMax()[0], _ModelRootNode->bbox().getMax()[1]),
+        _ModelRootNode->bbox().getMax()[2]);
+
+    _maxAbs = std::max(rabs(_minBBox), rabs(_maxBBox));
+    _minAbs = std::min(rabs(_minBBox), rabs(_maxBBox));
+  }
+
+  inline void DetachModel()
+  {
+    _ModelRootNode->DetachChildren();
+    _ModelRootNode->clearBBox();
 
 #if 0
-		// 2D Scene
-		_p2DNode.DetachChildren();
-		_pFENode->DetachChildren();
-		_pVisibleSilhouetteNode->DetachChildren();
+    // 2D Scene
+    _p2DNode.DetachChildren();
+    _pFENode->DetachChildren();
+    _pVisibleSilhouetteNode->DetachChildren();
 #endif
-	}
+  }
 
-	inline void DetachSilhouette()
-	{
-		_SilhouetteRootNode->DetachChildren();
+  inline void DetachSilhouette()
+  {
+    _SilhouetteRootNode->DetachChildren();
 #if 0
-		_pFENode->DetachChildren();
-		_pVisibleSilhouetteNode->DetachChildren();
+    _pFENode->DetachChildren();
+    _pVisibleSilhouetteNode->DetachChildren();
 #endif
-		_p2DSelectionNode->destroy();
-	}
-
-	inline void DetachVisibleSilhouette()
-	{
-		//_pVisibleSilhouetteNode->DetachChildren();
-		_p2DSelectionNode->destroy();
-	}
-
-	inline void DetachDebug()
-	{
-		_DebugRootNode->DetachChildren();
-	}
-
-	real distanceToSceneCenter();
-	real GetFocalLength();
-
-	inline real GetAspect() const
-	{
-		return ((real)_width / (real)_height);
-	}
-
-	void setHorizontalFov(float hfov)
-	{
-		_Fovy = 2.0 * atan (tan(hfov / 2.0) / GetAspect());
-	}
-
-	inline real GetFovyRadian() const
-	{
-		return _Fovy;
-	}
-
-	inline real GetFovyDegrees() const
-	{
-		return _Fovy * 180.0 / M_PI;  // TODO Use RAD2DEG here too?
-	}
-
-	BBox<Vec3r> scene3DBBox() const {return _ModelRootNode->bbox();}
-
-	real znear();
-	real zfar();
-
-public:
-	/*! Core scene drawing */
-	void DrawScene(SceneVisitor *iRenderer);
-
-	/*! 2D Scene Drawing */
-	void Draw2DScene(SceneVisitor *iRenderer);
-
-protected:
-	/*! fabs or abs */
-	inline int rabs(int x) {return abs(x);}
-	inline real rabs(real x) {return fabs(x);}
-
-protected:
-	float _Fovy;
-
-	//The root node container
-	NodeGroup         _RootNode;
-	NodeDrawingStyle *_ModelRootNode;
-	NodeDrawingStyle *_SilhouetteRootNode;
-	NodeDrawingStyle *_DebugRootNode;
-
-	NodeGroup _Light;
-
-	real _minBBox;
-	real _maxBBox;
-	real _maxAbs;
-	real _minAbs;
-
-	// 2D Scene
-	bool _Draw2DScene;
-	bool _Draw3DScene;
-	NodeGroup _p2DNode;
-	NodeDrawingStyle *_p2DSelectionNode;
+    _p2DSelectionNode->destroy();
+  }
+
+  inline void DetachVisibleSilhouette()
+  {
+    //_pVisibleSilhouetteNode->DetachChildren();
+    _p2DSelectionNode->destroy();
+  }
+
+  inline void DetachDebug()
+  {
+    _DebugRootNode->DetachChildren();
+  }
+
+  real distanceToSceneCenter();
+  real GetFocalLength();
+
+  inline real GetAspect() const
+  {
+    return ((real)_width / (real)_height);
+  }
+
+  void setHorizontalFov(float hfov)
+  {
+    _Fovy = 2.0 * atan(tan(hfov / 2.0) / GetAspect());
+  }
+
+  inline real GetFovyRadian() const
+  {
+    return _Fovy;
+  }
+
+  inline real GetFovyDegrees() const
+  {
+    return _Fovy * 180.0 / M_PI;  // TODO Use RAD2DEG here too?
+  }
+
+  BBox<Vec3r> scene3DBBox() const
+  {
+    return _ModelRootNode->bbox();
+  }
+
+  real znear();
+  real zfar();
+
+ public:
+  /*! Core scene drawing */
+  void DrawScene(SceneVisitor *iRenderer);
+
+  /*! 2D Scene Drawing */
+  void Draw2DScene(SceneVisitor *iRenderer);
+
+ protected:
+  /*! fabs or abs */
+  inline int rabs(int x)
+  {
+    return abs(x);
+  }
+  inline real rabs(real x)
+  {
+    return fabs(x);
+  }
+
+ protected:
+  float _Fovy;
+
+  //The root node container
+  NodeGroup _RootNode;
+  NodeDrawingStyle *_ModelRootNode;
+  NodeDrawingStyle *_SilhouetteRootNode;
+  NodeDrawingStyle *_DebugRootNode;
+
+  NodeGroup _Light;
+
+  real _minBBox;
+  real _maxBBox;
+  real _maxAbs;
+  real _minAbs;
+
+  // 2D Scene
+  bool _Draw2DScene;
+  bool _Draw3DScene;
+  NodeGroup _p2DNode;
+  NodeDrawingStyle *_p2DSelectionNode;
 
 #ifdef WITH_CXX_GUARDEDALLOC
-	MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:AppView")
+  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:AppView")
 #endif
 };
 
 } /* namespace Freestyle */
 
-#endif // __APPVIEW_H__
+#endif  // __APPVIEW_H__
diff --git a/source/blender/freestyle/intern/application/Controller.cpp b/source/blender/freestyle/intern/application/Controller.cpp
index bd02b3378d1..e6066123a33 100644
--- a/source/blender/freestyle/intern/application/Controller.cpp
+++ b/source/blender/freestyle/intern/application/Controller.cpp
@@ -74,1045 +74,1051 @@ namespace Freestyle {
 
 Controller::Controller()
 {
-	const string sep(Config::DIR_SEP.c_str());
+  const string sep(Config::DIR_SEP.c_str());
 #if 0
-	const string filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR + sep +
-	                        Config::OPTIONS_CURRENT_DIRS_FILE;
-	_current_dirs = new ConfigIO(filename, Config::APPLICATION_NAME + "CurrentDirs", true);
+  const string filename = Config::Path::getInstance()->getHomeDir() + sep + Config::OPTIONS_DIR + sep +
+                          Config::OPTIONS_CURRENT_DIRS_FILE;
+  _current_dirs = new ConfigIO(filename, Config::APPLICATION_NAME + "CurrentDirs", true);
 #endif
 
-	_RootNode = new NodeGroup;
-	_RootNode->addRef();
+  _RootNode = new NodeGroup;
+  _RootNode->addRef();
 
 #if 0
-	_SilhouetteNode = NULL;
-	_ProjectedSilhouette = NULL;
-	_VisibleProjectedSilhouette = NULL;
+  _SilhouetteNode = NULL;
+  _ProjectedSilhouette = NULL;
+  _VisibleProjectedSilhouette = NULL;
 
-	_DebugNode = new NodeGroup;
-	_DebugNode->addRef();
+  _DebugNode = new NodeGroup;
+  _DebugNode->addRef();
 #endif
 
-	_winged_edge = NULL;
+  _winged_edge = NULL;
 
-	_pView = NULL;
-	_pRenderMonitor = NULL;
+  _pView = NULL;
+  _pRenderMonitor = NULL;
 
-	_edgeTesselationNature = (Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE);
+  _edgeTesselationNature = (Nature::SILHOUETTE | Nature::BORDER | Nature::CREASE);
 
-	_ProgressBar = new ProgressBar;
-	_SceneNumFaces = 0;
+  _ProgressBar = new ProgressBar;
+  _SceneNumFaces = 0;
 #if 0
-	_minEdgeSize = DBL_MAX;
+  _minEdgeSize = DBL_MAX;
 #endif
-	_EPSILON = 1.0e-6;
-	_bboxDiag = 0;
+  _EPSILON = 1.0e-6;
+  _bboxDiag = 0;
 
-	_ViewMap = 0;
+  _ViewMap = 0;
 
-	_Canvas = 0;
+  _Canvas = 0;
 
-	_VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_traditional;
-	//_VisibilityAlgo = ViewMapBuilder::ray_casting;
+  _VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_traditional;
+  //_VisibilityAlgo = ViewMapBuilder::ray_casting;
 
-	_Canvas = new AppCanvas;
+  _Canvas = new AppCanvas;
 
-	_inter = new PythonInterpreter();
-	_EnableViewMapCache = false;
-	_EnableQI = true;
-	_EnableFaceSmoothness = false;
-	_ComputeRidges = true;
-	_ComputeSteerableViewMap = false;
-	_ComputeSuggestive = true;
-	_ComputeMaterialBoundaries = true;
-	_sphereRadius = 1.0;
-	_creaseAngle = 134.43;
-	prevSceneHash = -1.0;
+  _inter = new PythonInterpreter();
+  _EnableViewMapCache = false;
+  _EnableQI = true;
+  _EnableFaceSmoothness = false;
+  _ComputeRidges = true;
+  _ComputeSteerableViewMap = false;
+  _ComputeSuggestive = true;
+  _ComputeMaterialBoundaries = true;
+  _sphereRadius = 1.0;
+  _creaseAngle = 134.43;
+  prevSceneHash = -1.0;
 
-	init_options();
+  init_options();
 }
 
 Controller::~Controller()
 {
-	if (NULL != _RootNode) {
-		int ref = _RootNode->destroy();
-		if (0 == ref)
-			delete _RootNode;
-	}
+  if (NULL != _RootNode) {
+    int ref = _RootNode->destroy();
+    if (0 == ref)
+      delete _RootNode;
+  }
 
 #if 0
-	if (NULL != _SilhouetteNode) {
-		int ref = _SilhouetteNode->destroy();
-		if (0 == ref)
-			delete _SilhouetteNode;
-	}
-
-	if (NULL != _DebugNode) {
-		int ref = _DebugNode->destroy();
-		if (0 == ref)
-			delete _DebugNode;
-	}
+  if (NULL != _SilhouetteNode) {
+    int ref = _SilhouetteNode->destroy();
+    if (0 == ref)
+      delete _SilhouetteNode;
+  }
+
+  if (NULL != _DebugNode) {
+    int ref = _DebugNode->destroy();
+    if (0 == ref)
+      delete _DebugNode;
+  }
 #endif
 
-	if (_winged_edge) {
-		delete _winged_edge;
-		_winged_edge = NULL;
-	}
+  if (_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
 
-	if (0 != _ViewMap) {
-		delete _ViewMap;
-		_ViewMap = 0;
-	}
+  if (0 != _ViewMap) {
+    delete _ViewMap;
+    _ViewMap = 0;
+  }
 
-	if (0 != _Canvas) {
-		delete _Canvas;
-		_Canvas = 0;
-	}
+  if (0 != _Canvas) {
+    delete _Canvas;
+    _Canvas = 0;
+  }
 
-	if (_inter) {
-		delete _inter;
-		_inter = NULL;
-	}
+  if (_inter) {
+    delete _inter;
+    _inter = NULL;
+  }
 
-	if (_ProgressBar) {
-		delete _ProgressBar;
-		_ProgressBar = NULL;
-	}
+  if (_ProgressBar) {
+    delete _ProgressBar;
+    _ProgressBar = NULL;
+  }
 
-	//delete _current_dirs;
+  //delete _current_dirs;
 }
 
 void Controller::setView(AppView *iView)
 {
-	if (NULL == iView)
-		return;
+  if (NULL == iView)
+    return;
 
-	_pView = iView;
-	_Canvas->setViewer(_pView);
+  _pView = iView;
+  _Canvas->setViewer(_pView);
 }
 
 void Controller::setRenderMonitor(RenderMonitor *iRenderMonitor)
 {
-	_pRenderMonitor = iRenderMonitor;
+  _pRenderMonitor = iRenderMonitor;
 }
 
 void Controller::setPassDiffuse(float *buf, int width, int height)
 {
-	AppCanvas *app_canvas = dynamic_cast<AppCanvas *>(_Canvas);
-	BLI_assert(app_canvas != 0);
-	app_canvas->setPassDiffuse(buf, width, height);
+  AppCanvas *app_canvas = dynamic_cast<AppCanvas *>(_Canvas);
+  BLI_assert(app_canvas != 0);
+  app_canvas->setPassDiffuse(buf, width, height);
 }
 
 void Controller::setPassZ(float *buf, int width, int height)
 {
-	AppCanvas *app_canvas = dynamic_cast<AppCanvas *>(_Canvas);
-	BLI_assert(app_canvas != 0);
-	app_canvas->setPassZ(buf, width, height);
+  AppCanvas *app_canvas = dynamic_cast<AppCanvas *>(_Canvas);
+  BLI_assert(app_canvas != 0);
+  app_canvas->setPassZ(buf, width, height);
 }
 
 void Controller::setContext(bContext *C)
 {
-	PythonInterpreter *py_inter = dynamic_cast<PythonInterpreter*>(_inter);
-	py_inter->setContext(C);
+  PythonInterpreter *py_inter = dynamic_cast<PythonInterpreter *>(_inter);
+  py_inter->setContext(C);
 }
 
 bool Controller::hitViewMapCache()
 {
-	if (!_EnableViewMapCache) {
-		return false;
-	}
-	if (sceneHashFunc.match()) {
-		return (NULL != _ViewMap);
-	}
-	sceneHashFunc.store();
-	return false;
+  if (!_EnableViewMapCache) {
+    return false;
+  }
+  if (sceneHashFunc.match()) {
+    return (NULL != _ViewMap);
+  }
+  sceneHashFunc.store();
+  return false;
 }
 
 int Controller::LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph)
 {
-	BlenderFileLoader loader(re, view_layer, depsgraph);
-
-	loader.setRenderMonitor(_pRenderMonitor);
-
-	_Chrono.start();
-
-	NodeGroup *blenderScene = loader.Load();
-
-	if (blenderScene == NULL) {
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			cout << "Cannot load scene" << endl;
-		}
-		return 1;
-	}
-
-	if (blenderScene->numberOfChildren() < 1) {
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			cout << "Empty scene" << endl;
-		}
-		blenderScene->destroy();
-		delete blenderScene;
-		return 1;
-	}
-
-	real duration = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "Scene loaded" << endl;
-		printf("Mesh cleaning    : %lf\n", duration);
-		printf("View map cache   : %s\n", _EnableViewMapCache ? "enabled" : "disabled");
-	}
-	_SceneNumFaces += loader.numFacesRead();
+  BlenderFileLoader loader(re, view_layer, depsgraph);
+
+  loader.setRenderMonitor(_pRenderMonitor);
+
+  _Chrono.start();
+
+  NodeGroup *blenderScene = loader.Load();
+
+  if (blenderScene == NULL) {
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      cout << "Cannot load scene" << endl;
+    }
+    return 1;
+  }
+
+  if (blenderScene->numberOfChildren() < 1) {
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      cout << "Empty scene" << endl;
+    }
+    blenderScene->destroy();
+    delete blenderScene;
+    return 1;
+  }
+
+  real duration = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "Scene loaded" << endl;
+    printf("Mesh cleaning    : %lf\n", duration);
+    printf("View map cache   : %s\n", _EnableViewMapCache ? "enabled" : "disabled");
+  }
+  _SceneNumFaces += loader.numFacesRead();
 
 #if 0
-	if (loader.minEdgeSize() < _minEdgeSize) {
-		_minEdgeSize = loader.minEdgeSize();
-	}
+  if (loader.minEdgeSize() < _minEdgeSize) {
+    _minEdgeSize = loader.minEdgeSize();
+  }
 #endif
 
 #if 0  // DEBUG
-	ScenePrettyPrinter spp;
-	blenderScene->accept(spp);
+  ScenePrettyPrinter spp;
+  blenderScene->accept(spp);
 #endif
 
-	_RootNode->AddChild(blenderScene);
-	_RootNode->UpdateBBox(); // FIXME: Correct that by making a Renderer to compute the bbox
-
-	_pView->setModel(_RootNode);
-	//_pView->FitBBox();
-
-	if (_pRenderMonitor->testBreak())
-		return 0;
-
-	if (_EnableViewMapCache) {
-
-		NodeCamera *cam;
-		if (g_freestyle.proj[3][3] != 0.0)
-			cam = new NodeOrthographicCamera;
-		else
-			cam = new NodePerspectiveCamera;
-		double proj[16];
-		for (int i = 0; i < 4; i++) {
-			for (int j = 0; j < 4; j++) {
-				proj[i * 4 + j] = g_freestyle.proj[i][j];
-			}
-		}
-		cam->setProjectionMatrix(proj);
-		_RootNode->AddChild(cam);
-		_RootNode->AddChild(new NodeViewLayer(*re->scene, *view_layer));
-
-		sceneHashFunc.reset();
-		//blenderScene->accept(sceneHashFunc);
-		_RootNode->accept(sceneHashFunc);
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			cout << "Scene hash       : " << sceneHashFunc.toString() << endl;
-		}
-		if (hitViewMapCache()) {
-			ClearRootNode();
-			return 0;
-		}
-		else {
-			delete _ViewMap;
-			_ViewMap = NULL;
-		}
-	}
-
-	_Chrono.start();
-
-	WXEdgeBuilder wx_builder;
-	wx_builder.setRenderMonitor(_pRenderMonitor);
-	blenderScene->accept(wx_builder);
-	_winged_edge = wx_builder.getWingedEdge();
-
-	duration = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		printf("WEdge building   : %lf\n", duration);
-	}
+  _RootNode->AddChild(blenderScene);
+  _RootNode->UpdateBBox();  // FIXME: Correct that by making a Renderer to compute the bbox
+
+  _pView->setModel(_RootNode);
+  //_pView->FitBBox();
+
+  if (_pRenderMonitor->testBreak())
+    return 0;
+
+  if (_EnableViewMapCache) {
+
+    NodeCamera *cam;
+    if (g_freestyle.proj[3][3] != 0.0)
+      cam = new NodeOrthographicCamera;
+    else
+      cam = new NodePerspectiveCamera;
+    double proj[16];
+    for (int i = 0; i < 4; i++) {
+      for (int j = 0; j < 4; j++) {
+        proj[i * 4 + j] = g_freestyle.proj[i][j];
+      }
+    }
+    cam->setProjectionMatrix(proj);
+    _RootNode->AddChild(cam);
+    _RootNode->AddChild(new NodeViewLayer(*re->scene, *view_layer));
+
+    sceneHashFunc.reset();
+    //blenderScene->accept(sceneHashFunc);
+    _RootNode->accept(sceneHashFunc);
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      cout << "Scene hash       : " << sceneHashFunc.toString() << endl;
+    }
+    if (hitViewMapCache()) {
+      ClearRootNode();
+      return 0;
+    }
+    else {
+      delete _ViewMap;
+      _ViewMap = NULL;
+    }
+  }
+
+  _Chrono.start();
+
+  WXEdgeBuilder wx_builder;
+  wx_builder.setRenderMonitor(_pRenderMonitor);
+  blenderScene->accept(wx_builder);
+  _winged_edge = wx_builder.getWingedEdge();
+
+  duration = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    printf("WEdge building   : %lf\n", duration);
+  }
 
 #if 0
-	_pView->setDebug(_DebugNode);
-
-	// delete stuff
-	if (0 != ws_builder) {
-		delete ws_builder;
-		ws_builder = 0;
-	}
-
-	soc QFileInfo qfi(iFileName);
-	soc string basename((const char*)qfi.fileName().toAscii().data());
-	char cleaned[FILE_MAX];
-	BLI_strncpy(cleaned, iFileName, FILE_MAX);
-	BLI_cleanup_file(NULL, cleaned);
-	string basename = string(cleaned);
+  _pView->setDebug(_DebugNode);
+
+  // delete stuff
+  if (0 != ws_builder) {
+    delete ws_builder;
+    ws_builder = 0;
+  }
+
+  soc QFileInfo qfi(iFileName);
+  soc string basename((const char*)qfi.fileName().toAscii().data());
+  char cleaned[FILE_MAX];
+  BLI_strncpy(cleaned, iFileName, FILE_MAX);
+  BLI_cleanup_file(NULL, cleaned);
+  string basename = string(cleaned);
 #endif
 
-	_ListOfModels.push_back("Blender_models");
+  _ListOfModels.push_back("Blender_models");
 
-	_Scene3dBBox = _RootNode->bbox();
+  _Scene3dBBox = _RootNode->bbox();
 
-	_bboxDiag = (_RootNode->bbox().getMax() - _RootNode->bbox().getMin()).norm();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "Triangles nb     : " << _SceneNumFaces << " imported, " <<
-		        _winged_edge->getNumFaces() << " retained" << endl;
-		cout << "Bounding Box     : " << _bboxDiag << endl;
-	}
+  _bboxDiag = (_RootNode->bbox().getMax() - _RootNode->bbox().getMin()).norm();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "Triangles nb     : " << _SceneNumFaces << " imported, " << _winged_edge->getNumFaces()
+         << " retained" << endl;
+    cout << "Bounding Box     : " << _bboxDiag << endl;
+  }
 
-	ClearRootNode();
+  ClearRootNode();
 
-	_SceneNumFaces = _winged_edge->getNumFaces();
-	if (_SceneNumFaces == 0) {
-		DeleteWingedEdge();
-		return 1;
-	}
+  _SceneNumFaces = _winged_edge->getNumFaces();
+  if (_SceneNumFaces == 0) {
+    DeleteWingedEdge();
+    return 1;
+  }
 
-	return 0;
+  return 0;
 }
 
 void Controller::CloseFile()
 {
-	WShape::setCurrentId(0);
-	_ListOfModels.clear();
+  WShape::setCurrentId(0);
+  _ListOfModels.clear();
 
-	// We deallocate the memory:
-	ClearRootNode();
-	DeleteWingedEdge();
-	DeleteViewMap();
+  // We deallocate the memory:
+  ClearRootNode();
+  DeleteWingedEdge();
+  DeleteViewMap();
 
-	// clears the canvas
-	_Canvas->Clear();
+  // clears the canvas
+  _Canvas->Clear();
 
-	// soc: reset passes
-	setPassDiffuse(NULL, 0, 0);
-	setPassZ(NULL, 0, 0);
+  // soc: reset passes
+  setPassDiffuse(NULL, 0, 0);
+  setPassZ(NULL, 0, 0);
 }
 
 void Controller::ClearRootNode()
 {
-	_pView->DetachModel();
-	if (NULL != _RootNode) {
-		int ref = _RootNode->destroy();
-		if (0 == ref)
-			_RootNode->addRef();
-		_RootNode->clearBBox();
-	}
+  _pView->DetachModel();
+  if (NULL != _RootNode) {
+    int ref = _RootNode->destroy();
+    if (0 == ref)
+      _RootNode->addRef();
+    _RootNode->clearBBox();
+  }
 }
 
 void Controller::DeleteWingedEdge()
 {
-	if (_winged_edge) {
-		delete _winged_edge;
-		_winged_edge = NULL;
-	}
-
-	// clears the grid
-	_Grid.clear();
-	_Scene3dBBox.clear();
-	_SceneNumFaces = 0;
+  if (_winged_edge) {
+    delete _winged_edge;
+    _winged_edge = NULL;
+  }
+
+  // clears the grid
+  _Grid.clear();
+  _Scene3dBBox.clear();
+  _SceneNumFaces = 0;
 #if 0
-	_minEdgeSize = DBL_MAX;
+  _minEdgeSize = DBL_MAX;
 #endif
 }
 
 void Controller::DeleteViewMap(bool freeCache)
 {
 #if 0
-	_pView->DetachSilhouette();
-	if (NULL != _SilhouetteNode) {
-		int ref = _SilhouetteNode->destroy();
-		if (0 == ref) {
-			delete _SilhouetteNode;
-			_SilhouetteNode = NULL;
-		}
-	}
-
-	if (NULL != _ProjectedSilhouette) {
-		int ref = _ProjectedSilhouette->destroy();
-		if (0 == ref) {
-			delete _ProjectedSilhouette;
-			_ProjectedSilhouette = NULL;
-		}
-	}
-	if (NULL != _VisibleProjectedSilhouette) {
-		int ref = _VisibleProjectedSilhouette->destroy();
-		if (0 == ref) {
-			delete _VisibleProjectedSilhouette;
-			_VisibleProjectedSilhouette = NULL;
-		}
-	}
-
-	_pView->DetachDebug();
-	if (NULL != _DebugNode) {
-		int ref = _DebugNode->destroy();
-		if (0 == ref)
-			_DebugNode->addRef();
-	}
+  _pView->DetachSilhouette();
+  if (NULL != _SilhouetteNode) {
+    int ref = _SilhouetteNode->destroy();
+    if (0 == ref) {
+      delete _SilhouetteNode;
+      _SilhouetteNode = NULL;
+    }
+  }
+
+  if (NULL != _ProjectedSilhouette) {
+    int ref = _ProjectedSilhouette->destroy();
+    if (0 == ref) {
+      delete _ProjectedSilhouette;
+      _ProjectedSilhouette = NULL;
+    }
+  }
+  if (NULL != _VisibleProjectedSilhouette) {
+    int ref = _VisibleProjectedSilhouette->destroy();
+    if (0 == ref) {
+      delete _VisibleProjectedSilhouette;
+      _VisibleProjectedSilhouette = NULL;
+    }
+  }
+
+  _pView->DetachDebug();
+  if (NULL != _DebugNode) {
+    int ref = _DebugNode->destroy();
+    if (0 == ref)
+      _DebugNode->addRef();
+  }
 #endif
 
-	if (NULL != _ViewMap) {
-		if (freeCache || !_EnableViewMapCache) {
-			delete _ViewMap;
-			_ViewMap = NULL;
-			prevSceneHash = -1.0;
-		}
-		else {
-			_ViewMap->Clean();
-		}
-	}
+  if (NULL != _ViewMap) {
+    if (freeCache || !_EnableViewMapCache) {
+      delete _ViewMap;
+      _ViewMap = NULL;
+      prevSceneHash = -1.0;
+    }
+    else {
+      _ViewMap->Clean();
+    }
+  }
 }
 
 void Controller::ComputeViewMap()
 {
-	if (!_ListOfModels.size())
-		return;
+  if (!_ListOfModels.size())
+    return;
 
-	DeleteViewMap(true);
+  DeleteViewMap(true);
 
-	// retrieve the 3D viewpoint and transformations information
-	//----------------------------------------------------------
-	// Save the viewpoint context at the view level in order
-	// to be able to restore it later:
+  // retrieve the 3D viewpoint and transformations information
+  //----------------------------------------------------------
+  // Save the viewpoint context at the view level in order
+  // to be able to restore it later:
 
-	// Restore the context of view:
-	// we need to perform all these operations while the
-	// 3D context is on.
-	Vec3f vp(UNPACK3(g_freestyle.viewpoint));
+  // Restore the context of view:
+  // we need to perform all these operations while the
+  // 3D context is on.
+  Vec3f vp(UNPACK3(g_freestyle.viewpoint));
 
 #if 0
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "mv" << endl;
-	}
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "mv" << endl;
+  }
 #endif
-	real mv[4][4];
-	for (int i = 0; i < 4; i++) {
-		for (int j = 0; j < 4; j++) {
-			mv[i][j] = g_freestyle.mv[i][j];
+  real mv[4][4];
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      mv[i][j] = g_freestyle.mv[i][j];
 #if 0
-			if (G.debug & G_DEBUG_FREESTYLE) {
-				cout << mv[i][j] << " ";
-			}
+      if (G.debug & G_DEBUG_FREESTYLE) {
+        cout << mv[i][j] << " ";
+      }
 #endif
-		}
+    }
 #if 0
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			cout << endl;
-		}
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      cout << endl;
+    }
 #endif
-	}
+  }
 
 #if 0
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "\nproj" << endl;
-	}
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "\nproj" << endl;
+  }
 #endif
-	real proj[4][4];
-	for (int i = 0; i < 4; i++) {
-		for (int j = 0; j < 4; j++) {
-			proj[i][j] = g_freestyle.proj[i][j];
+  real proj[4][4];
+  for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 4; j++) {
+      proj[i][j] = g_freestyle.proj[i][j];
 #if 0
-			if (G.debug & G_DEBUG_FREESTYLE) {
-				cout << proj[i][j] << " ";
-			}
+      if (G.debug & G_DEBUG_FREESTYLE) {
+        cout << proj[i][j] << " ";
+      }
 #endif
-		}
+    }
 #if 0
-		if (G.debug & G_DEBUG_FREESTYLE) {
-			cout << endl;
-		}
+    if (G.debug & G_DEBUG_FREESTYLE) {
+      cout << endl;
+    }
 #endif
-	}
+  }
 
-	int viewport[4];
-	for (int i = 0; i < 4; i++)
-		viewport[i] = g_freestyle.viewport[i];
+  int viewport[4];
+  for (int i = 0; i < 4; i++)
+    viewport[i] = g_freestyle.viewport[i];
 
 #if 0
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "\nfocal:" << _pView->GetFocalLength() << endl << endl;
-	}
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "\nfocal:" << _pView->GetFocalLength() << endl << endl;
+  }
 #endif
 
-	// Flag the WXEdge structure for silhouette edge detection:
-	//----------------------------------------------------------
-
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "\n===  Detecting silhouette edges  ===" << endl;
-	}
-	_Chrono.start();
-
-	edgeDetector.setViewpoint(vp);
-	edgeDetector.enableOrthographicProjection(proj[3][3] != 0.0);
-	edgeDetector.enableRidgesAndValleysFlag(_ComputeRidges);
-	edgeDetector.enableSuggestiveContours(_ComputeSuggestive);
-	edgeDetector.enableMaterialBoundaries(_ComputeMaterialBoundaries);
-	edgeDetector.enableFaceSmoothness(_EnableFaceSmoothness);
-	edgeDetector.setCreaseAngle(_creaseAngle);
-	edgeDetector.setSphereRadius(_sphereRadius);
-	edgeDetector.setSuggestiveContourKrDerivativeEpsilon(_suggestiveContourKrDerivativeEpsilon);
-	edgeDetector.setRenderMonitor(_pRenderMonitor);
-	edgeDetector.processShapes(*_winged_edge);
-
-	real duration = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		printf("Feature lines    : %lf\n", duration);
-	}
-
-	if (_pRenderMonitor->testBreak())
-		return;
-
-	// Builds the view map structure from the flagged WSEdge structure:
-	//----------------------------------------------------------
-	ViewMapBuilder vmBuilder;
-	vmBuilder.setEnableQI(_EnableQI);
-	vmBuilder.setViewpoint(vp);
-	vmBuilder.setTransform(mv, proj, viewport, _pView->GetFocalLength(), _pView->GetAspect(), _pView->GetFovyRadian());
-	vmBuilder.setFrustum(_pView->znear(), _pView->zfar());
-	vmBuilder.setGrid(&_Grid);
-	vmBuilder.setRenderMonitor(_pRenderMonitor);
+  // Flag the WXEdge structure for silhouette edge detection:
+  //----------------------------------------------------------
+
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "\n===  Detecting silhouette edges  ===" << endl;
+  }
+  _Chrono.start();
+
+  edgeDetector.setViewpoint(vp);
+  edgeDetector.enableOrthographicProjection(proj[3][3] != 0.0);
+  edgeDetector.enableRidgesAndValleysFlag(_ComputeRidges);
+  edgeDetector.enableSuggestiveContours(_ComputeSuggestive);
+  edgeDetector.enableMaterialBoundaries(_ComputeMaterialBoundaries);
+  edgeDetector.enableFaceSmoothness(_EnableFaceSmoothness);
+  edgeDetector.setCreaseAngle(_creaseAngle);
+  edgeDetector.setSphereRadius(_sphereRadius);
+  edgeDetector.setSuggestiveContourKrDerivativeEpsilon(_suggestiveContourKrDerivativeEpsilon);
+  edgeDetector.setRenderMonitor(_pRenderMonitor);
+  edgeDetector.processShapes(*_winged_edge);
+
+  real duration = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    printf("Feature lines    : %lf\n", duration);
+  }
+
+  if (_pRenderMonitor->testBreak())
+    return;
+
+  // Builds the view map structure from the flagged WSEdge structure:
+  //----------------------------------------------------------
+  ViewMapBuilder vmBuilder;
+  vmBuilder.setEnableQI(_EnableQI);
+  vmBuilder.setViewpoint(vp);
+  vmBuilder.setTransform(
+      mv, proj, viewport, _pView->GetFocalLength(), _pView->GetAspect(), _pView->GetFovyRadian());
+  vmBuilder.setFrustum(_pView->znear(), _pView->zfar());
+  vmBuilder.setGrid(&_Grid);
+  vmBuilder.setRenderMonitor(_pRenderMonitor);
 
 #if 0
-	// Builds a tesselated form of the silhouette for display purpose:
-	//---------------------------------------------------------------
-	ViewMapTesselator3D sTesselator3d;
-	ViewMapTesselator2D sTesselator2d;
-	sTesselator2d.setNature(_edgeTesselationNature);
-	sTesselator3d.setNature(_edgeTesselationNature);
+  // Builds a tesselated form of the silhouette for display purpose:
+  //---------------------------------------------------------------
+  ViewMapTesselator3D sTesselator3d;
+  ViewMapTesselator2D sTesselator2d;
+  sTesselator2d.setNature(_edgeTesselationNature);
+  sTesselator3d.setNature(_edgeTesselationNature);
 #endif
 
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "\n===  Building the view map  ===" << endl;
-	}
-	_Chrono.start();
-	// Build View Map
-	_ViewMap = vmBuilder.BuildViewMap(*_winged_edge, _VisibilityAlgo, _EPSILON, _Scene3dBBox, _SceneNumFaces);
-	_ViewMap->setScene3dBBox(_Scene3dBBox);
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "\n===  Building the view map  ===" << endl;
+  }
+  _Chrono.start();
+  // Build View Map
+  _ViewMap = vmBuilder.BuildViewMap(
+      *_winged_edge, _VisibilityAlgo, _EPSILON, _Scene3dBBox, _SceneNumFaces);
+  _ViewMap->setScene3dBBox(_Scene3dBBox);
 
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		printf("ViewMap edge count : %i\n", _ViewMap->viewedges_size());
-	}
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    printf("ViewMap edge count : %i\n", _ViewMap->viewedges_size());
+  }
 
 #if 0
-	// Tesselate the 3D edges:
-	_SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
-	_SilhouetteNode->addRef();
+  // Tesselate the 3D edges:
+  _SilhouetteNode = sTesselator3d.Tesselate(_ViewMap);
+  _SilhouetteNode->addRef();
 
-	// Tesselate 2D edges
-	_ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
-	_ProjectedSilhouette->addRef();
+  // Tesselate 2D edges
+  _ProjectedSilhouette = sTesselator2d.Tesselate(_ViewMap);
+  _ProjectedSilhouette->addRef();
 #endif
 
-	duration = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		printf("ViewMap building : %lf\n", duration);
-	}
+  duration = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    printf("ViewMap building : %lf\n", duration);
+  }
 
 #if 0
-	_pView->AddSilhouette(_SilhouetteNode);
-	_pView->AddSilhouette(_WRoot);
-	_pView->Add2DSilhouette(_ProjectedSilhouette);
-	_pView->Add2DVisibleSilhouette(_VisibleProjectedSilhouette);
-	_pView->AddDebug(_DebugNode);
+  _pView->AddSilhouette(_SilhouetteNode);
+  _pView->AddSilhouette(_WRoot);
+  _pView->Add2DSilhouette(_ProjectedSilhouette);
+  _pView->Add2DVisibleSilhouette(_VisibleProjectedSilhouette);
+  _pView->AddDebug(_DebugNode);
 #endif
 
-	// Draw the steerable density map:
-	//--------------------------------
-	if (_ComputeSteerableViewMap) {
-		ComputeSteerableViewMap();
-	}
-	// Reset Style modules modification flags
-	resetModified(true);
+  // Draw the steerable density map:
+  //--------------------------------
+  if (_ComputeSteerableViewMap) {
+    ComputeSteerableViewMap();
+  }
+  // Reset Style modules modification flags
+  resetModified(true);
 
-	DeleteWingedEdge();
+  DeleteWingedEdge();
 }
 
 void Controller::ComputeSteerableViewMap()
 {
 #if 0  //soc
-	if ((!_Canvas) || (!_ViewMap))
-		return;
-
-	// Build 4 nodes containing the edges in the 4 directions
-	NodeGroup *ng[Canvas::NB_STEERABLE_VIEWMAP];
-	unsigned i;
-	real c = 32.0f/255.0f; // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
-	for (i = 0; i < Canvas::NB_STEERABLE_VIEWMAP; ++i) {
-		ng[i] = new NodeGroup;
-	}
-	NodeShape *completeNS = new NodeShape;
-	completeNS->material().setDiffuse(c,c,c,1);
-	ng[Canvas::NB_STEERABLE_VIEWMAP-1]->AddChild(completeNS);
-	SteerableViewMap *svm = _Canvas->getSteerableViewMap();
-	svm->Reset();
-
-	ViewMap::fedges_container& fedges = _ViewMap->FEdges();
-	LineRep *fRep;
-	NodeShape *ns;
-	for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end();
-	     f != fend;
-	     ++f)
-	{
-		if ((*f)->viewedge()->qi() != 0)
-			continue;
-		fRep = new LineRep((*f)->vertexA()->point2d(), (*f)->vertexB()->point2d());
-		completeNS->AddRep(fRep); // add to the complete map anyway
-		double *oweights = svm->AddFEdge(*f);
-		for (i = 0; i < (Canvas::NB_STEERABLE_VIEWMAP - 1); ++i) {
-			ns = new NodeShape;
-			double wc = oweights[i]*c;
-			if (oweights[i] == 0)
-				continue;
-			ns->material().setDiffuse(wc, wc, wc, 1);
-			ns->AddRep(fRep);
-			ng[i]->AddChild(ns);
-		}
-	}
-
-	GrayImage *img[Canvas::NB_STEERABLE_VIEWMAP];
-	//#ifdef WIN32
-	QGLBasicWidget offscreenBuffer(_pView, "SteerableViewMap", _pView->width(), _pView->height());
-	QPixmap pm;
-	QImage qimg;
-	for (i = 0; i < Canvas::NB_STEERABLE_VIEWMAP; ++i) {
-		offscreenBuffer.AddNode(ng[i]);
-#if 0
-		img[i] = new GrayImage(_pView->width(), _pView->height());
-		offscreenBuffer.readPixels(0,0,_pView->width(), _pView->height(), img[i]->getArray());
-#endif
-		pm = offscreenBuffer.renderPixmap(_pView->width(), _pView->height());
-
-		if (pm.isNull()) {
-			if (G.debug & G_DEBUG_FREESTYLE) {
-				cout << "BuildViewMap Warning: couldn't render the steerable ViewMap" << endl;
-			}
-		}
-		//pm.save(QString("steerable") + QString::number(i) + QString(".bmp"), "BMP");
-		// FIXME!! Lost of time !
-		qimg = pm.toImage();
-		// FIXME !! again!
-		img[i] = new GrayImage(_pView->width(), _pView->height());
-		for (unsigned int y = 0; y < img[i]->height(); ++y) {
-			for (unsigned int x = 0; x < img[i]->width(); ++x) {
-				//img[i]->setPixel(x, y, (float)qGray(qimg.pixel(x, y)) / 255.0f);
-				img[i]->setPixel(x, y, (float)qGray(qimg.pixel(x, y)));
-				//float c = qGray(qimg.pixel(x, y));
-				//img[i]->setPixel(x, y, qGray(qimg.pixel(x, y)));
-			}
-		}
-		offscreenBuffer.DetachNode(ng[i]);
-		ng[i]->destroy();
-		delete ng[i];
-		// check
-#if 0
-		qimg = QImage(_pView->width(), _pView->height(), 32);
-		for (unsigned int y = 0; y < img[i]->height(); ++y) {
-			for (unsigned int x = 0; x < img[i]->width(); ++x) {
-				float v = img[i]->pixel(x, y);
-				qimg.setPixel(x, y, qRgb(v, v, v));
-			}
-		}
-		qimg.save(QString("newsteerable") + QString::number(i) + QString(".bmp"), "BMP");
-#endif
-	}
-
-
-	svm->buildImagesPyramids(img, false, 0, 1.0f);
+  if ((!_Canvas) || (!_ViewMap))
+    return;
+
+  // Build 4 nodes containing the edges in the 4 directions
+  NodeGroup *ng[Canvas::NB_STEERABLE_VIEWMAP];
+  unsigned i;
+  real c = 32.0f/255.0f; // see SteerableViewMap::readSteerableViewMapPixel() for information about this 32.
+  for (i = 0; i < Canvas::NB_STEERABLE_VIEWMAP; ++i) {
+    ng[i] = new NodeGroup;
+  }
+  NodeShape *completeNS = new NodeShape;
+  completeNS->material().setDiffuse(c,c,c,1);
+  ng[Canvas::NB_STEERABLE_VIEWMAP-1]->AddChild(completeNS);
+  SteerableViewMap *svm = _Canvas->getSteerableViewMap();
+  svm->Reset();
+
+  ViewMap::fedges_container& fedges = _ViewMap->FEdges();
+  LineRep *fRep;
+  NodeShape *ns;
+  for (ViewMap::fedges_container::iterator f = fedges.begin(), fend = fedges.end();
+       f != fend;
+       ++f)
+  {
+    if ((*f)->viewedge()->qi() != 0)
+      continue;
+    fRep = new LineRep((*f)->vertexA()->point2d(), (*f)->vertexB()->point2d());
+    completeNS->AddRep(fRep); // add to the complete map anyway
+    double *oweights = svm->AddFEdge(*f);
+    for (i = 0; i < (Canvas::NB_STEERABLE_VIEWMAP - 1); ++i) {
+      ns = new NodeShape;
+      double wc = oweights[i]*c;
+      if (oweights[i] == 0)
+        continue;
+      ns->material().setDiffuse(wc, wc, wc, 1);
+      ns->AddRep(fRep);
+      ng[i]->AddChild(ns);
+    }
+  }
+
+  GrayImage *img[Canvas::NB_STEERABLE_VIEWMAP];
+  //#ifdef WIN32
+  QGLBasicWidget offscreenBuffer(_pView, "SteerableViewMap", _pView->width(), _pView->height());
+  QPixmap pm;
+  QImage qimg;
+  for (i = 0; i < Canvas::NB_STEERABLE_VIEWMAP; ++i) {
+    offscreenBuffer.AddNode(ng[i]);
+#  if 0
+    img[i] = new GrayImage(_pView->width(), _pView->height());
+    offscreenBuffer.readPixels(0,0,_pView->width(), _pView->height(), img[i]->getArray());
+#  endif
+    pm = offscreenBuffer.renderPixmap(_pView->width(), _pView->height());
+
+    if (pm.isNull()) {
+      if (G.debug & G_DEBUG_FREESTYLE) {
+        cout << "BuildViewMap Warning: couldn't render the steerable ViewMap" << endl;
+      }
+    }
+    //pm.save(QString("steerable") + QString::number(i) + QString(".bmp"), "BMP");
+    // FIXME!! Lost of time !
+    qimg = pm.toImage();
+    // FIXME !! again!
+    img[i] = new GrayImage(_pView->width(), _pView->height());
+    for (unsigned int y = 0; y < img[i]->height(); ++y) {
+      for (unsigned int x = 0; x < img[i]->width(); ++x) {
+        //img[i]->setPixel(x, y, (float)qGray(qimg.pixel(x, y)) / 255.0f);
+        img[i]->setPixel(x, y, (float)qGray(qimg.pixel(x, y)));
+        //float c = qGray(qimg.pixel(x, y));
+        //img[i]->setPixel(x, y, qGray(qimg.pixel(x, y)));
+      }
+    }
+    offscreenBuffer.DetachNode(ng[i]);
+    ng[i]->destroy();
+    delete ng[i];
+    // check
+#  if 0
+    qimg = QImage(_pView->width(), _pView->height(), 32);
+    for (unsigned int y = 0; y < img[i]->height(); ++y) {
+      for (unsigned int x = 0; x < img[i]->width(); ++x) {
+        float v = img[i]->pixel(x, y);
+        qimg.setPixel(x, y, qRgb(v, v, v));
+      }
+    }
+    qimg.save(QString("newsteerable") + QString::number(i) + QString(".bmp"), "BMP");
+#  endif
+  }
+
+
+  svm->buildImagesPyramids(img, false, 0, 1.0f);
 #endif
 }
 
 void Controller::saveSteerableViewMapImages()
 {
-	SteerableViewMap *svm = _Canvas->getSteerableViewMap();
-	if (!svm) {
-		cerr << "the Steerable ViewMap has not been computed yet" << endl;
-		return;
-	}
-	svm->saveSteerableViewMap();
+  SteerableViewMap *svm = _Canvas->getSteerableViewMap();
+  if (!svm) {
+    cerr << "the Steerable ViewMap has not been computed yet" << endl;
+    return;
+  }
+  svm->saveSteerableViewMap();
 }
 
 void Controller::toggleVisibilityAlgo()
 {
-	if (_VisibilityAlgo == ViewMapBuilder::ray_casting) {
-		_VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
-	}
-	else if (_VisibilityAlgo == ViewMapBuilder::ray_casting_fast) {
-		_VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
-	}
-	else {
-		_VisibilityAlgo = ViewMapBuilder::ray_casting;
-	}
+  if (_VisibilityAlgo == ViewMapBuilder::ray_casting) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+  }
+  else if (_VisibilityAlgo == ViewMapBuilder::ray_casting_fast) {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
+  }
+  else {
+    _VisibilityAlgo = ViewMapBuilder::ray_casting;
+  }
 }
 
 void Controller::setVisibilityAlgo(int algo)
 {
-	switch (algo) {
-		case FREESTYLE_ALGO_REGULAR:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting;
-			break;
-		case FREESTYLE_ALGO_FAST:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
-			break;
-		case FREESTYLE_ALGO_VERYFAST:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
-			break;
-		case FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_culled_adaptive_traditional;
-			break;
-		case FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_traditional;
-			break;
-		case FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_culled_adaptive_cumulative;
-			break;
-		case FREESTYLE_ALGO_ADAPTIVE_CUMULATIVE:
-			_VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_cumulative;
-			break;
-	}
+  switch (algo) {
+    case FREESTYLE_ALGO_REGULAR:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting;
+      break;
+    case FREESTYLE_ALGO_FAST:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_fast;
+      break;
+    case FREESTYLE_ALGO_VERYFAST:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_very_fast;
+      break;
+    case FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_culled_adaptive_traditional;
+      break;
+    case FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_traditional;
+      break;
+    case FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_culled_adaptive_cumulative;
+      break;
+    case FREESTYLE_ALGO_ADAPTIVE_CUMULATIVE:
+      _VisibilityAlgo = ViewMapBuilder::ray_casting_adaptive_cumulative;
+      break;
+  }
 }
 
 int Controller::getVisibilityAlgo()
 {
-	switch (_VisibilityAlgo) {
-		case ViewMapBuilder::ray_casting:
-			return FREESTYLE_ALGO_REGULAR;
-		case ViewMapBuilder::ray_casting_fast:
-			return FREESTYLE_ALGO_FAST;
-		case ViewMapBuilder::ray_casting_very_fast:
-			return FREESTYLE_ALGO_VERYFAST;
-		case ViewMapBuilder::ray_casting_culled_adaptive_traditional:
-			return FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL;
-		case ViewMapBuilder::ray_casting_adaptive_traditional:
-			return FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL;
-		case ViewMapBuilder::ray_casting_culled_adaptive_cumulative:
-			return FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE;
-		case ViewMapBuilder::ray_casting_adaptive_cumulative:
-			return FREESTYLE_ALGO_ADAPTIVE_CUMULATIVE;
-	}
-
-	// ray_casting_adaptive_traditional is the most exact replacement
-	// for legacy code
-	return FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL;
+  switch (_VisibilityAlgo) {
+    case ViewMapBuilder::ray_casting:
+      return FREESTYLE_ALGO_REGULAR;
+    case ViewMapBuilder::ray_casting_fast:
+      return FREESTYLE_ALGO_FAST;
+    case ViewMapBuilder::ray_casting_very_fast:
+      return FREESTYLE_ALGO_VERYFAST;
+    case ViewMapBuilder::ray_casting_culled_adaptive_traditional:
+      return FREESTYLE_ALGO_CULLED_ADAPTIVE_TRADITIONAL;
+    case ViewMapBuilder::ray_casting_adaptive_traditional:
+      return FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL;
+    case ViewMapBuilder::ray_casting_culled_adaptive_cumulative:
+      return FREESTYLE_ALGO_CULLED_ADAPTIVE_CUMULATIVE;
+    case ViewMapBuilder::ray_casting_adaptive_cumulative:
+      return FREESTYLE_ALGO_ADAPTIVE_CUMULATIVE;
+  }
+
+  // ray_casting_adaptive_traditional is the most exact replacement
+  // for legacy code
+  return FREESTYLE_ALGO_ADAPTIVE_TRADITIONAL;
 }
 
 void Controller::setViewMapCache(bool iBool)
 {
-	_EnableViewMapCache = iBool;
+  _EnableViewMapCache = iBool;
 }
 
 bool Controller::getViewMapCache() const
 {
-	return _EnableViewMapCache;
+  return _EnableViewMapCache;
 }
 
 void Controller::setQuantitativeInvisibility(bool iBool)
 {
-	_EnableQI = iBool;
+  _EnableQI = iBool;
 }
 
 bool Controller::getQuantitativeInvisibility() const
 {
-	return _EnableQI;
+  return _EnableQI;
 }
 
 void Controller::setFaceSmoothness(bool iBool)
 {
-	_EnableFaceSmoothness = iBool;
+  _EnableFaceSmoothness = iBool;
 }
 
 bool Controller::getFaceSmoothness() const
 {
-	return _EnableFaceSmoothness;
+  return _EnableFaceSmoothness;
 }
 
 void Controller::setComputeRidgesAndValleysFlag(bool iBool)
 {
-	_ComputeRidges = iBool;
+  _ComputeRidges = iBool;
 }
 
 bool Controller::getComputeRidgesAndValleysFlag() const
 {
-	return _ComputeRidges;
+  return _ComputeRidges;
 }
 
 void Controller::setComputeSuggestiveContoursFlag(bool b)
 {
-	_ComputeSuggestive = b;
+  _ComputeSuggestive = b;
 }
 
 bool Controller::getComputeSuggestiveContoursFlag() const
 {
-	return _ComputeSuggestive;
+  return _ComputeSuggestive;
 }
 
 void Controller::setComputeMaterialBoundariesFlag(bool b)
 {
-	_ComputeMaterialBoundaries = b;
+  _ComputeMaterialBoundaries = b;
 }
 
 bool Controller::getComputeMaterialBoundariesFlag() const
 {
-	return _ComputeMaterialBoundaries;
+  return _ComputeMaterialBoundaries;
 }
 
 void Controller::setComputeSteerableViewMapFlag(bool iBool)
 {
-	_ComputeSteerableViewMap = iBool;
+  _ComputeSteerableViewMap = iBool;
 }
 
 bool Controller::getComputeSteerableViewMapFlag() const
 {
-	return _ComputeSteerableViewMap;
+  return _ComputeSteerableViewMap;
 }
 
 int Controller::DrawStrokes()
 {
-	if (_ViewMap == 0)
-		return 0;
-
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "\n===  Stroke drawing  ===" << endl;
-	}
-	_Chrono.start();
-	_Canvas->Draw();
-	real d = _Chrono.stop();
-	int strokeCount = _Canvas->getStrokeCount();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "Strokes generation  : " << d << endl;
-		cout << "Stroke count  : " << strokeCount << endl;
-	}
-	resetModified();
-	DeleteViewMap();
-	return strokeCount;
+  if (_ViewMap == 0)
+    return 0;
+
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "\n===  Stroke drawing  ===" << endl;
+  }
+  _Chrono.start();
+  _Canvas->Draw();
+  real d = _Chrono.stop();
+  int strokeCount = _Canvas->getStrokeCount();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "Strokes generation  : " << d << endl;
+    cout << "Stroke count  : " << strokeCount << endl;
+  }
+  resetModified();
+  DeleteViewMap();
+  return strokeCount;
 }
 
 void Controller::ResetRenderCount()
 {
-	_render_count = 0;
+  _render_count = 0;
 }
 
 Render *Controller::RenderStrokes(Render *re, bool render)
 {
-	int totmesh = 0;
-	_Chrono.start();
-	BlenderStrokeRenderer *blenderRenderer = new BlenderStrokeRenderer(re, ++_render_count);
-	if (render) {
-		_Canvas->Render(blenderRenderer);
-		totmesh = blenderRenderer->GenerateScene();
-	}
-	real d = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "Temporary scene generation: " << d << endl;
-	}
-	_Chrono.start();
-	Render *freestyle_render = blenderRenderer->RenderScene(re, render);
-	d = _Chrono.stop();
-	if (G.debug & G_DEBUG_FREESTYLE) {
-		cout << "Stroke rendering  : " << d << endl;
-
-		uintptr_t mem_in_use = MEM_get_memory_in_use();
-		uintptr_t mmap_in_use = MEM_get_mapped_memory_in_use();
-		uintptr_t peak_memory = MEM_get_peak_memory();
-
-		float megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
-		float mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
-		float megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
-
-		printf("%d objs, %d verts, %d faces, mem %.2fM (%.2fM, peak %.2fM)\n",
-		       totmesh, freestyle_render->i.totvert, freestyle_render->i.totface,
-		       megs_used_memory, mmap_used_memory, megs_peak_memory);
-	}
-	delete blenderRenderer;
-
-	return freestyle_render;
+  int totmesh = 0;
+  _Chrono.start();
+  BlenderStrokeRenderer *blenderRenderer = new BlenderStrokeRenderer(re, ++_render_count);
+  if (render) {
+    _Canvas->Render(blenderRenderer);
+    totmesh = blenderRenderer->GenerateScene();
+  }
+  real d = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "Temporary scene generation: " << d << endl;
+  }
+  _Chrono.start();
+  Render *freestyle_render = blenderRenderer->RenderScene(re, render);
+  d = _Chrono.stop();
+  if (G.debug & G_DEBUG_FREESTYLE) {
+    cout << "Stroke rendering  : " << d << endl;
+
+    uintptr_t mem_in_use = MEM_get_memory_in_use();
+    uintptr_t mmap_in_use = MEM_get_mapped_memory_in_use();
+    uintptr_t peak_memory = MEM_get_peak_memory();
+
+    float megs_used_memory = (mem_in_use - mmap_in_use) / (1024.0 * 1024.0);
+    float mmap_used_memory = (mmap_in_use) / (1024.0 * 1024.0);
+    float megs_peak_memory = (peak_memory) / (1024.0 * 1024.0);
+
+    printf("%d objs, %d verts, %d faces, mem %.2fM (%.2fM, peak %.2fM)\n",
+           totmesh,
+           freestyle_render->i.totvert,
+           freestyle_render->i.totface,
+           megs_used_memory,
+           mmap_used_memory,
+           megs_peak_memory);
+  }
+  delete blenderRenderer;
+
+  return freestyle_render;
 }
 
 void Controller::InsertStyleModule(unsigned index, const char *iFileName)
 {
-	if (!BLI_path_extension_check(iFileName, ".py")) {
-		cerr << "Error: Cannot load \"" << string(iFileName) << "\", unknown extension" << endl;
-		return;
-	}
+  if (!BLI_path_extension_check(iFileName, ".py")) {
+    cerr << "Error: Cannot load \"" << string(iFileName) << "\", unknown extension" << endl;
+    return;
+  }
 
-	StyleModule *sm = new StyleModule(iFileName, _inter);
-	_Canvas->InsertStyleModule(index, sm);
+  StyleModule *sm = new StyleModule(iFileName, _inter);
+  _Canvas->InsertStyleModule(index, sm);
 }
 
 void Controller::InsertStyleModule(unsigned index, const char *iName, const char *iBuffer)
 {
-	StyleModule *sm = new BufferedStyleModule(iBuffer, iName, _inter);
-	_Canvas->InsertStyleModule(index, sm);
+  StyleModule *sm = new BufferedStyleModule(iBuffer, iName, _inter);
+  _Canvas->InsertStyleModule(index, sm);
 }
 
 void Controller::InsertStyleModule(unsigned index, const char *iName, struct Text *iText)
 {
-	StyleModule *sm = new BlenderStyleModule(iText, iName, _inter);
-	_Canvas->InsertStyleModule(index, sm);
+  StyleModule *sm = new BlenderStyleModule(iText, iName, _inter);
+  _Canvas->InsertStyleModule(index, sm);
 }
 
 void Controller::AddStyleModule(const char * /*iFileName*/)
 {
-	//_pStyleWindow->Add(iFileName);
+  //_pStyleWindow->Add(iFileName);
 }
 
 void Controller::RemoveStyleModule(unsigned index)
 {
-	_Canvas->RemoveStyleModule(index);
+  _Canvas->RemoveStyleModule(index);
 }
 
 void Controller::Clear()
 {
-	_Canvas->Clear();
+  _Canvas->Clear();
 }
 
-void Controller::ReloadStyleModule(unsigned index, const char * iFileName)
+void Controller::ReloadStyleModule(unsigned index, const char *iFileName)
 {
-	StyleModule *sm = new StyleModule(iFileName, _inter);
-	_Canvas->ReplaceStyleModule(index, sm);
+  StyleModule *sm = new StyleModule(iFileName, _inter);
+  _Canvas->ReplaceStyleModule(index, sm);
 }
 
 void Controller::SwapStyleModules(unsigned i1, unsigned i2)
 {
-	_Canvas->SwapStyleModules(i1, i2);
+  _Canvas->SwapStyleModules(i1, i2);
 }
 
 void Controller::toggleLayer(unsigned index, bool iDisplay)
 {
-	_Canvas->setVisible(index, iDisplay);
+  _Canvas->setVisible(index, iDisplay);
 }
 
 void Controller::setModified(unsigned index, bool iMod)
 {
-	//_pStyleWindow->setModified(index, iMod);
-	_Canvas->setModified(index, iMod);
-	updateCausalStyleModules(index + 1);
+  //_pStyleWindow->setModified(index, iMod);
+  _Canvas->setModified(index, iMod);
+  updateCausalStyleModules(index + 1);
 }
 
 void Controller::updateCausalStyleModules(unsigned index)
 {
-	vector<unsigned> vec;
-	_Canvas->causalStyleModules(vec, index);
-	for (vector<unsigned>::const_iterator it = vec.begin(); it != vec.end(); it++) {
-		//_pStyleWindow->setModified(*it, true);
-		_Canvas->setModified(*it, true);
-	}
+  vector<unsigned> vec;
+  _Canvas->causalStyleModules(vec, index);
+  for (vector<unsigned>::const_iterator it = vec.begin(); it != vec.end(); it++) {
+    //_pStyleWindow->setModified(*it, true);
+    _Canvas->setModified(*it, true);
+  }
 }
 
 void Controller::resetModified(bool iMod)
 {
-	//_pStyleWindow->resetModified(iMod);
-	_Canvas->resetModified(iMod);
+  //_pStyleWindow->resetModified(iMod);
+  _Canvas->resetModified(iMod);
 }
 
-NodeGroup *Controller::BuildRep(vector<ViewEdge*>::iterator vedges_begin, vector<ViewEdge*>::iterator vedges_end)
+NodeGroup *Controller::BuildRep(vector<ViewEdge *>::iterator vedges_begin,
+                                vector<ViewEdge *>::iterator vedges_end)
 {
-	ViewMapTesselator2D tesselator2D;
-	FrsMaterial mat;
-	mat.setDiffuse(1, 1, 0.3, 1);
-	tesselator2D.setFrsMaterial(mat);
+  ViewMapTesselator2D tesselator2D;
+  FrsMaterial mat;
+  mat.setDiffuse(1, 1, 0.3, 1);
+  tesselator2D.setFrsMaterial(mat);
 
-	return (tesselator2D.Tesselate(vedges_begin, vedges_end));
+  return (tesselator2D.Tesselate(vedges_begin, vedges_end));
 }
 
 void Controller::toggleEdgeTesselationNature(Nature::EdgeNature iNature)
 {
-	_edgeTesselationNature ^= (iNature);
-	ComputeViewMap();
+  _edgeTesselationNature ^= (iNature);
+  ComputeViewMap();
 }
 
-void Controller::setModelsDir(const string& /*dir*/)
+void Controller::setModelsDir(const string & /*dir*/)
 {
-	//_current_dirs->setValue("models/dir", dir);
+  //_current_dirs->setValue("models/dir", dir);
 }
 
 string Controller::getModelsDir() const
 {
-	string dir = ".";
-	//_current_dirs->getValue("models/dir", dir);
-	return dir;
+  string dir = ".";
+  //_current_dirs->getValue("models/dir", dir);
+  return dir;
 }
 
-void Controller::setModulesDir(const string& /*dir*/)
+void Controller::setModulesDir(const string & /*dir*/)
 {
-	//_current_dirs->setValue("modules/dir", dir);
+  //_current_dirs->setValue("modules/dir", dir);
 }
 
 string Controller::getModulesDir() const
 {
-	string dir = ".";
-	//_current_dirs->getValue("modules/dir", dir);
-	return dir;
+  string dir = ".";
+  //_current_dirs->getValue("modules/dir", dir);
+  return dir;
 }
 
 void Controller::resetInterpreter()
 {
-	if (_inter)
-		_inter->reset();
+  if (_inter)
+    _inter->reset();
 }
 
-
 void Controller::displayDensityCurves(int x, int y)
 {
-	SteerableViewMap *svm = _Canvas->getSteerableViewMap();
-	if (!svm)
-		return;
-
-	unsigned int i, j;
-	typedef vector<Vec3r> densityCurve;
-	vector<densityCurve> curves(svm->getNumberOfOrientations() + 1);
-	vector<densityCurve> curvesDirection(svm->getNumberOfPyramidLevels());
-
-	// collect the curves values
-	unsigned nbCurves = svm->getNumberOfOrientations() + 1;
-	unsigned nbPoints = svm->getNumberOfPyramidLevels();
-	if (!nbPoints)
-		return;
-
-	// build the density/nbLevels curves for each orientation
-	for (i = 0; i < nbCurves; ++i) {
-		for (j = 0; j < nbPoints; ++j) {
-			curves[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(i, j, x, y), 0));
-		}
-	}
-	// build the density/nbOrientations curves for each level
-	for (i = 0; i < nbPoints; ++i) {
-		for (j = 0; j < nbCurves; ++j) {
-			curvesDirection[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(j, i, x, y), 0));
-		}
-	}
-
-	// display the curves
+  SteerableViewMap *svm = _Canvas->getSteerableViewMap();
+  if (!svm)
+    return;
+
+  unsigned int i, j;
+  typedef vector<Vec3r> densityCurve;
+  vector<densityCurve> curves(svm->getNumberOfOrientations() + 1);
+  vector<densityCurve> curvesDirection(svm->getNumberOfPyramidLevels());
+
+  // collect the curves values
+  unsigned nbCurves = svm->getNumberOfOrientations() + 1;
+  unsigned nbPoints = svm->getNumberOfPyramidLevels();
+  if (!nbPoints)
+    return;
+
+  // build the density/nbLevels curves for each orientation
+  for (i = 0; i < nbCurves; ++i) {
+    for (j = 0; j < nbPoints; ++j) {
+      curves[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(i, j, x, y), 0));
+    }
+  }
+  // build the density/nbOrientations curves for each level
+  for (i = 0; i < nbPoints; ++i) {
+    for (j = 0; j < nbCurves; ++j) {
+      curvesDirection[i].push_back(Vec3r(j, svm->readSteerableViewMapPixel(j, i, x, y), 0));
+    }
+  }
+
+  // display the curves
 #if 0
-	for (i = 0; i < nbCurves; ++i)
-		_pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0, 0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
-	for (i = 1; i <= 8; ++i)
-		_pDensityCurvesWindow->setLevelCurve(i, Vec2d(0, 0), Vec2d(nbCurves, 1), curvesDirection[i],
-		                                     "orientation", "density");
-	_pDensityCurvesWindow->show();
+  for (i = 0; i < nbCurves; ++i)
+    _pDensityCurvesWindow->setOrientationCurve(i, Vec2d(0, 0), Vec2d(nbPoints, 1), curves[i], "scale", "density");
+  for (i = 1; i <= 8; ++i)
+    _pDensityCurvesWindow->setLevelCurve(i, Vec2d(0, 0), Vec2d(nbCurves, 1), curvesDirection[i],
+                                         "orientation", "density");
+  _pDensityCurvesWindow->show();
 #endif
 }
 
 void Controller::init_options()
 {
-	// from AppOptionsWindow.cpp
-	// Default init options
+  // from AppOptionsWindow.cpp
+  // Default init options
 
-	Config::Path * cpath = Config::Path::getInstance();
+  Config::Path *cpath = Config::Path::getInstance();
 
-	// Directories
-	ViewMapIO::Options::setModelsPath(cpath->getModelsPath());
-	TextureManager::Options::setPatternsPath(cpath->getPatternsPath());
-	TextureManager::Options::setBrushesPath(cpath->getModelsPath());
+  // Directories
+  ViewMapIO::Options::setModelsPath(cpath->getModelsPath());
+  TextureManager::Options::setPatternsPath(cpath->getPatternsPath());
+  TextureManager::Options::setBrushesPath(cpath->getModelsPath());
 
-	// ViewMap Format
-	ViewMapIO::Options::rmFlags(ViewMapIO::Options::FLOAT_VECTORS);
-	ViewMapIO::Options::rmFlags(ViewMapIO::Options::NO_OCCLUDERS);
-	setComputeSteerableViewMapFlag(false);
+  // ViewMap Format
+  ViewMapIO::Options::rmFlags(ViewMapIO::Options::FLOAT_VECTORS);
+  ViewMapIO::Options::rmFlags(ViewMapIO::Options::NO_OCCLUDERS);
+  setComputeSteerableViewMapFlag(false);
 
-	// Visibility
-	setQuantitativeInvisibility(true);
+  // Visibility
+  setQuantitativeInvisibility(true);
 
-	// soc: initialize canvas
-	_Canvas->init();
+  // soc: initialize canvas
+  _Canvas->init();
 
-	// soc: initialize passes
-	setPassDiffuse(NULL, 0, 0);
-	setPassZ(NULL, 0, 0);
+  // soc: initialize passes
+  setPassDiffuse(NULL, 0, 0);
+  setPassZ(NULL, 0, 0);
 }
 
 } /* namespace Freestyle */
diff --git a/source/blender/freestyle/intern/application/Controller.h b/source/blender/freestyle/intern/application/Controller.h
index 765ea418f5e..be8553c73e1 100644
--- a/source/blender/freestyle/intern/application/Controller.h
+++ b/source/blender/freestyle/intern/application/Controller.h
@@ -32,7 +32,7 @@
 #include "../view_map/ViewMapBuilder.h"
 
 #ifdef WITH_CXX_GUARDEDALLOC
-#include "MEM_guardedalloc.h"
+#  include "MEM_guardedalloc.h"
 #endif
 
 namespace Freestyle {
@@ -47,201 +47,219 @@ class SShape;
 class ViewEdge;
 class ViewMap;
 
-class Controller
-{
-public:
-	Controller();
-	~Controller();
-
-	void setView(AppView *iView);
-	void setRenderMonitor(RenderMonitor *iRenderMonitor);
-	void setPassDiffuse(float *buf, int width, int height);
-	void setPassZ(float *buf, int width, int height);
-	void setContext(bContext *C);
-
-	//soc
-	void init_options();
-
-	int  LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph);
-	int  Load3DSFile(const char *iFileName);
-	void CloseFile();
-	void ComputeViewMap();
-	void ComputeSteerableViewMap();
-	void saveSteerableViewMapImages();
-	void toggleEdgeTesselationNature(Nature::EdgeNature iNature);
-	int DrawStrokes();
-	void ResetRenderCount();
-	Render *RenderStrokes(Render *re, bool render);
-	void SwapStyleModules(unsigned i1, unsigned i2);
-	void InsertStyleModule(unsigned index, const char *iFileName);
-	void InsertStyleModule(unsigned index, const char *iName, const char *iBuffer);
-	void InsertStyleModule(unsigned index, const char *iName, struct Text *iText);
-	void AddStyleModule(const char *iFileName);
-	void RemoveStyleModule(unsigned index);
-	void ReloadStyleModule(unsigned index, const char * iFileName);
-	void Clear();
-	void ClearRootNode();
-	void DeleteWingedEdge();
-	void DeleteViewMap(bool freeCache = false);
-	void toggleLayer(unsigned index, bool iDisplay);
-	void setModified(unsigned index, bool iMod);
-	void resetModified(bool iMod=false);
-	void updateCausalStyleModules(unsigned index);
-	void displayDensityCurves(int x, int y);
-
-	ViewEdge *SelectViewEdge(real x, real y);
-	FEdge *SelectFEdge(real x, real y);
-	NodeGroup *BuildRep(vector<ViewEdge*>::iterator vedges_begin, vector<ViewEdge*>::iterator vedges_end) ;
+class Controller {
+ public:
+  Controller();
+  ~Controller();
+
+  void setView(AppView *iView);
+  void setRenderMonitor(RenderMonitor *iRenderMonitor);
+  void setPassDiffuse(float *buf, int width, int height);
+  void setPassZ(float *buf, int width, int height);
+  void setContext(bContext *C);
+
+  //soc
+  void init_options();
+
+  int LoadMesh(Render *re, ViewLayer *view_layer, Depsgraph *depsgraph);
+  int Load3DSFile(const char *iFileName);
+  void CloseFile();
+  void ComputeViewMap();
+  void ComputeSteerableViewMap();
+  void saveSteerableViewMapImages();
+  void toggleEdgeTesselationNature(Nature::EdgeNature iNature);
+  int DrawStrokes();
+  void ResetRenderCount();
+  Render *RenderStrokes(Render *re, bool render);
+  void SwapStyleModules(unsigned i1, unsigned i2);
+  void InsertStyleModule(unsigned index, const char *iFileName);
+  void InsertStyleModule(unsigned index, const char *iName, const char *iBuffer);
+  void InsertStyleModule(unsigned index, const char *iName, struct Text *iText);
+  void AddStyleModule(const char *iFileName);
+  void RemoveStyleModule(unsigned index);
+  void ReloadStyleModule(unsigned index, const char *iFileName);
+  void Clear();
+  void ClearRootNode();
+  void DeleteWingedEdge();
+  void DeleteViewMap(bool freeCache = false);
+  void toggleLayer(unsigned index, bool iDisplay);
+  void setModified(unsigned index, bool iMod);
+  void resetModified(bool iMod = false);
+  void updateCausalStyleModules(unsigned index);
+  void displayDensityCurves(int x, int y);
+
+  ViewEdge *SelectViewEdge(real x, real y);
+  FEdge *SelectFEdge(real x, real y);
+  NodeGroup *BuildRep(vector<ViewEdge *>::iterator vedges_begin,
+                      vector<ViewEdge *>::iterator vedges_end);
 
 #if 0
-	NodeGroup *debugNode() {return _DebugNode;}
-	AppView *view() {return _pView;}
-	NodeGroup *debugScene() {return _DebugNode;}
-	Grid& grid() {return _Grid;}
+  NodeGroup *debugNode() {return _DebugNode;}
+  AppView *view() {return _pView;}
+  NodeGroup *debugScene() {return _DebugNode;}
+  Grid& grid() {return _Grid;}
 #endif
 
-	void toggleVisibilityAlgo();
-	void setVisibilityAlgo(int algo);
-	int getVisibilityAlgo();
-
-	void setViewMapCache(bool iBool);
-	bool getViewMapCache() const;
-	void setQuantitativeInvisibility(bool iBool); // if true, we compute quantitativeInvisibility
-	bool getQuantitativeInvisibility() const;
-	void setFaceSmoothness(bool iBool);
-	bool getFaceSmoothness() const;
-
-	void setComputeRidgesAndValleysFlag(bool b);
-	bool getComputeRidgesAndValleysFlag() const;
-	void setComputeSuggestiveContoursFlag(bool b);
-	bool getComputeSuggestiveContoursFlag() const;
-	void setComputeMaterialBoundariesFlag(bool b);
-	bool getComputeMaterialBoundariesFlag() const;
-
-	void setComputeSteerableViewMapFlag(bool iBool);
-	bool getComputeSteerableViewMapFlag() const;
-	void setCreaseAngle(float angle) {_creaseAngle = angle;}
-	float getCreaseAngle() const {return _creaseAngle;}
-	void setSphereRadius(float s) {_sphereRadius = s;}
-	float getSphereRadius() const {return _sphereRadius;}
-	void setSuggestiveContourKrDerivativeEpsilon(float dkr) {_suggestiveContourKrDerivativeEpsilon = dkr;}
-	float getSuggestiveContourKrDerivativeEpsilon() const {return _suggestiveContourKrDerivativeEpsilon;}
-
-	void setModelsDir(const string& dir);
-	string getModelsDir() const;
-	void setModulesDir(const string& dir);
-	string getModulesDir() const;
-
-	bool hitViewMapCache();
-
-	void resetInterpreter();
-
-public:
-	// Viewmap data structure
-	ViewMap *_ViewMap;
-
-	// Canvas
-	AppCanvas *_Canvas;
-
-private:
-	// Main Window:
-	//AppMainWindow *_pMainWindow;
-
-	// List of models currently loaded
-	vector<string> _ListOfModels;
-
-	// Current directories
-	//ConfigIO* _current_dirs;
-
-	//View
-	// 3D
-	AppView *_pView;
-
-	// 2D
+  void toggleVisibilityAlgo();
+  void setVisibilityAlgo(int algo);
+  int getVisibilityAlgo();
+
+  void setViewMapCache(bool iBool);
+  bool getViewMapCache() const;
+  void setQuantitativeInvisibility(bool iBool);  // if true, we compute quantitativeInvisibility
+  bool getQuantitativeInvisibility() const;
+  void setFaceSmoothness(bool iBool);
+  bool getFaceSmoothness() const;
+
+  void setComputeRidgesAndValleysFlag(bool b);
+  bool getComputeRidgesAndValleysFlag() const;
+  void setComputeSuggestiveContoursFlag(bool b);
+  bool getComputeSuggestiveContoursFlag() const;
+  void setComputeMaterialBoundariesFlag(bool b);
+  bool getComputeMaterialBoundariesFlag() const;
+
+  void setComputeSteerableViewMapFlag(bool iBool);
+  bool getComputeSteerableViewMapFlag() const;
+  void setCreaseAngle(float angle)
+  {
+    _creaseAngle = angle;
+  }
+  float getCreaseAngle() const
+  {
+    return _creaseAngle;
+  }
+  void setSphereRadius(float s)
+  {
+    _sphereRadius = s;
+  }
+  float getSphereRadius() const
+  {
+    return _sphereRadius;
+  }
+  void setSuggestiveContourKrDerivativeEpsilon(float dkr)
+  {
+    _suggestiveContourKrDerivativeEpsilon = dkr;
+  }
+  float getSuggestiveContourKrDerivativeEpsilon() const
+  {
+    return _suggestiveContourKrDerivativeEpsilon;
+  }
+
+  void setModelsDir(const string &dir);
+  string getModelsDir() const;
+  void setModulesDir(const string &dir);
+  string getModulesDir() const;
+
+  bool hitViewMapCache();
+
+  void resetInterpreter();
+
+ public:
+  // Viewmap data structure
+  ViewMap *_ViewMap;
+
+  // Canvas
+  AppCanvas *_Canvas;
+
+ private:
+  // Main Window:
+  //AppMainWindow *_pMainWindow;
+
+  // List of models currently loaded
+  vector<string> _ListOfModels;
+
+  // Current directories
+  //ConfigIO* _current_dirs;
+
+  //View
+  // 3D
+  AppView *_pView;
+
+  // 2D
 #if 0
-	Viewer2DWindow *_pView2DWindow;
-	Viewer2D *_pView2D;
+  Viewer2DWindow *_pView2DWindow;
+  Viewer2D *_pView2D;
 #endif
 
-	RenderMonitor *_pRenderMonitor;
+  RenderMonitor *_pRenderMonitor;
 
-	//Model
-	// Drawing Structure
-	NodeGroup *_RootNode;
+  //Model
+  // Drawing Structure
+  NodeGroup *_RootNode;
 
-	// Winged-Edge structure
-	WingedEdge *_winged_edge;
+  // Winged-Edge structure
+  WingedEdge *_winged_edge;
 
 #if 0
-	// Silhouette structure:
-	std::vector<SShape*> _SShapes;
-	NodeGroup *_SRoot;
+  // Silhouette structure:
+  std::vector<SShape*> _SShapes;
+  NodeGroup *_SRoot;
 
-	// Silhouette
-	NodeGroup *_SilhouetteNode;
-	NodeGroup *_ProjectedSilhouette;
-	NodeGroup *_VisibleProjectedSilhouette;
+  // Silhouette
+  NodeGroup *_SilhouetteNode;
+  NodeGroup *_ProjectedSilhouette;
+  NodeGroup *_VisibleProjectedSilhouette;
 
-	// more Debug info
-	NodeGroup *_DebugNode;
+  // more Debug info
+  NodeGroup *_DebugNode;
 #endif
 
-	// debug
-	//NodeUser<ViewMap> *_ViewMapNode; // FIXME
+  // debug
+  //NodeUser<ViewMap> *_ViewMapNode; // FIXME
 
-	// Chronometer:
-	Chronometer _Chrono;
+  // Chronometer:
+  Chronometer _Chrono;
 
-	// Progress Bar
-	ProgressBar *_ProgressBar;
+  // Progress Bar
+  ProgressBar *_ProgressBar;
 
-	// edges tesselation nature
-	int _edgeTesselationNature;
+  // edges tesselation nature
+  int _edgeTesselationNature;
 
-	FastGrid _Grid;
-	//HashGrid _Grid;
+  FastGrid _Grid;
+  //HashGrid _Grid;
 
-	BBox<Vec3r> _Scene3dBBox;
-	unsigned int _SceneNumFaces;
+  BBox<Vec3r> _Scene3dBBox;
+  unsigned int _SceneNumFaces;
 #if 0
-	real _minEdgeSize;
+  real _minEdgeSize;
 #endif
-	real _EPSILON;
-	real _bboxDiag;
+  real _EPSILON;
+  real _bboxDiag;
 
-	int _render_count;
+  int _render_count;
 
-	//AppStyleWindow *_pStyleWindow;
-	//AppOptionsWindow *_pOptionsWindow;
-	//AppDensityCurvesWindow *_pDensityCurvesWindow;
+  //AppStyleWindow *_pStyleWindow;
+  //AppOptionsWindow *_pOptionsWindow;
+  //AppDensityCurvesWindow *_pDensityCurvesWindow;
 
-	ViewMapBuilder::visibility_algo _VisibilityAlgo;
+  ViewMapBuilder::visibility_algo _VisibilityAlgo;
 
-	// Script Interpreter
-	Interpreter *_inter;
+  // Script Interpreter
+  Interpreter *_inter;
 
-	string _help_index;
-	string _browser_cmd;
+  string _help_index;
+  string _browser_cmd;
 
-	bool _EnableViewMapCache;
-	bool _EnableQI;
-	bool _EnableFaceSmoothness;
-	bool _ComputeRidges;
-	bool _ComputeSuggestive;
-	bool _ComputeMaterialBoundaries;
-	float _creaseAngle;
-	float _sphereRadius;
-	float _suggestiveContourKrDerivativeEpsilon;
+  bool _EnableViewMapCache;
+  bool _EnableQI;
+  bool _EnableFaceSmoothness;
+  bool _ComputeRidges;
+  bool _ComputeSuggestive;
+  bool _ComputeMaterialBoundaries;
+  float _creaseAngle;
+  float _sphereRadius;
+  float _suggestiveContourKrDerivativeEpsilon;
 
-	bool _ComputeSteerableViewMap;
+  bool _ComputeSteerableViewMap;
 
-	FEdgeXDetector edgeDetector;
+  FEdgeXDetector edgeDetector;
 
-	SceneHash sceneHashFunc;
-	real prevSceneHash;
+  SceneHash sceneHashFunc;
+  real prevSceneHash;
 
 #ifdef WITH_CXX_GUARDEDALLOC
-	MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Controller")
+  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Controller")
 #endif
 };
 
@@ -249,4 +267,4 @@ extern Controller *g_pController;
 
 } /* namespace Freestyle */
 
-#endif // __CONTROLLER_H__
+#endif  // __CONTROLLER_H__