Subversion Repositories gelsvn

/*
 *  VisObj.cpp
 *  GEL
 *
 *  Created by J. Andreas Bærentzen on 20/09/08.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */

#include "VisObj.h"

#include <GLGraphics/Console.h>
#include <HMesh/Manifold.h>
#include <HMesh/AttributeVector.h>
#include <HMesh/load.h>
#include <HMesh/curvature.h>

#include <CGLA/Mat3x3d.h>
#include <CGLA/Vec3d.h>
#include <CGLA/Vec4d.h>

using namespace std;
using namespace CGLA;
using namespace HMesh;
using namespace GLGraphics;

int WINX=800, WINY=800;

namespace GLGraphics {
    
    void VisObj::refit()
    {
        bsphere(mani, bsphere_center, bsphere_radius);
        
        view_ctrl.set_centre(Vec3f(bsphere_center));
        view_ctrl.set_eye_dist(2*bsphere_radius);
    }
    
    bool VisObj::reload(string _file)
    {
        if(_file != "") file = _file;
        mani.clear();
        if(!load(file, mani))
            return false;
        refit();
        return true;
    }
    
    bool VisObj::add_mesh(string file)
    {
        if(!load(file, mani))
            return false;
        refit();
        return true;
    }
    
    
    bool VisObj::select_vertex(const CGLA::Vec2i& pos)
    {
        float d;
        if(depth_pick(pos[0], pos[1], d))
        {
            Vec3d c;
            float r;
            bsphere(mani, c, r);
            VertexID closest = InvalidVertexID;
            double min_dist = DBL_MAX;
            for(auto vid : mani.vertices())
            {
                Vec3d wp = world2screen(mani.pos(vid));
                if(sqr_length(Vec2d(wp[0],wp[1])-Vec2d(pos))<100)
                {
                    double dist = sqr_length(screen2world(pos[0], pos[1], d)-mani.pos(vid));
                    if(dist < min_dist)
                    {
                        min_dist = dist;
                        closest = vid;
                    }
                }
            }
            if(closest != InvalidVertexID) {
                vertex_selection.resize(mani.allocated_vertices(),0);
                vertex_selection[closest] = 1;
                active_selection = true;
                post_create_display_list();
                return true;
            }
        }
        return false;
        
    }

    void VisObj::produce_renderer(const std::string& display_method , Console& cs, bool smooth, float gamma)
    {
        delete renderer;
        
        string short_name = display_method.substr(0,3);
        if(short_name== "wir")
            renderer = new WireframeRenderer(mani, smooth);
        
        else if(short_name == "har")
            renderer = new HarmonicsRenderer(mani, harm, cs);
        
        else if(short_name == "iso") {
            renderer = new IsophoteLineRenderer();
            renderer->compile_display_list(mani,smooth);
        }
        else if(short_name == "ref") {
            renderer = new ReflectionLineRenderer();
            renderer->compile_display_list(mani,smooth);
        }
        else if(short_name == "gla") {
            renderer = new GlazedRenderer();
            dynamic_cast<GlazedRenderer*>(renderer)->compile_display_list(mani,smooth);
        }
        
        
        else if(short_name == "too") {
            renderer = new ToonRenderer();
            renderer->compile_display_list(mani,smooth);
        }
        
        
        else if(short_name == "cur"){
            static Console::variable<string> line_direction("min");
            static Console::variable<string> method("tensors");
            static Console::variable<int> smoothing_iter(1);
            
            line_direction.reg(cs,"display.curvature_lines.direction", "");
            method.reg(cs, "display.curvature_lines.method", "");
            smoothing_iter.reg(cs, "display.curvature_lines.smoothing_iter", "");
            
            VertexAttributeVector<Mat3x3d> curvature_tensors(mani.allocated_vertices());
            VertexAttributeVector<Vec3d> min_curv_direction(mani.allocated_vertices());
            VertexAttributeVector<Vec3d> max_curv_direction(mani.allocated_vertices());
            string _line_direction = line_direction;
            VertexAttributeVector<Vec3d>& lines = (_line_direction == "min") ? min_curv_direction : max_curv_direction;
            VertexAttributeVector<Vec2d> curvature(mani.allocated_vertices());
            
            if(string(method) == "tensors")
            {
                curvature_tensors_from_edges(mani, curvature_tensors);
                for(int i=0;i<smoothing_iter; ++i)
                    smooth_curvature_tensors(mani,curvature_tensors);
                
                curvature_from_tensors(mani, curvature_tensors,
                                       min_curv_direction,
                                       max_curv_direction,
                                       curvature);
            }
            else
                curvature_paraboloids(mani,
                                      min_curv_direction,
                                      max_curv_direction,
                                      curvature);
            
            renderer = new LineFieldRenderer();
            dynamic_cast<LineFieldRenderer*>(renderer)->compile_display_list(mani, lines);
        }
        else if(short_name == "gau"){
            static Console::variable<float> smoothing(2.0f);
            smoothing.reg(cs, "display.gaussian_curvature_renderer.smoothing", "");
            VertexAttributeVector<double> scalars(mani.allocated_vertices());
            gaussian_curvature_angle_defects(mani, scalars, smoothing);
            double max_G = 0;
            
            for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
                max_G = max(abs(scalars[*v]), max_G);
            
            renderer = new ScalarFieldRenderer();
            dynamic_cast<ScalarFieldRenderer*>(renderer)->compile_display_list(mani, smooth, scalars, max_G, gamma);
            
        }
        else if(short_name == "mea"){
            static Console::variable<int> smoothing(2);
            smoothing.reg(cs, "display.mean_curvature_renderer.smoothing", "");
            
            VertexAttributeVector<double> scalars(mani.allocated_vertices());
            mean_curvatures(mani, scalars, smoothing);
            double max_G = 0;
            double mean = 0;
            
            for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v){
                max_G = max(abs(scalars[*v]), max_G);
                mean += scalars[*v];
            }
            
            renderer = new ScalarFieldRenderer();
            dynamic_cast<ScalarFieldRenderer*>(renderer)->compile_display_list(mani, smooth, scalars, max_G, gamma);
        }
        else if(short_name == "amb"){
            static Console::variable<int> smoothing(2);
            smoothing.reg(cs, "display.ambient_occlusion_renderer.smoothing", "");
            
            VertexAttributeVector<double> scalars(mani.allocated_vertices());
            mean_curvatures(mani, scalars, smoothing);
            double max_G = 0;
            
            for(VertexIDIterator v = mani.vertices_begin(); v != mani.vertices_end(); ++v)
                max_G = max(abs(scalars[*v]), max_G);
            
            renderer = new AmbientOcclusionRenderer();
            dynamic_cast<AmbientOcclusionRenderer*>(renderer)->compile_display_list(mani, scalars, max_G);
            
        }
        else if(short_name == "deb")
        {
            renderer = new DebugRenderer;
            renderer->compile_display_list(mani, smooth);
        }
        else {
            renderer = new NormalRenderer();
            renderer->compile_display_list(mani, smooth);
        }

    
    }
    
    void VisObj::draw_selection()
    {
        Vec3d c;
        float r;
        bsphere(mani, c, r);
        r *= 0.003;
        glDisable(GL_LIGHTING);
        for(auto vid : mani.vertices())
        {
            Vec3d p = mani.pos(vid);
            if(vertex_selection[vid])
                glColor3f(1,1,0);
            else
                glColor3f(0, 0, 0.3);
            glPushMatrix();
            glTranslated(p[0], p[1], p[2]);
            glScalef(r, r, r);
            draw_ball();
            glPopMatrix();
        }
        glEnable(GL_LIGHTING);
    }

    
    void VisObj::display(const std::string& display_method , Console& cs, bool smooth, float gamma)
    {
        if(create_display_list){
            create_display_list = false;
            produce_renderer(display_method, cs, smooth, gamma);
        }
        view_ctrl.set_gl_modelview();
        renderer->draw();
        if(active_selection)
            draw_selection();
    }
}