225 lines
6.6 KiB
C++
225 lines
6.6 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Paella
|
|
// Copyright (C) 2015 - Thomas FORGIONE, Emilie JALRAS, Marion LENFANT, Thierry MALON, Amandine PAILLOUX
|
|
// Authors :
|
|
// Thomas FORGIONE
|
|
// Emilie JALRAS
|
|
// Marion LENFANT
|
|
// Thierry MALON
|
|
// Amandine PAILLOUX
|
|
//
|
|
// This file is part of the project Paella
|
|
// This software is provided 'as-is', without any express or implied warranty.
|
|
// In no event will the authors be held liable for any damages arising from the use of this software.
|
|
//
|
|
// Permission is granted to anyone to use this software for any purpose,
|
|
// including commercial applications, and to alter it and redistribute it freely,
|
|
// subject to the following restrictions:
|
|
//
|
|
// 1. The origin of this software must not be misrepresented;
|
|
// you must not claim that you wrote the original software.
|
|
// If you use this software in a product, an acknowledgment
|
|
// in the product documentation would be appreciated but is not required.
|
|
//
|
|
// 2. Altered source versions must be plainly marked as such,
|
|
// and must not be misrepresented as being the original software.
|
|
//
|
|
// 3. This notice may not be removed or altered from any source distribution.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <memory>
|
|
#include <cmath>
|
|
#include <SFML/Window.hpp>
|
|
#include <SFML/Graphics.hpp>
|
|
#include <SFML/OpenGL.hpp>
|
|
#include <GL/gl.h>
|
|
#include <GL/glu.h>
|
|
|
|
#include <SFMLTools/FreeFlyCamera.hpp>
|
|
|
|
// Yes, this is a uggly hack... I need it to make this test work
|
|
#define private public
|
|
#include <Skeleton/Skeleton.hpp>
|
|
#undef private
|
|
|
|
|
|
// Full hd : 1920x1080
|
|
constexpr auto WIDTH = 1920;
|
|
constexpr auto HEIGHT = 1080;
|
|
|
|
void drawScene(sft::FreeFlyCamera const& camera, Skeleton const& s, Skeleton const& s2, std::vector<std::pair<unsigned int, unsigned int>> const& matching, std::vector<std::array<float,3>> const& colors);
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
if (argc < 2)
|
|
{
|
|
std::cout << "I need a skeleton !" << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
|
|
std::srand(std::time(0));
|
|
|
|
// Création de la fenêtre
|
|
sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT),
|
|
"Skeleton",
|
|
sf::Style::Fullscreen,
|
|
sf::ContextSettings(32));
|
|
|
|
window.setVerticalSyncEnabled(true);
|
|
window.setMouseCursorVisible(false);
|
|
|
|
//Initialisation du mode 3D
|
|
glMatrixMode(GL_PROJECTION);
|
|
glLoadIdentity();
|
|
gluPerspective(70,(double)WIDTH/HEIGHT,0.2,10000);
|
|
|
|
// Initialisation de Z-Buffer
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
// Activer les textures
|
|
glEnable(GL_TEXTURE_2D);
|
|
|
|
// Autoriser la transparence
|
|
glEnable(GL_BLEND);
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
// Ces 2 lignes améliorent le rendu
|
|
glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);
|
|
glHint(GL_POINT_SMOOTH_HINT,GL_NICEST);
|
|
|
|
// On efface le tampon d'affichage
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glFlush();
|
|
|
|
// Init mesh
|
|
Skeleton s, s2;
|
|
s.loadFromFile(std::string{argv[1]});
|
|
std::vector<std::pair<unsigned int, unsigned int>> matching;
|
|
s.split();
|
|
|
|
#include "init.cxx"
|
|
|
|
if (argc > 2)
|
|
{
|
|
s2.loadFromFile(std::string{argv[2]});
|
|
s2.split();
|
|
std::swap(s2.m_branches[0], s2.m_branches[1]);
|
|
|
|
std::cout << "Matching..." << std::endl;
|
|
matching = branchesMatching(keypoints1, s, s2);
|
|
std::cout << "Finished..." << std::endl;
|
|
|
|
for (auto const& pair : matching)
|
|
std::cout << pair.first << " -> " << pair.second << std::endl;
|
|
}
|
|
|
|
|
|
std::vector<std::array<float,3>> colors;
|
|
|
|
for (auto i = 0u; i < s.numberOfBranches(); i++)
|
|
{
|
|
float r = static_cast<float>(std::rand())/RAND_MAX;
|
|
float g = static_cast<float>(std::rand())/RAND_MAX;
|
|
float b = static_cast<float>(std::rand())/RAND_MAX;
|
|
colors.push_back({{r,g,b}});
|
|
}
|
|
|
|
// Camera
|
|
auto camera = sft::FreeFlyCamera{};
|
|
|
|
// la boucle principale
|
|
auto running = true;
|
|
auto captureRequired = false;
|
|
while (running)
|
|
{
|
|
// gestion des évènements
|
|
sf::Event event;
|
|
while (window.pollEvent(event))
|
|
{
|
|
if (event.type == sf::Event::Closed)
|
|
{
|
|
// on stoppe le programme
|
|
running = false;
|
|
}
|
|
else if (event.type == sf::Event::KeyPressed)
|
|
{
|
|
if (event.key.code == sf::Keyboard::Escape)
|
|
{
|
|
running = false;
|
|
}
|
|
else if (event.key.code == sf::Keyboard::P)
|
|
{
|
|
captureRequired = true;
|
|
}
|
|
}
|
|
else if (event.type == sf::Event::MouseMoved)
|
|
{
|
|
// Hum...
|
|
}
|
|
else if (event.type == sf::Event::Resized)
|
|
{
|
|
// on ajuste le viewport lorsque la fenêtre est redimensionnée
|
|
glViewport(0, 0, event.size.width, event.size.height);
|
|
}
|
|
|
|
}
|
|
|
|
// Les trucs qui sont pas des évènements
|
|
camera.nextStep(WIDTH, HEIGHT);
|
|
sf::Mouse::setPosition(sf::Vector2i{WIDTH/2, HEIGHT/2});
|
|
|
|
// Dessin de la scene
|
|
drawScene(camera, s, s2, matching, colors);
|
|
|
|
if (captureRequired)
|
|
{
|
|
window.capture().saveToFile("capture.jpg");
|
|
captureRequired = false;
|
|
}
|
|
|
|
// termine la trame courante (en interne, échange les deux tampons de rendu)
|
|
window.display();
|
|
}
|
|
|
|
// libération des ressources...
|
|
|
|
return 0;
|
|
}
|
|
|
|
void drawScene(sft::FreeFlyCamera const& camera, Skeleton const& split, Skeleton const& split2, std::vector<std::pair<unsigned int, unsigned int>> const& matching, std::vector<std::array<float,3>> const& colors)
|
|
{
|
|
// Initialisation
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
glMatrixMode(GL_MODELVIEW);
|
|
glLoadIdentity();
|
|
|
|
// Position Camera gluLookAt(positionCamera, positionCible, vecteurVertical)
|
|
camera.look();
|
|
|
|
|
|
for (auto i = 0u; i < matching.size(); i++)
|
|
{
|
|
// Find random color
|
|
glColor3f(colors[i][0], colors[i][1], colors[i][2]);
|
|
split.draw(i);
|
|
glPushMatrix();
|
|
glTranslatef(1000,0,0);
|
|
split2.draw(i);
|
|
glPopMatrix();
|
|
glPushMatrix();
|
|
glTranslatef(0,-1500,0);
|
|
split.draw(matching[i].first);
|
|
glPushMatrix();
|
|
glTranslatef(1000,0,0);
|
|
split2.draw(matching[i].second);
|
|
glPopMatrix();
|
|
glPopMatrix();
|
|
}
|
|
|
|
// MAJ de l'écran
|
|
glFlush();
|
|
}
|