InternalOrganMesh.h

Go to the documentation of this file.

/*

Copyright (c) 2017, Dr Franck P. Vidal (franck.p.vidal@fpvidal.net),
http://www.fpvidal.net/
All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.

3. Neither the name of the Bangor University nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


#ifndef __InternalOrganMesh_h
#define __InternalOrganMesh_h

//******************************************************************************
//  Include
//******************************************************************************
#ifndef __AnatomicalMesh_h
#include <gVirtualXRay/AnatomicalMesh.h>
#endif

#ifndef __Shader_h
#include "gVirtualXRay/Shader.h"
#endif


//******************************************************************************
//  namespace
//******************************************************************************
namespace gVirtualXRay {

//==============================================================================
//==============================================================================
class InternalOrganMesh: public AnatomicalMesh
//------------------------------------------------------------------------------
{
//******************************************************************************
public:
    //--------------------------------------------------------------------------
    /*
     *  @param texture_2D_size:                 Size of the side of the buffer
     *                                          of the 2D texture
     *                                          (default: 1024)
     *  @param texture_3D_size:                 Size of the side of the buffer
     *                                          of the 3D texture (default: 64)
     *  @param optimize_texture_coordinates:    To know if the texture
     *                                          coordinates need to be optimized
     *                                          (default: true)
     */
    //--------------------------------------------------------------------------
    InternalOrganMesh(bool optimize_texture_coordinates = true,
                      unsigned int texture_2D_size = 1024,
                      unsigned int texture_3D_size = 64);

    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual ~InternalOrganMesh();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual bool isTransparent() const;

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual bool isSoftTissue() const = 0;

    
    //--------------------------------------------------------------------------
    /*
    *   @param aShaderID: The GLSL shader used to display the anatomical mesh
    */
    //-------------------------------------------------------------------------
    virtual void defineDisplayShaderInput(int shader_id);

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void initialize() = 0;

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void splitFaces();


    virtual void copyFrom(const InternalOrganMesh& aPolygonMesh);


    virtual InternalOrganMesh& operator=(const InternalOrganMesh& aPolygonMesh);


//******************************************************************************
protected:
    enum ToCreate
    {
        TO_CREATE_BUMP_MAP,
        TO_CREATE_COLOUR_TEXTURE
    };

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void generateTextures() = 0;

    
    //--------------------------------------------------------------------------
    /*
     *  @param shader:          The GLSL shader
     *  @param frame_buffer:    The frame buffer the texture will be rendered to
     *  @param to_create:       To know if a bump map or a colour texture has to
     *                          be created
     */
    //--------------------------------------------------------------------------
    virtual void generate2DTexture(Shader const& shader,
                                   unsigned int& frame_buffer,
                                   ToCreate to_create);

    
    //--------------------------------------------------------------------------
    /*
     *  @param shader:          The GLSL shader
     *  @param frame_buffer:    The frame buffer the texture will be rendered to
     *  @param texture:         the texture storing the data
     *  @param to_create:       To know if a bump map or a colour texture has to
     *                          be created
     */
    //--------------------------------------------------------------------------
    virtual void generate3DTexture(Shader const& shader,
                                   unsigned int& frame_buffer,
                                   unsigned int& texture, ToCreate to_create);
    

    //--------------------------------------------------------------------------
    /*
     *  @param shader_id: The GLSL shader
     */
    //--------------------------------------------------------------------------
    virtual void defineBumpMapShaderInput(int shader_id);
    

    //--------------------------------------------------------------------------
    /*
     *  @param shader_id: The GLSL shader
     */
    //-------------------------------------------------------------------------
    virtual void defineColourTextureShaderInput(int shader_id) = 0;

    
    //--------------------------------------------------------------------------
    /*
    *   @param aTexture: the texture to be generated
    *   @param aFrameBuffer: the framebuffer
    */
    //-------------------------------------------------------------------------
    virtual void initialize2DBuffer(unsigned int& aTexture,
                                    unsigned int& aFrameBuffer);

    
    //--------------------------------------------------------------------------
    /*
     *  @param aTexture:        the texture to be generated
     *  @param aFrameBuffer:    the framebuffer
     */
    //-------------------------------------------------------------------------
    virtual void initialize3DBuffer(unsigned int& aTexture,
                                    unsigned int& aFrameBuffer,
                                    bool has_colours);

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void load2DBumpShader();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void load3DBumpShader();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void initialize2DTextureCoordinates();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void initialize3DTextureCoordinates();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void shareNormalVectors();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void deleteIndices();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void initGradientTab();

    
    //--------------------------------------------------------------------------
    //--------------------------------------------------------------------------
    virtual void initPermutation();

    
    // Gradient tab for gnoise
    std::vector<VEC3> m_gradient_tab;

    
    // Permutation tab for noises
    std::vector<int> m_permutation;

    
    // Coordinates for texture sampling in 2D
    std::vector<VEC2> m_texture_coordinates_2d;

    
    // Coordinates for texture sampling in 3D
    std::vector<VEC3> m_texture_coordinates_3d;

    
    // Direction of the margin to add between triangles in the 2D texture
    std::vector<VEC2> m_margin_direction;

    
    // Buffers for the bump map
    unsigned int m_bump_map_texture;
    
    
    unsigned int m_bump_map_frame_buffer;

    
    // GLSL shader to create the bump map
    Shader m_bump_map_shader;

    
    // To know if the internal organ is a muscle with a tendon for texturing and
    // bump mapping, 0 by default
    int m_has_tendon;

    
    // To know if the internal organ is a lung with two colors and a line
    // for texturing and bump mapping, 0 by default
    int m_is_lung;

    
    // To know if the internal organ has thin bumps for bump mapping,
    // 0 by default
    int m_has_thin_bumps;

    
    int m_use_3D_bump_map;

    
    // Size of the side of the buffer in 2D
    unsigned int m_texture_size_2d;
    
    
    // Size of the side of the buffer in 3D
    unsigned int m_texture_size_3d;

    
    // To know if the textured has been initialized
    bool m_need_initialize;

    
    // To know if the generation texture coordinates has been set
    bool m_generation_texture_coord_are_set;

    
    // To know if the texture coordinates need to be optimized
    bool m_optimize_texture_coordinates;
};

    
} // namespace gVirtualXRay


#endif // INTERNALORGANMESH_H