surface_radiance.h 4.74 KB
Newer Older
1 2 3 4 5
#ifndef _SURFACE_RADIANCE_PLUGIN_H_
#define _SURFACE_RADIANCE_PLUGIN_H_

#include "plugin_interaction.h"
#include "surface_radiance_dockTab.h"
6
#include "dialog_computeRadianceDistance.h"
7 8 9

#include "Utils/sphericalHarmonics.h"
#include "Utils/Shaders/shaderRadiancePerVertex.h"
10
#include "Utils/drawer.h"
11

12
#include "Algo/Decimation/decimation.h"
13 14 15 16 17 18 19 20 21 22 23 24 25

namespace CGoGN
{

namespace SCHNApps
{

struct MapParameters
{
	MapParameters() :
		positionVBO(NULL),
		normalVBO(NULL),
		radianceTexture(NULL),
26 27 28 29 30
		paramVBO(NULL),
		positionApproximator(NULL),
		normalApproximator(NULL),
		radianceApproximator(NULL),
		selector(NULL)
31 32
	{}

33 34
	unsigned int nbVertices;

35 36 37 38 39
	Utils::VBO* positionVBO;
	Utils::VBO* normalVBO;

	CGoGN::Utils::ShaderRadiancePerVertex* radiancePerVertexShader;

40
	VertexAttribute<Utils::SphericalHarmonics<PFP2::REAL, PFP2::VEC3>, PFP2::MAP> radiance;
41 42 43
	Utils::Texture<2, Geom::Vec3f>* radianceTexture;
	VertexAttribute<Geom::Vec2i, PFP2::MAP> param;
	Utils::VBO* paramVBO;
44

45
//	DartAttribute<PFP2::REAL, PFP2::MAP> halfedgeError;
46

47 48 49
	Algo::Surface::Decimation::ApproximatorGen<PFP2>* positionApproximator;
	Algo::Surface::Decimation::ApproximatorGen<PFP2>* normalApproximator;
	Algo::Surface::Decimation::ApproximatorGen<PFP2>* radianceApproximator;
50 51

	Algo::Surface::Decimation::Selector<PFP2>* selector;
52 53 54 55 56 57
};

class Surface_Radiance_Plugin : public PluginInteraction
{
	Q_OBJECT
	Q_INTERFACES(CGoGN::SCHNApps::Plugin)
Sylvain Thery's avatar
Sylvain Thery committed
58 59 60
#if CGOGN_QT_DESIRED_VERSION == 5
	Q_PLUGIN_METADATA(IID "CGoGN.SCHNapps.Plugin")
#endif
61

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
	friend class Surface_Radiance_DockTab;

public:
	Surface_Radiance_Plugin()
	{}

	~Surface_Radiance_Plugin()
	{}

	virtual bool enable();
	virtual void disable();

	virtual void draw(View *view) {}
	virtual void drawMap(View* view, MapHandlerGen* map);

	virtual void keyPress(View* view, QKeyEvent* event) {}
	virtual void keyRelease(View* view, QKeyEvent* event) {}
	virtual void mousePress(View* view, QMouseEvent* event) {}
	virtual void mouseRelease(View* view, QMouseEvent* event) {}
	virtual void mouseMove(View* view, QMouseEvent* event) {}
	virtual void wheelEvent(View* view, QWheelEvent* event) {}

	virtual void viewLinked(View *view) {}
	virtual void viewUnlinked(View *view) {}

private slots:
	// slots called from SCHNApps signals
	void selectedViewChanged(View* prev, View* cur);
	void selectedMapChanged(MapHandlerGen* prev, MapHandlerGen* cur);
	void mapAdded(MapHandlerGen* map);
	void mapRemoved(MapHandlerGen* map);
93
	void schnappsClosing();
94 95 96 97 98 99 100 101

	// slots called from MapHandler signals
	void vboAdded(Utils::VBO* vbo);
	void vboRemoved(Utils::VBO* vbo);
	void attributeModified(unsigned int orbit, QString nameAttr);

	void importFromFileDialog();

102 103 104
	void openComputeRadianceDistanceDialog();
	void computeRadianceDistanceFromDialog();

105 106 107 108 109
public slots:
	// slots for Python calls
	void changePositionVBO(const QString& map, const QString& vbo);
	void changeNormalVBO(const QString& map, const QString& vbo);
	MapHandlerGen* importFromFile(const QString& fileName);
110 111 112 113 114
	void decimate(
		const QString& mapName,
		const QString& positionAttributeName,
		const QString& normalAttributeName,
		float decimationGoal,
115 116 117
		bool halfCollapse = false,
		bool exportMeshes = false
	);
118
	void computeRadianceDistance(const QString& mapName1,
119
		const QString& positionAttributeName1,
120
		const QString& normalAttributeName1,
121 122 123
		const QString& distanceAttributeName1,
		const QString& mapName2,
		const QString& positionAttributeName2,
124
		const QString& normalAttributeName2,
125
		const QString& distanceAttributeName2
126
	);
127 128 129 130 131
	void exportPLY(
		const QString& mapName,
		const QString& positionAttributeName,
		const QString& normalAttributeName,
		const QString& filename
132
	);
133 134

protected:
135
	MapHandlerGen* currentlyDecimatedMap() { return m_currentlyDecimatedMap; }
136
	bool currentDecimationHalf() { return m_currentDecimationHalf; }
137 138
	static void checkNbVerticesAndExport(Surface_Radiance_Plugin* p, const unsigned int* nbVertices);

139
	Surface_Radiance_DockTab* m_dockTab;
140 141 142 143

	Dialog_ComputeRadianceDistance* m_computeRadianceDistanceDialog;
	QAction* m_computeRadianceDistanceAction;

144 145
	QHash<MapHandlerGen*, MapParameters> h_mapParameterSet;

146
	MapHandlerGen* m_currentlyDecimatedMap;
147
	bool m_currentDecimationHalf;
148 149 150
	std::vector<unsigned int> exportNbVert;
	unsigned int nextExportIndex;

151
	QAction* m_importAction;
152 153 154 155 156 157 158 159 160 161 162 163 164

	static bool isInHemisphere(double x, double y, double z, void* u)
	{ // true iff [x,y,z] and u have the same direction
		PFP2::REAL* n = (PFP2::REAL*)(u);
		return x*n[0] + y*n[1] + z*n[2] >= 0.0;
	}

	static double SHEvalCartesian_Error(double x, double y, double z, void* u)
	{
		Utils::SphericalHarmonics<PFP2::REAL, PFP2::VEC3>& e = *(Utils::SphericalHarmonics<PFP2::REAL, PFP2::VEC3>*)(u);
		PFP2::VEC3 c = e.evaluate_at(x, y, z);
		return c.norm2();
	}
165 166 167 168 169 170
};

} // namespace SCHNApps

} // namespace CGoGN

171
#endif // _SURFACE_RADIANCE_PLUGIN_H_