将Renderer部分放入Renderer命名空间

ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj

@@ -103,20 +103,21 @@
     <ClCompile Include="src\main.cpp" />
     <ClCompile Include="src\MainWindow.cpp" />
     <ClCompile Include="src\NavigationBarWidget.cpp" />
-    <ClCompile Include="src\Renderer\BvhTree.cpp" />
+    <ClCompile Include="src\Renderer\Painting\BvhTree.cpp" />
     <ClCompile Include="src\Renderer\Camera.cpp" />
-    <ClCompile Include="src\Renderer\CubicBezier.cpp" />
+    <ClCompile Include="src\Renderer\Painting\CubicBezier.cpp" />
-    <ClCompile Include="src\Renderer\CubicMonotonization.cpp" />
+    <ClCompile Include="src\Renderer\Painting\CubicMonotonization.cpp" />
     <ClCompile Include="src\Renderer\Light.cpp" />
-    <ClCompile Include="src\Renderer\Line.cpp" />
+    <ClCompile Include="src\Renderer\Painting\Line.cpp" />
     <ClCompile Include="src\Renderer\Mesh.cpp" />
     <ClCompile Include="src\Renderer\Model.cpp" />
-    <ClCompile Include="src\Renderer\PaintingHelper.cpp" />
+    <ClCompile Include="src\Renderer\Painting\Painting.cpp" />
+    <ClCompile Include="src\Renderer\Painting\PaintingHelper.cpp" />
     <ClCompile Include="src\Renderer\PaintingMesh.cpp" />
     <ClCompile Include="src\Renderer\RendererGLWidget.cpp" />
     <ClCompile Include="src\Renderer\RendererWidget.cpp" />
-    <ClCompile Include="src\Renderer\ShortCutTree.cpp" />
+    <ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp" />
-    <ClCompile Include="src\Renderer\StraightLine.cpp" />
+    <ClCompile Include="src\Renderer\Painting\StraightLine.cpp" />
     <ClCompile Include="src\SvgParser.cpp" />
     <ClCompile Include="src\TitleWidget.cpp" />
     <QtRcc Include="MainWindow.qrc" />
@@ -148,6 +149,7 @@
   </ItemGroup>
   <ItemGroup>
     <QtMoc Include="src\MainWindow.h" />
+    <ClInclude Include="src\Renderer\Painting\Painting.h" />
     <ClInclude Include="src\SvgParser.h" />
     <QtMoc Include="src\TitleWidget.h" />
     <QtMoc Include="src\IconWidget.h" />
@@ -155,19 +157,19 @@
     <QtMoc Include="src\NavigationBarWidget.h" />
     <QtMoc Include="src\Renderer\RendererWidget.h" />
     <QtMoc Include="src\Editor\EditorWidget.h" />
-    <ClInclude Include="src\Renderer\BvhTree.h" />
+    <ClInclude Include="src\Renderer\Painting\BvhTree.h" />
     <ClInclude Include="src\Renderer\Camera.h" />
-    <ClInclude Include="src\Renderer\CubicBezier.h" />
+    <ClInclude Include="src\Renderer\Painting\CubicBezier.h" />
-    <ClInclude Include="src\Renderer\CubicMonotonization.h" />
+    <ClInclude Include="src\Renderer\Painting\CubicMonotonization.h" />
     <ClInclude Include="src\Renderer\Drawable.h" />
     <ClInclude Include="src\Renderer\Light.h" />
-    <ClInclude Include="src\Renderer\Line.h" />
+    <ClInclude Include="src\Renderer\Painting\Line.h" />
     <ClInclude Include="src\Renderer\Mesh.h" />
     <ClInclude Include="src\Renderer\Model.h" />
-    <ClInclude Include="src\Renderer\PaintingHelper.h" />
+    <ClInclude Include="src\Renderer\Painting\PaintingHelper.h" />
     <ClInclude Include="src\Renderer\PaintingMesh.h" />
-    <ClInclude Include="src\Renderer\ShortCutTree.h" />
+    <ClInclude Include="src\Renderer\Painting\ShortCutTree.h" />
-    <ClInclude Include="src\Renderer\StraightLine.h" />
+    <ClInclude Include="src\Renderer\Painting\StraightLine.h" />
     <QtMoc Include="src\Renderer\RendererGLWidget.h" />
   </ItemGroup>
   <ItemGroup>

ArchitectureColoredPainting/ArchitectureColoredPainting.vcxproj.filters

@@ -35,6 +35,12 @@
     <Filter Include="Resource Files\Shaders">
       <UniqueIdentifier>{60515177-3da7-420f-8f5b-27c16bb2b77b}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Source Files\Renderer\Painting">
+      <UniqueIdentifier>{653d1291-0de8-4e0a-855d-7cfc755f7632}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Renderer\Painting">
+      <UniqueIdentifier>{22909273-2b23-49fa-84ab-444cefb09656}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <QtUic Include="MainWindow.ui">
@@ -51,45 +57,24 @@
     <ClCompile Include="src\Editor\EditorWidget.cpp">
       <Filter>Source Files\Editor</Filter>
     </ClCompile>
-    <ClCompile Include="src\Renderer\BvhTree.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
     <ClCompile Include="src\Renderer\Camera.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
-    <ClCompile Include="src\Renderer\CubicBezier.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Renderer\CubicMonotonization.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
     <ClCompile Include="src\Renderer\Light.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
-    <ClCompile Include="src\Renderer\Line.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
     <ClCompile Include="src\Renderer\Mesh.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
     <ClCompile Include="src\Renderer\Model.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
-    <ClCompile Include="src\Renderer\PaintingHelper.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
     <ClCompile Include="src\Renderer\PaintingMesh.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
     <ClCompile Include="src\Renderer\RendererGLWidget.cpp">
       <Filter>Source Files\Renderer</Filter>
     </ClCompile>
-    <ClCompile Include="src\Renderer\ShortCutTree.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
-    <ClCompile Include="src\Renderer\StraightLine.cpp">
-      <Filter>Source Files\Renderer</Filter>
-    </ClCompile>
     <ClCompile Include="src\main.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
@@ -114,6 +99,30 @@
     <ClCompile Include="src\TitleWidget.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\BvhTree.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\CubicBezier.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\CubicMonotonization.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\PaintingHelper.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\ShortCutTree.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\StraightLine.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\Painting.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
+    <ClCompile Include="src\Renderer\Painting\Line.cpp">
+      <Filter>Source Files\Renderer\Painting</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <QtMoc Include="src\Renderer\RendererGLWidget.h">
@@ -206,48 +215,51 @@
     </QtUic>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="src\Renderer\BvhTree.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="src\Renderer\Camera.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
-    <ClInclude Include="src\Renderer\CubicBezier.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
-    <ClInclude Include="src\Renderer\CubicMonotonization.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="src\Renderer\Drawable.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
     <ClInclude Include="src\Renderer\Light.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
-    <ClInclude Include="src\Renderer\Line.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="src\Renderer\Mesh.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
     <ClInclude Include="src\Renderer\Model.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
-    <ClInclude Include="src\Renderer\PaintingHelper.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="src\Renderer\PaintingMesh.h">
       <Filter>Header Files\Renderer</Filter>
     </ClInclude>
-    <ClInclude Include="src\Renderer\ShortCutTree.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
-    <ClInclude Include="src\Renderer\StraightLine.h">
-      <Filter>Header Files\Renderer</Filter>
-    </ClInclude>
     <ClInclude Include="src\SvgParser.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\BvhTree.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\CubicBezier.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\CubicMonotonization.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\Line.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\PaintingHelper.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\ShortCutTree.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\StraightLine.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
+    <ClInclude Include="src\Renderer\Painting\Painting.h">
+      <Filter>Header Files\Renderer\Painting</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <QtRcc Include="MainWindow.qrc">

ArchitectureColoredPainting/MainWindow.ui

@@ -94,7 +94,7 @@ QTabWidget::pane {
           <string>纹理编辑</string>
          </attribute>
         </widget>
-        <widget class="RendererWidget" name="rendererWidget">
+        <widget class="Renderer::RendererWidget" name="rendererWidget">
          <attribute name="title">
           <string>场景渲染</string>
          </attribute>
@@ -109,7 +109,7 @@ QTabWidget::pane {
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
-   <class>RendererWidget</class>
+   <class>Renderer::RendererWidget</class>
    <extends>QWidget</extends>
    <header>Renderer/RendererWidget.h</header>
   </customwidget>

ArchitectureColoredPainting/RendererWidget.ui

@@ -48,7 +48,7 @@
       <enum>QLayout::SetDefaultConstraint</enum>
      </property>
      <item>
-      <widget class="RendererGLWidget" name="openGLWidget">
+      <widget class="Renderer::RendererGLWidget" name="openGLWidget">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
          <horstretch>0</horstretch>
@@ -94,7 +94,7 @@
  <layoutdefault spacing="6" margin="11"/>
  <customwidgets>
   <customwidget>
-   <class>RendererGLWidget</class>
+   <class>Renderer::RendererGLWidget</class>
    <extends>QOpenGLWidget</extends>
    <header>RendererGLWidget.h</header>
   </customwidget>

ArchitectureColoredPainting/src/MainWindow.cpp

@@ -110,7 +110,7 @@ CentralWidget::CentralWidget(QWidget* parent) : QMainWindow(parent)
 	QObject::connect(navigationBarWidget->buttonGroup, &QButtonGroup::idClicked,
 		ui.tabWidget, &QTabWidget::setCurrentIndex);
 	QObject::connect(ui.tabWidget, &QTabWidget::currentChanged,
-		ui.rendererWidget, &RendererWidget::currentTabChanged);
+		ui.rendererWidget, &Renderer::RendererWidget::currentTabChanged);
 }
 
 CentralWidget::~CentralWidget()

ArchitectureColoredPainting/src/Renderer/BvhTree.h

@@ -1,88 +0,0 @@
-#pragma once
-
-#include <QOpenGLTexture>
-#include <QOpenGLContext>
-#include <QTextCodec>
-#include <algorithm>
-#include <QVector4D>
-#include <iostream>
-#include <memory>
-#include <vector>
-#include <cmath>
-
-using std::shared_ptr;
-
-struct BvhTreeData {
-	QVector4D bound;
-	GLuint leftSon, rightSon;
-	void show() {
-		printf("Bvh: (%lf, %lf) (%lf, %lf): %d %d\n",
-			bound.x(), bound.y(), bound.z(), bound.w(),
-			leftSon, rightSon);
-	}
-	BvhTreeData(QVector4D bound, GLuint leftSon, GLuint rightSon)
-		: bound(bound), leftSon(leftSon), rightSon(rightSon) {}
-	BvhTreeData()
-		: leftSon(0), rightSon(0) {}
-	~BvhTreeData() {}
-};
-// BvhTree 节点
-struct BvhNode {	
-	GLuint lab;
-	bool isLeaf;
-	QVector4D bound;
-	shared_ptr<BvhNode> child[2];
-	static bool x_compare(BvhTreeData a, BvhTreeData b) {
-		return a.bound.x() < b.bound.x();
-	}
-	static bool y_compare(BvhTreeData a, BvhTreeData b) {
-		return a.bound.y() < b.bound.y();
-	}
-	GLuint getLeftSon(int k) {
-		if (isLeaf) {
-			return 0x80000000+child[0]->lab;
-		}
-		return child[0]->lab;
-	}
-	GLuint getRightSon(int k) {
-		if (isLeaf) {
-			return child[1]->lab;
-		}
-		return child[1]->lab;
-	}
-	BvhNode() {
-		child[0] = child[1] = NULL;
-		isLeaf = false;
-		lab = 0;
-	}
-	int maximumBound() {
-		return (std::fabs(bound.x() - bound.w()) < std::fabs(bound.y() - bound.z()));
-	}
-	~BvhNode() {}
-};
-
-typedef std::shared_ptr<BvhNode> BvhPtr;
-
-class BvhTree
-{
-	
-private:
-	GLuint tot;
-	BvhPtr root;
-	static QVector4D calcBound(BvhTreeData initBound[], int l, int r);
-	static QVector4D Union(QVector4D a, QVector4D b);
-	BvhPtr subBvhTree(BvhTreeData initBound[], int l, int r);
-	void traverseBvhTree(BvhPtr now, std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
-public:
-	BvhTree() {
-		tot = 0;
-		root = NULL;
-	}
-	// 根据底层包围盒生成bvh树
-	void buildBvhTree(BvhTreeData initBound[], int len);
-	// 获得 Bvh （rootBvh部分）的 children 数组，包围盒数组 vector 传输
-	void getBvhArray(std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
-	// 获得 BvhTree 中节点总数
-	GLuint getBvhNodeNum();
-};
-

ArchitectureColoredPainting/src/Renderer/Camera.cpp

@@ -1,5 +1,5 @@
 #include "Camera.h"
-
+using namespace Renderer;
 
 
 // constructor with vectors

ArchitectureColoredPainting/src/Renderer/Camera.h

@@ -5,12 +5,8 @@
 #include <QtMath>
 #include <QOpenGLFunctions_4_5_Compatibility>
 
-// Default camera values
+namespace Renderer
-const float YAW = -90.0f;
+{
-const float PITCH = 0.0f;
-const float SPEED = 200.f;
-const float SENSITIVITY = 0.1f;
-const float ZOOM = 45.0f;
 
 	// Defines several possible options for camera movement. Used as abstraction to stay away from window-system specific input methods
 	enum Camera_Movement {
@@ -26,6 +22,12 @@ class Camera
 	{
 
 	public:
+		// Default camera values
+		static constexpr float YAW = -90.0f;
+		static constexpr float PITCH = 0.0f;
+		static constexpr float SPEED = 200.f;
+		static constexpr float SENSITIVITY = 0.1f;
+		static constexpr float ZOOM = 45.0f;
 		// camera Attributes
 		QVector3D Position;
 		QVector3D Front;
@@ -68,3 +70,4 @@ private:
 		void updateCameraVectors();
 	};
 
+}

ArchitectureColoredPainting/src/Renderer/CubicBezier.h

@@ -1,20 +0,0 @@
-#pragma once
-#include "Line.h"
-#include <memory>
-
-class CubicBezier : public Line
-{
-	using Line::Line;
-private:
-	static Point getPointByT(Point a, Point b, double t);
-	static Point calculateControlPoint(Point a, Point b);
-	static void findPointsOfDivison(vector<double> &p, vector<double>& res);
-	void splitBezierCubic(double t, vector<LinePtr>& res);
-public: 
-	virtual double findTByValue(double value, bool isY);
-	virtual void monotonization(vector <LinePtr>& res);
-	virtual double getLineValueByT(double t, bool isY);
-	virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
-	void transformToCubic();
-};
-

ArchitectureColoredPainting/src/Renderer/CubicMonotonization.h

@@ -1,24 +0,0 @@
-#include <utility>
-#include <vector>
-#include <algorithm>
-#pragma once
-using std::pair;
-using std::vector;
-using std::min;
-using std::max;
-using std::sort;
-class CubicMonotonization
-{
-typedef pair<double, double> point;
-typedef vector<point> Line;
-private:
-	static const double eps;
-	point getPointByT(point a, point b, double t) const;
-	void findPointsOfDivison(vector<double> p, vector<double> &res);
-	double getBezierPoint(vector<double> &p, double t) const;
-	void splitBezierCubic(Line& p, point mid, double t, vector <Line> &res);
-public:
-	// p 为端点、控制点、控制点、端点， res 为所有导数为0的点
-	void getPointsOfDivision(Line p, vector <Line> &res);
-};
-

ArchitectureColoredPainting/src/Renderer/Drawable.h

@@ -1,8 +1,10 @@
 #pragma once
+namespace Renderer
+{
     class Drawable
     {
     public:
         virtual void draw() = 0;
         virtual void drawShadow() = 0;
     };
-
+}

ArchitectureColoredPainting/src/Renderer/Light.cpp

@@ -1,6 +1,6 @@
 #include "Light.h"
 #include <qDebug>
-
+using namespace Renderer;
 Light::Light(Camera* camera)
 	: camera(camera)
 	//, shadowCascadeLevels{ camera->FarPlane / 25.0f, camera->FarPlane / 12.0f, camera->FarPlane / 6.0f, camera->FarPlane / 3.0f }

ArchitectureColoredPainting/src/Renderer/Light.h

@@ -9,6 +9,8 @@
 #include "Camera.h"
 #include "Model.h"
 
+namespace Renderer
+{
     class Light
     {
     public:
@@ -26,4 +28,5 @@ private:
         Camera* camera;
 
     };
+}
 

ArchitectureColoredPainting/src/Renderer/Line.h

@@ -1,65 +0,0 @@
-#pragma once
-#include <vector>
-#include <utility>
-#include <vector>
-#include <QVector4D>
-#include <algorithm>
-#include <memory>
-#include <iostream>
-
-using std::vector;
-using std::pair;
-using std::min;
-using std::max;
-using std::sort;
-using std::shared_ptr;
-using std::make_shared;
-using std::swap;
-
-const double eps = 1e-5;
-
-struct Point {
-	double x, y;
-	Point operator + (const Point a) { return { x + a.x, y + a.y }; }
-	Point operator - (const Point a) { return { x - a.x, y - a.y }; }
-	Point operator * (const double a) { return { x * a, y * a }; }
-	double operator * (const Point a) { return x * a.y - y * a.x; }
-	bool operator== (const Point& a) const {
-		return fabs(x - a.x) <= eps && fabs(y - a.y) <= eps;
-	}
-	bool operator< (const Point& a) const {
-		return fabs(x - a.x) <= eps ? y < a.y : x < a.x;
-	}
-	void show() {
-		std::cout << '(' << x << ',' << y << ')' << ' ';
-	}
-};
-
-class Line
-{
-protected:
-	vector<double> vX, vY;
-	int siz;
-public:
-	typedef shared_ptr<Line> LinePtr;
-	Line() :siz(0) {}
-	Line(vector<Point> Vp);
-	int size();
-	void clear();
-	Point getBegin();
-	Point getEnd();
-	int direction(bool isY);
-	virtual double getLineValueByT(double t, bool isY) = 0;
-	virtual void monotonization(vector <LinePtr>& res) = 0;
-	virtual int judgeBoundIntersection(double xy, double l, double r, bool isY) = 0;
-	virtual bool judgeIntersection(QVector4D bound);
-	bool isLineContained(QVector4D bound);
-	Point operator[](int index) const;
-	Point getPointByIndex(int index) const;
-	vector<Point> toPointVector() const;
-	void setPointByIndex(int index, Point now);
-	void push_back(Point now);
-	virtual ~Line() {}
-};
-
-typedef shared_ptr<Line> LinePtr;

ArchitectureColoredPainting/src/Renderer/Mesh.cpp

@@ -1,5 +1,5 @@
 #include "Mesh.h"
-
+using namespace Renderer;
 Mesh::Mesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
 	: glFunc(glFunc)
 	, shaderProgram(shaderProgram)

ArchitectureColoredPainting/src/Renderer/Mesh.h

@@ -13,7 +13,8 @@
 #include <assimp/scene.h>
 #include <assimp/postprocess.h>
 #include "Drawable.h"
-
+namespace Renderer
+{
 	struct Vertex
 	{
 		QVector3D Position;
@@ -59,3 +60,4 @@ private:
 		QOpenGLBuffer VBO, EBO;
 
 	};
+}

ArchitectureColoredPainting/src/Renderer/Model.cpp

@@ -6,10 +6,11 @@
 #include <iostream>
 #include "PaintingMesh.h"
 #include <QtMath>
-#include "BvhTree.h"
+#include "Painting/BvhTree.h"
-#include "ShortCutTree.h"
+#include "Painting/ShortCutTree.h"
 #include "../SvgParser.h"
-
+using namespace Renderer;
+using std::vector;
 Model::Model(QString path, QOpenGLContext* context, QOpenGLShaderProgram* shaderProgram)
 	: context(context)
 	, glFunc(context->versionFunctions<QOpenGLFunctions_4_5_Compatibility>())

ArchitectureColoredPainting/src/Renderer/Model.h

@@ -2,9 +2,11 @@
 
 #include "Mesh.h"
 #include "Drawable.h"
-#include "PaintingHelper.h"
+#include "Painting/PaintingHelper.h"
 #include <QDir>
 
+namespace Renderer
+{
 	class Model
 	{
 	public:
@@ -48,3 +50,4 @@ private:
 		QVector<Texture*> loadMaterialTextures(aiMaterial* mat, aiTextureType type, QString typeName);
 
 	};
+}

ArchitectureColoredPainting/src/Renderer/Painting/BvhTree.cpp

@@ -1,5 +1,5 @@
 #include "BvhTree.h"
-
+using namespace Renderer;
 GLuint BvhTree::getBvhNodeNum() {
 	return tot;
 }

ArchitectureColoredPainting/src/Renderer/Painting/BvhTree.h

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <QOpenGLTexture>
+#include <QOpenGLContext>
+#include <QTextCodec>
+#include <algorithm>
+#include <QVector4D>
+#include <iostream>
+#include <memory>
+#include <vector>
+#include <cmath>
+
+namespace Renderer
+{
+	struct BvhTreeData {
+		QVector4D bound;
+		GLuint leftSon, rightSon;
+		void show() {
+			printf("Bvh: (%lf, %lf) (%lf, %lf): %d %d\n",
+				bound.x(), bound.y(), bound.z(), bound.w(),
+				leftSon, rightSon);
+		}
+		BvhTreeData(QVector4D bound, GLuint leftSon, GLuint rightSon)
+			: bound(bound), leftSon(leftSon), rightSon(rightSon) {}
+		BvhTreeData()
+			: leftSon(0), rightSon(0) {}
+		~BvhTreeData() {}
+	};
+	// BvhTree 节点
+	struct BvhNode {
+		GLuint lab;
+		bool isLeaf;
+		QVector4D bound;
+		std::shared_ptr<BvhNode> child[2];
+		static bool x_compare(BvhTreeData a, BvhTreeData b) {
+			return a.bound.x() < b.bound.x();
+		}
+		static bool y_compare(BvhTreeData a, BvhTreeData b) {
+			return a.bound.y() < b.bound.y();
+		}
+		GLuint getLeftSon(int k) {
+			if (isLeaf) {
+				return 0x80000000 + child[0]->lab;
+			}
+			return child[0]->lab;
+		}
+		GLuint getRightSon(int k) {
+			if (isLeaf) {
+				return child[1]->lab;
+			}
+			return child[1]->lab;
+		}
+		BvhNode() {
+			child[0] = child[1] = NULL;
+			isLeaf = false;
+			lab = 0;
+		}
+		int maximumBound() {
+			return (std::fabs(bound.x() - bound.w()) < std::fabs(bound.y() - bound.z()));
+		}
+		~BvhNode() {}
+	};
+
+	typedef std::shared_ptr<BvhNode> BvhPtr;
+
+	class BvhTree
+	{
+
+	private:
+		GLuint tot;
+		BvhPtr root;
+		static QVector4D calcBound(BvhTreeData initBound[], int l, int r);
+		static QVector4D Union(QVector4D a, QVector4D b);
+		BvhPtr subBvhTree(BvhTreeData initBound[], int l, int r);
+		void traverseBvhTree(BvhPtr now, std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
+	public:
+		BvhTree() {
+			tot = 0;
+			root = NULL;
+		}
+		// 根据底层包围盒生成bvh树
+		void buildBvhTree(BvhTreeData initBound[], int len);
+		// 获得 Bvh （rootBvh部分）的 children 数组，包围盒数组 vector 传输
+		void getBvhArray(std::vector<GLuint>& children, std::vector<QVector4D>& bounds);
+		// 获得 BvhTree 中节点总数
+		GLuint getBvhNodeNum();
+	};
+
+}

ArchitectureColoredPainting/src/Renderer/Painting/CubicBezier.cpp

@@ -1,5 +1,6 @@
 #include "CubicBezier.h"
-
+using namespace Renderer;
+using std::vector;
 double CubicBezier::getLineValueByT(double t, bool isY) {
 	vector<double> p;
 	if (isY) p = vY;

ArchitectureColoredPainting/src/Renderer/Painting/CubicBezier.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "Line.h"
+#include <memory>
+namespace Renderer
+{
+	class CubicBezier : public Line
+	{
+		using Line::Line;
+	private:
+		static Point getPointByT(Point a, Point b, double t);
+		static Point calculateControlPoint(Point a, Point b);
+		static void findPointsOfDivison(std::vector<double>& p, std::vector<double>& res);
+		void splitBezierCubic(double t, std::vector<LinePtr>& res);
+	public:
+		virtual double findTByValue(double value, bool isY);
+		virtual void monotonization(std::vector <LinePtr>& res);
+		virtual double getLineValueByT(double t, bool isY);
+		virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
+		void transformToCubic();
+	};
+}

ArchitectureColoredPainting/src/Renderer/Painting/CubicMonotonization.cpp

@@ -1,5 +1,9 @@
 #include "CubicMonotonization.h"
-
+using namespace Renderer;
+using std::vector;
+using std::min;
+using std::max;
+using std::sort;
 const double CubicMonotonization::eps = 1e-6;
 
 

ArchitectureColoredPainting/src/Renderer/Painting/CubicMonotonization.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <utility>
+#include <vector>
+#include <algorithm>
+
+namespace Renderer
+{
+	class CubicMonotonization
+	{
+		typedef std::pair<double, double> point;
+		typedef std::vector<point> Line;
+	private:
+		static const double eps;
+		point getPointByT(point a, point b, double t) const;
+		void findPointsOfDivison(std::vector<double> p, std::vector<double>& res);
+		double getBezierPoint(std::vector<double>& p, double t) const;
+		void splitBezierCubic(Line& p, point mid, double t, std::vector <Line>& res);
+	public:
+		// p 为端点、控制点、控制点、端点， res 为所有导数为0的点
+		void getPointsOfDivision(Line p, std::vector <Line>& res);
+	};
+
+}

ArchitectureColoredPainting/src/Renderer/Painting/Line.cpp

@@ -1,5 +1,13 @@
 #include "Line.h"
-
+using namespace Renderer;
+using std::vector;
+using std::pair;
+using std::min;
+using std::max;
+using std::sort;
+using std::shared_ptr;
+using std::make_shared;
+using std::swap;
 Line::Line(vector<Point> Vp) {
 	siz = Vp.size();
 	for (Point now : Vp) {

ArchitectureColoredPainting/src/Renderer/Painting/Line.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <vector>
+#include <utility>
+#include <vector>
+#include <QVector4D>
+#include <algorithm>
+#include <memory>
+#include <iostream>
+namespace Renderer
+{
+
+	const double eps = 1e-5;
+
+	struct Point {
+		double x, y;
+		Point operator + (const Point a) { return { x + a.x, y + a.y }; }
+		Point operator - (const Point a) { return { x - a.x, y - a.y }; }
+		Point operator * (const double a) { return { x * a, y * a }; }
+		double operator * (const Point a) { return x * a.y - y * a.x; }
+		bool operator== (const Point& a) const {
+			return fabs(x - a.x) <= eps && fabs(y - a.y) <= eps;
+		}
+		bool operator< (const Point& a) const {
+			return fabs(x - a.x) <= eps ? y < a.y : x < a.x;
+		}
+		void show() {
+			std::cout << '(' << x << ',' << y << ')' << ' ';
+		}
+	};
+
+	class Line
+	{
+	protected:
+		std::vector<double> vX, vY;
+		int siz;
+	public:
+		typedef std::shared_ptr<Line> LinePtr;
+		Line() :siz(0) {}
+		Line(std::vector<Point> Vp);
+		int size();
+		void clear();
+		Point getBegin();
+		Point getEnd();
+		int direction(bool isY);
+		virtual double getLineValueByT(double t, bool isY) = 0;
+		virtual void monotonization(std::vector <LinePtr>& res) = 0;
+		virtual int judgeBoundIntersection(double xy, double l, double r, bool isY) = 0;
+		virtual bool judgeIntersection(QVector4D bound);
+		bool isLineContained(QVector4D bound);
+		Point operator[](int index) const;
+		Point getPointByIndex(int index) const;
+		std::vector<Point> toPointVector() const;
+		void setPointByIndex(int index, Point now);
+		void push_back(Point now);
+		virtual ~Line() {}
+	};
+}

ArchitectureColoredPainting/src/Renderer/Painting/Painting.cpp

@@ -0,0 +1,8 @@
+#include "Painting.h"
+
+using namespace Renderer;
+Painting::Painting()
+{
+}
+
+

ArchitectureColoredPainting/src/Renderer/Painting/Painting.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <vector>
+#include <QOpenGLFunctions_4_5_Compatibility>
+#include "Line.h"
+
+namespace Renderer 
+{
+	class Painting
+	{
+		std::vector<GLuint> paintingOffsets;
+		std::vector<GLuint> bvhChildren;
+		std::vector<QVector4D> bvhBound;
+		std::vector<GLuint> elementOffset;
+		std::vector<GLuint> elementIndex;
+		std::vector<GLfloat> elementData;
+		int paintingId = 0;
+	public:
+		Painting();
+		
+	};
+}
+
+

ArchitectureColoredPainting/src/Renderer/Painting/PaintingHelper.cpp

@@ -1,5 +1,5 @@
 #include "PaintingHelper.h"
-
+using namespace Renderer;
 
 PaintingHelper::PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc) :glFunc(glFunc)
 {

ArchitectureColoredPainting/src/Renderer/Painting/PaintingHelper.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <vector>
+#include <QDebug>
+#include <QVector4D>
+#include <QOpenGLFunctions_4_5_Compatibility>
+#include "BvhTree.h"
+namespace Renderer
+{
+	class PaintingHelper
+	{
+	private:
+		QOpenGLFunctions_4_5_Compatibility* glFunc;
+		GLuint paintingOffsetsSSBO, bvhSSBO, bvhBoundSSBO, elementOffsetSSBO, elementIndexSSBO, elementDataSSBO;
+		std::vector<GLuint> paintingOffsets;
+		std::vector<GLuint> bvhChildren;
+		std::vector<QVector4D> bvhBound;
+		std::vector<GLuint> elementOffset;
+		std::vector<GLuint> elementIndex;
+		std::vector<GLfloat> elementData;
+		int paintingCount = 0;
+
+	public:
+		PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc);
+		int addPainting(GLuint paintingBvhLength, std::vector<GLuint> bvhChildren, std::vector<QVector4D> bvhBound,
+			std::vector<GLuint> elementOffset, std::vector<GLuint> elementIndex, std::vector<GLfloat> elementData);
+		void allocateBuffers();
+		void bindPaintingBuffers();
+	};
+
+}

ArchitectureColoredPainting/src/Renderer/Painting/ShortCutTree.cpp

@@ -1,6 +1,12 @@
 #include "ShortCutTree.h"
 #include <qDebug>
-
+using namespace Renderer;
+using std::queue;
+using std::map;
+using std::for_each;
+using std::set;
+using std::pair;
+using std::vector;
 void ShortCutTree::init() {
 	restOfTreeNodes.clear();
 	allLine.clear();
@@ -57,9 +63,9 @@ bool ShortCutTree::isLineEqual(PointIndexVector& a, PointIndexVector& b) const {
 	return true;
 }
 
-void ShortCutTree::monotonization(vector<PointVector>& inLines, vector<LinePtr>& outLines) {
+void ShortCutTree::monotonization(vector<PointVector>& inLines, vector<std::shared_ptr<Line>>& outLines) {
 	for (PointVector&l: inLines) {
-		LinePtr nowLine;
+		std::shared_ptr<Line> nowLine;
 		switch(l.size()) {
 			case 2: nowLine.reset(new StraightLine(l)); break;
 			case 3: case 4: nowLine.reset(new CubicBezier(l)); break;

ArchitectureColoredPainting/src/Renderer/Painting/ShortCutTree.h

@@ -0,0 +1,62 @@
+#pragma once
+#include "CubicBezier.h"
+#include "StraightLine.h"
+#include "BvhTree.h"
+#include <queue>
+#include <set>
+namespace Renderer
+{
+
+
+	struct ShortCutNode {
+		typedef std::vector<Point> vectorPoint;
+		int windingIncrement, eastGroup;
+		bool divided;
+		/* type 代表进入广度优先搜索队列的节点种类：
+		0：不需要拆开的节点
+		1：需要拆分*/
+		QVector4D bound;
+		std::vector<int> lineSet;
+		ShortCutNode() {
+			divided = true;
+			windingIncrement = 0;
+			eastGroup = 0;
+			lineSet.clear();
+			bound = { 0, 0, 0, 0 };
+		}
+		~ShortCutNode() {}
+	};
+	class ShortCutTree
+	{
+		typedef std::vector<Point>  PointVector;
+		typedef std::vector<int> PointIndexVector;
+	private:
+		std::vector<ShortCutNode> restOfTreeNodes;
+		std::vector<std::shared_ptr<Line>> allLine;
+		int RequiredLineMin, numPoint, numLine;
+		std::map<Point, int> pointMap;
+		std::vector<int> lineIndexs;
+
+		int getPointIndex(Point nowPoint);
+		void generateShortCutsegmentement(ShortCutNode& nowTreeNode);
+		bool handleShortCutNode(ShortCutNode& fa, ShortCutNode& nowTreeNode, double yValue, std::vector<ShortCutNode>& v, int& sumIncrement);
+		void spliteToShortCutTree();
+		static void monotonization(std::vector<PointVector>& inL, std::vector<std::shared_ptr<Line>>& outL);
+		bool isLineEqual(PointIndexVector& a, PointIndexVector& b) const;
+		void simplifyLineVector();
+		// 需要测试，随机获得合理的边界
+		static bool IsBorderValueResonable(double value, std::set <double>& valueSet);
+		static double findBorderValueNotOnLine(double value, std::set <double>& valueSet);
+	public:
+		void init();
+		//lineMin最小线数目，即划分终止条件
+		ShortCutTree(int lineMin = 3)
+			:RequiredLineMin(lineMin), numPoint(0), numLine(0) {}
+		// 传入一个vector<vector<Point> > 作为所有输入的线
+		void buildShortCutTree(std::vector<PointVector>& lineSet);
+		// 获得点集合和线集合 返回输入BvhTree的数据集合
+		std::vector<BvhTreeData> getPointLineAndBvhTree(std::vector<float>& pointSet, std::vector<GLuint>& lineSet);
+		~ShortCutTree() {}
+	};
+
+}

ArchitectureColoredPainting/src/Renderer/Painting/StraightLine.cpp

@@ -1,5 +1,6 @@
 #include "StraightLine.h"
-
+using namespace Renderer;
+using std::swap;
 double StraightLine::getLineValueByT(double t, bool isY) {
 	double valueBegin, valueEnd;
 	if (isY) {

ArchitectureColoredPainting/src/Renderer/Painting/StraightLine.h

@@ -0,0 +1,12 @@
+#include "Line.h"
+namespace Renderer
+{
+	class StraightLine : public Line
+	{
+		using Line::Line;
+		virtual double getLineValueByT(double t, bool isY);
+		virtual void monotonization(std::vector <LinePtr>& res) {};
+		virtual double findTByValue(double value, bool isY);
+		virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
+	};
+}

ArchitectureColoredPainting/src/Renderer/PaintingHelper.h

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <QDebug>
-#include <QVector4D>
-#include <QOpenGLFunctions_4_5_Compatibility>
-#include "BvhTree.h"
-
-class PaintingHelper
-{
-private:
-	QOpenGLFunctions_4_5_Compatibility* glFunc;
-	GLuint paintingOffsetsSSBO, bvhSSBO, bvhBoundSSBO, elementOffsetSSBO, elementIndexSSBO, elementDataSSBO;
-	std::vector<GLuint> paintingOffsets;
-	std::vector<GLuint> bvhChildren;
-	std::vector<QVector4D> bvhBound;
-	std::vector<GLuint> elementOffset;
-	std::vector<GLuint> elementIndex;
-	std::vector<GLfloat> elementData;
-	int paintingCount = 0;
-	
-public:
-	PaintingHelper(QOpenGLFunctions_4_5_Compatibility* glFunc);
-	int addPainting(GLuint paintingBvhLength, std::vector<GLuint> bvhChildren, std::vector<QVector4D> bvhBound,
-					std::vector<GLuint> elementOffset, std::vector<GLuint> elementIndex, std::vector<GLfloat> elementData);
-	void allocateBuffers();
-	void bindPaintingBuffers();
-};
-

ArchitectureColoredPainting/src/Renderer/PaintingMesh.cpp

@@ -1,5 +1,5 @@
 #include "PaintingMesh.h"
-
+using namespace Renderer;
 PaintingMesh::PaintingMesh(QOpenGLFunctions_4_5_Compatibility* glFunc, QOpenGLShaderProgram* shaderProgram, QOpenGLShaderProgram* shadowProgram, aiMatrix4x4 model)
     : glFunc(glFunc)
     , shaderProgram(shaderProgram)

ArchitectureColoredPainting/src/Renderer/PaintingMesh.h

@@ -15,6 +15,8 @@
 #include <assimp/postprocess.h>
 #include "Drawable.h"
 
+namespace Renderer
+{
 	struct PaintingVertex
 	{
 		QVector3D Position;
@@ -46,3 +48,4 @@ private:
 		QOpenGLBuffer VBO, EBO;
 
 	};
+}

ArchitectureColoredPainting/src/Renderer/RendererGLWidget.cpp

@@ -6,7 +6,7 @@
 #include <QScreen>
 #include <QGuiApplication>
 #include <random>
-
+using namespace Renderer;
 //QVector3D lightPositions[] = { 2000 * QVector3D(0.2, 4, 1).normalized(), QVector3D(100,100,100) ,QVector3D(-100,100,100) ,QVector3D(100,100,-100) };
 QVector3D lightColors[] = { 20 * QVector3D(0.7529,0.7450,0.6784).normalized(), QVector3D(0,0,0) ,QVector3D(0,0,0) ,QVector3D(0,0,0) };
 static float sunPitch = 105, sunYaw = 80;

ArchitectureColoredPainting/src/Renderer/RendererGLWidget.h

@@ -10,8 +10,9 @@
 #include "Camera.h"
 #include "Light.h"
 #include "Model.h"
-#include "PaintingHelper.h"
+#include "Painting/PaintingHelper.h"
-
+namespace Renderer
+{
     class RendererGLWidget : public QOpenGLWidget, protected QOpenGLFunctions_4_5_Compatibility
     {
         Q_OBJECT
@@ -65,4 +66,4 @@ private:
         Model* model;
         PaintingHelper* paintingHelper;
     };
-
+}

ArchitectureColoredPainting/src/Renderer/RendererWidget.cpp

@@ -1,6 +1,6 @@
 #include "RendererWidget.h"
 #include "RendererGLWidget.h"
-
+using namespace Renderer;
 RendererWidget::RendererWidget(QWidget *parent)
 	: QWidget(parent)
 {

ArchitectureColoredPainting/src/Renderer/RendererWidget.h

@@ -2,7 +2,8 @@
 
 #include <QWidget>
 #include "ui_RendererWidget.h"
-
+namespace Renderer
+{
 	class RendererWidget : public QWidget
 	{
 		Q_OBJECT
@@ -16,3 +17,4 @@ public slots:
 	private:
 		Ui::RendererWidgetClass ui;
 	};
+}

ArchitectureColoredPainting/src/Renderer/ShortCutTree.h

@@ -1,63 +0,0 @@
-#pragma once
-#include "CubicBezier.h"
-#include "StraightLine.h"
-#include "BvhTree.h"
-#include <queue>
-#include <set>
-
-using std::queue;
-using std::map;
-using std::for_each;
-using std::set;
-
-struct ShortCutNode {
-	typedef vector<Point> vectorPoint;
-	int windingIncrement, eastGroup;
-	bool divided;
-	/* type 代表进入广度优先搜索队列的节点种类：
-	0：不需要拆开的节点
-	1：需要拆分*/
-	QVector4D bound;
-	vector<int> lineSet;
-	ShortCutNode() {
-		divided = true;
-		windingIncrement = 0;
-		eastGroup = 0;
-		lineSet.clear();
-		bound = { 0, 0, 0, 0 };
-	}
-	~ShortCutNode() {}
-};
-class ShortCutTree
-{
-	typedef vector<Point>  PointVector;
-	typedef vector<int> PointIndexVector;
-private:
-	vector<ShortCutNode> restOfTreeNodes;
-	vector<LinePtr> allLine;
-	int RequiredLineMin, numPoint, numLine;
-	map<Point, int> pointMap;
-	vector<int> lineIndexs;
-
-	int getPointIndex(Point nowPoint);
-	void generateShortCutsegmentement(ShortCutNode& nowTreeNode);
-	bool handleShortCutNode(ShortCutNode& fa, ShortCutNode& nowTreeNode, double yValue, vector<ShortCutNode>& v, int& sumIncrement);
-	void spliteToShortCutTree();
-	static void monotonization(vector<PointVector>& inL, vector<LinePtr> &outL);
-	bool isLineEqual(PointIndexVector& a, PointIndexVector& b) const;
-	void simplifyLineVector();
-	// 需要测试，随机获得合理的边界
-	static bool IsBorderValueResonable(double value, set <double>& valueSet);
-	static double findBorderValueNotOnLine(double value, set <double>& valueSet);
-public:
-	void init();
-	//lineMin最小线数目，即划分终止条件
-	ShortCutTree(int lineMin = 3)
-		:RequiredLineMin(lineMin), numPoint(0), numLine(0) {}
-	// 传入一个vector<vector<Point> > 作为所有输入的线
-	void buildShortCutTree(vector<PointVector>& lineSet);
-	// 获得点集合和线集合 返回输入BvhTree的数据集合
-	vector<BvhTreeData> getPointLineAndBvhTree(vector<float> &pointSet, vector<GLuint> &lineSet);
-	~ShortCutTree() {}
-};
-

ArchitectureColoredPainting/src/Renderer/StraightLine.h

@@ -1,10 +0,0 @@
-#include "Line.h"
-
-class StraightLine : public Line 
-{
-	using Line::Line;
-	virtual double getLineValueByT(double t, bool isY);
-	virtual void monotonization(vector <LinePtr>& res) {};
-	virtual double findTByValue(double value, bool isY);
-	virtual int judgeBoundIntersection(double xy, double l, double r, bool isY);
-};

ArchitectureColoredPainting/src/SvgParser.cpp

@@ -484,7 +484,7 @@ namespace SVGParser
 	}
 
 }; // namespace SVGParser
-
+using Renderer::Point;
 SvgParser::SvgParser(const std::string path, double width, double height) : path(path), width(width), height(height)
 {
 }

ArchitectureColoredPainting/src/SvgParser.h

@@ -1,9 +1,9 @@
 #pragma once
 
-#include "Renderer/Line.h"
+#include "Renderer/Painting/Line.h"
 #include <cmath>
 #include <string>
-using namespace std;
+
 namespace SVGParser
 {
 	enum SVGCommandType
@@ -140,7 +140,7 @@ class SVGClosePath : public SVGCommand
 		virtual SVGCommandType getType();
 		virtual std::string toString2();
 	};
-typedef vector<std::shared_ptr<SVGCommand>> SVGPath;
+	typedef std::vector<std::shared_ptr<SVGCommand>> SVGPath;
 	SVGPath parsePath(std::istream&);
 
 	std::ostream& operator<<(std::ostream&, const SVGParser::SVGPath&);
@@ -150,7 +150,7 @@ class SvgParser
 {
 public:
 	SvgParser(const std::string path, const double width, const double height);
-    vector<vector<Point>> parse();
+	std::vector<std::vector<Renderer::Point>> parse();
 
 private:
 	static constexpr const double eps = 1e-6;
@@ -159,15 +159,15 @@ class SvgParser
 	const double width;
 	const double height;
 
-    Point convertPoint(double x, double y);
+	Renderer::Point convertPoint(double x, double y);
-    Point clampPoint(Point p);
+	Renderer::Point clampPoint(Renderer::Point p);
-    Point convertAbsPoint(double x, double y);
+	Renderer::Point convertAbsPoint(double x, double y);
-    Point convertRelPoint(Point pointBegin, double x, double y);
+	Renderer::Point convertRelPoint(Renderer::Point pointBegin, double x, double y);
-    void ellipticalArcConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA,
+	void ellipticalArcConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA,
-                                         bool flagS, Point endPoint,vector<vector<Point>>& lines);
+		bool flagS, Renderer::Point endPoint, std::vector<std::vector<Renderer::Point>>& lines);
-    vector<double> centerConverter(Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS,
+	std::vector<double> centerConverter(Renderer::Point beginPoint, double radiusX, double radiusY, double phi, bool flagA, bool flagS,
-                                   Point endPoint);
+		Renderer::Point endPoint);
-    double angleConverter(Point u, Point v);
+	double angleConverter(Renderer::Point u, Renderer::Point v);
-    Point eConverter(Point c, Point r, double cosPhi, double sinPhi, double t);
+	Renderer::Point eConverter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
-    Point e2Converter(Point c, Point r, double cosPhi, double sinPhi, double t);
+	Renderer::Point e2Converter(Renderer::Point c, Renderer::Point r, double cosPhi, double sinPhi, double t);
 };