Loading...
Searching...
No Matches
MeshViewerWidgetT_impl.hh
/* ========================================================================= *
* *
* OpenMesh *
* Copyright (c) 2001-2025, RWTH-Aachen University *
* Department of Computer Graphics and Multimedia *
* All rights reserved. *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenMesh. *
*---------------------------------------------------------------------------*
* *
* 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 copyright holder 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. *
* *
* ========================================================================= */
#pragma once
//== INCLUDES =================================================================
#ifdef _MSC_VER
//# pragma warning(disable: 4267 4311)
#endif
//
#include <iostream>
#include <fstream>
// --------------------
#include <QImage>
#include <QFileInfo>
#include <QKeyEvent>
// --------------------
#include <OpenMesh/Core/Utils/vector_cast.hh>
#include <OpenMesh/Tools/Utils/Timer.hh>
#include <OpenMesh/Apps/QtViewer/MeshViewerWidgetT.hh>
using namespace OpenMesh;
using namespace Qt;
#if defined(_MSC_VER)
# undef min
# undef max
#endif
//== IMPLEMENTATION ==========================================================
template <typename M>
bool
MeshViewerWidgetT<M>::open_mesh(const char* _filename, IO::Options _opt)
{
// load mesh
// calculate normals
// set scene center and radius
mesh_.request_face_normals();
mesh_.request_face_colors();
mesh_.request_vertex_normals();
mesh_.request_vertex_colors();
mesh_.request_vertex_texcoords2D();
std::cout << "Loading from file '" << _filename << "'\n";
if ( IO::read_mesh(mesh_, _filename, _opt ))
{
// store read option
opt_ = _opt;
// update face and vertex normals
if ( ! opt_.check( IO::Options::FaceNormal ) )
mesh_.update_face_normals();
else
std::cout << "File provides face normals\n";
if ( ! opt_.check( IO::Options::VertexNormal ) )
mesh_.update_vertex_normals();
else
std::cout << "File provides vertex normals\n";
// check for possible color information
if ( opt_.check( IO::Options::VertexColor ) )
{
std::cout << "File provides vertex colors\n";
add_draw_mode("Colored Vertices");
}
else
mesh_.release_vertex_colors();
if ( _opt.check( IO::Options::FaceColor ) )
{
std::cout << "File provides face colors\n";
add_draw_mode("Solid Colored Faces");
add_draw_mode("Smooth Colored Faces");
}
else
mesh_.release_face_colors();
if ( _opt.check( IO::Options::VertexTexCoord ) )
std::cout << "File provides texture coordinates\n";
// bounding box
typename Mesh::ConstVertexIter vIt(mesh_.vertices_begin());
typename Mesh::ConstVertexIter vEnd(mesh_.vertices_end());
using OpenMesh::Vec3f;
Vec3f bbMin, bbMax;
bbMin = bbMax = OpenMesh::vector_cast<Vec3f>(mesh_.point(*vIt));
for (size_t count=0; vIt!=vEnd; ++vIt, ++count)
{
bbMin.minimize( OpenMesh::vector_cast<Vec3f>(mesh_.point(*vIt)));
bbMax.maximize( OpenMesh::vector_cast<Vec3f>(mesh_.point(*vIt)));
}
// set center and radius
set_scene_pos( (bbMin+bbMax)*0.5f, (bbMin-bbMax).norm()*0.5f );
// for normal display
normal_scale_ = (bbMax-bbMin).min()*0.05f;
// info
std::clog << mesh_.n_vertices() << " vertices, "
<< mesh_.n_edges() << " edge, "
<< mesh_.n_faces() << " faces\n";
// base point for displaying face normals
{
OpenMesh::Utils::Timer t;
t.start();
mesh_.add_property( fp_normal_base_ );
typename M::FaceIter f_it = mesh_.faces_begin();
typename M::FaceVertexIter fv_it;
for (;f_it != mesh_.faces_end(); ++f_it)
{
typename Mesh::Point v(0,0,0);
for( fv_it=mesh_.fv_iter(*f_it); fv_it.is_valid(); ++fv_it)
v += OpenMesh::vector_cast<typename Mesh::Normal>(mesh_.point(*fv_it));
v *= 1.0f/3.0f;
mesh_.property( fp_normal_base_, *f_it ) = v;
}
t.stop();
std::clog << "Computed base point for displaying face normals ["
<< t.as_string() << "]" << std::endl;
}
//
{
std::clog << "Computing strips.." << std::flush;
OpenMesh::Utils::Timer t;
t.start();
compute_strips();
t.stop();
std::clog << "done [" << strips_.n_strips()
<< " strips created in " << t.as_string() << "]\n";
}
//
#if defined(WIN32)
updateGL();
#endif
if ( this->parentWidget() != nullptr )
this->parentWidget()->setWindowTitle(QFileInfo(_filename).fileName());
else
setWindowTitle(QFileInfo(_filename).fileName());
// loading done
return true;
}
return false;
}
//-----------------------------------------------------------------------------
template <typename M>
bool MeshViewerWidgetT<M>::open_texture( const char *_filename )
{
QImage texsrc;
QString fname = _filename;
if (texsrc.load( fname ))
{
return set_texture( texsrc );
}
return false;
}
//-----------------------------------------------------------------------------
template <typename M>
bool MeshViewerWidgetT<M>::set_texture( QImage& _texsrc )
{
if ( !opt_.vertex_has_texcoord() )
return false;
{
// adjust texture size: 2^k * 2^l
int tex_w, w( _texsrc.width() );
int tex_h, h( _texsrc.height() );
for (tex_w=1; tex_w <= w; tex_w <<= 1) {};
for (tex_h=1; tex_h <= h; tex_h <<= 1) {};
tex_w >>= 1;
tex_h >>= 1;
_texsrc = _texsrc.scaled( tex_w, tex_h, Qt::IgnoreAspectRatio, Qt::SmoothTransformation );
}
QImage texture = _texsrc.convertToFormat(QImage::Format_ARGB32).rgbSwapped();
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_SKIP_ROWS, 0);
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ROW_LENGTH, 0);
glPixelStorei(GL_PACK_SKIP_ROWS, 0);
glPixelStorei(GL_PACK_SKIP_PIXELS, 0);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
if ( tex_id_ > 0 )
{
glDeleteTextures(1, &tex_id_);
}
glGenTextures(1, &tex_id_);
glBindTexture(GL_TEXTURE_2D, tex_id_);
// glTexGenfv( GL_S, GL_SPHERE_MAP, 0 );
// glTexGenfv( GL_T, GL_SPHERE_MAP, 0 );
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, // target
0, // level
GL_RGBA, // internal format
texture.width(), // width (2^n)
texture.height(), // height (2^m)
0, // border
GL_RGBA, // format
GL_UNSIGNED_BYTE, // type
texture.bits() ); // pointer to pixels
std::cout << "Texture loaded\n";
return true;
}
//-----------------------------------------------------------------------------
template <typename M>
void
MeshViewerWidgetT<M>::draw_openmesh(const std::string& _draw_mode)
{
typename Mesh::ConstFaceIter fIt(mesh_.faces_begin()),
fEnd(mesh_.faces_end());
typename Mesh::ConstFaceVertexIter fvIt;
#if defined(OM_USE_OSG) && OM_USE_OSG
if (_draw_mode == "OpenSG Indices") // --------------------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
if ( tex_id_ && mesh_.has_vertex_texcoords2D() )
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh_.texcoords2D());
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex_id_);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, tex_mode_);
}
glDrawElements(GL_TRIANGLES,
mesh_.osg_indices()->size(),
GL_UNSIGNED_INT,
&mesh_.osg_indices()->getField()[0] );
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
else
#endif
if (_draw_mode == "Wireframe") // -------------------------------------------
{
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
fvIt = mesh_.cfv_iter(*fIt);
glVertex3fv( &mesh_.point(*fvIt)[0] );
++fvIt;
glVertex3fv( &mesh_.point(*fvIt)[0] );
++fvIt;
glVertex3fv( &mesh_.point(*fvIt)[0] );
}
glEnd();
}
else if (_draw_mode == "Solid Flat") // -------------------------------------
{
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
glNormal3fv( &mesh_.normal(*fIt)[0] );
fvIt = mesh_.cfv_iter(*fIt);
glVertex3fv( &mesh_.point(*fvIt)[0] );
++fvIt;
glVertex3fv( &mesh_.point(*fvIt)[0] );
++fvIt;
glVertex3fv( &mesh_.point(*fvIt)[0] );
}
glEnd();
}
else if (_draw_mode == "Solid Smooth") // -----------------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
if ( tex_id_ && mesh_.has_vertex_texcoords2D() )
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh_.texcoords2D());
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex_id_);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, tex_mode_);
}
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
fvIt = mesh_.cfv_iter(*fIt);
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
}
glEnd();
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
if ( tex_id_ && mesh_.has_vertex_texcoords2D() )
{
glDisable(GL_TEXTURE_2D);
}
}
else if (_draw_mode == "Colored Vertices") // --------------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
if ( mesh_.has_vertex_colors() )
{
glEnableClientState( GL_COLOR_ARRAY );
glColorPointer(3, GL_UNSIGNED_BYTE, 0,mesh_.vertex_colors());
}
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
fvIt = mesh_.cfv_iter(*fIt);
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
}
glEnd();
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
else if (_draw_mode == "Solid Colored Faces") // -----------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
glColor( *fIt );
fvIt = mesh_.cfv_iter(*fIt);
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
}
glEnd();
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
else if (_draw_mode == "Smooth Colored Faces") // ---------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
glBegin(GL_TRIANGLES);
for (; fIt!=fEnd; ++fIt)
{
glMaterial( *fIt );
fvIt = mesh_.cfv_iter(*fIt);
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
++fvIt;
glArrayElement(fvIt->idx());
}
glEnd();
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
}
else if ( _draw_mode == "Strips'n VertexArrays" ) // ------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, 0, mesh_.vertex_normals());
if ( tex_id_ && mesh_.has_vertex_texcoords2D() )
{
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, 0, mesh_.texcoords2D());
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, tex_id_);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, tex_mode_);
}
typename MyStripifier::StripsIterator strip_it = strips_.begin();
typename MyStripifier::StripsIterator strip_last = strips_.end();
// Draw all strips
for (; strip_it!=strip_last; ++strip_it)
{
glDrawElements(GL_TRIANGLE_STRIP,
static_cast<GLsizei>(strip_it->size()), GL_UNSIGNED_INT, &(*strip_it)[0] );
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
else if (_draw_mode == "Show Strips" && strips_.is_valid() ) // -------------
{
typename MyStripifier::StripsIterator strip_it = strips_.begin();
typename MyStripifier::StripsIterator strip_last = strips_.end();
float cmax = 256.0f;
int range = 220;
int base = (int)cmax-range;
int drcol = 13;
int dgcol = 31;
int dbcol = 17;
int rcol=0, gcol=dgcol, bcol=dbcol+dbcol;
// Draw all strips
for (; strip_it!=strip_last; ++strip_it)
{
typename MyStripifier::IndexIterator idx_it = strip_it->begin();
typename MyStripifier::IndexIterator idx_last = strip_it->end();
rcol = (rcol+drcol) % range;
gcol = (gcol+dgcol) % range;
bcol = (bcol+dbcol) % range;
glBegin(GL_TRIANGLE_STRIP);
glColor3f((rcol+base)/cmax, (gcol+base)/cmax, (bcol+base)/cmax);
for ( ;idx_it != idx_last; ++idx_it )
glVertex3fv(&mesh_.point( OM_TYPENAME Mesh::VertexHandle(*idx_it))[0]);
glEnd();
}
glColor3f(1.0, 1.0, 1.0);
}
else if( _draw_mode == "Points" ) // -----------------------------------------
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, 0, mesh_.points());
if (mesh_.has_vertex_colors() && use_color_)
{
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, mesh_.vertex_colors());
}
glDrawArrays( GL_POINTS, 0, static_cast<GLsizei>(mesh_.n_vertices()) );
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
}
//-----------------------------------------------------------------------------
template <typename M>
void
MeshViewerWidgetT<M>::draw_scene(const std::string& _draw_mode)
{
if ( ! mesh_.n_vertices() )
return;
#if defined(OM_USE_OSG) && OM_USE_OSG
else if ( _draw_mode == "OpenSG Indices")
{
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
draw_openmesh( _draw_mode );
}
else
#endif
if ( _draw_mode == "Points" )
{
glDisable(GL_LIGHTING);
draw_openmesh(_draw_mode);
}
else if (_draw_mode == "Wireframe")
{
glDisable(GL_LIGHTING);
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
draw_openmesh(_draw_mode);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else if ( _draw_mode == "Hidden-Line" )
{
glDisable(GL_LIGHTING);
glShadeModel(GL_FLAT);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glColor4f( 0.0f, 0.0f, 0.0f, 1.0f );
glDepthRange(0.01, 1.0);
draw_openmesh( "Wireframe" );
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glDepthRange( 0.0, 1.0 );
draw_openmesh( "Wireframe" );
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
}
else if (_draw_mode == "Solid Flat")
{
glEnable(GL_LIGHTING);
glShadeModel(GL_FLAT);
draw_openmesh(_draw_mode);
}
else if (_draw_mode == "Solid Smooth" ||
_draw_mode == "Strips'n VertexArrays" )
{
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
draw_openmesh(_draw_mode);
}
else if (_draw_mode == "Show Strips")
{
glDisable(GL_LIGHTING);
draw_openmesh(_draw_mode);
}
else if (_draw_mode == "Colored Vertices" )
{
glDisable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
draw_openmesh(_draw_mode);
}
else if (_draw_mode == "Solid Colored Faces")
{
glDisable(GL_LIGHTING);
glShadeModel(GL_FLAT);
draw_openmesh(_draw_mode);
setDefaultMaterial();
}
else if (_draw_mode == "Smooth Colored Faces" )
{
glEnable(GL_LIGHTING);
glShadeModel(GL_SMOOTH);
draw_openmesh(_draw_mode);
setDefaultMaterial();
}
if (show_vnormals_)
{
typename Mesh::VertexIter vit;
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
glColor3f(1.000f, 0.803f, 0.027f); // orange
for(vit=mesh_.vertices_begin(); vit!=mesh_.vertices_end(); ++vit)
{
glVertex( *vit );
glVertex( mesh_.point( *vit ) + normal_scale_*mesh_.normal( *vit ) );
}
glEnd();
}
if (show_fnormals_)
{
typename Mesh::FaceIter fit;
glDisable(GL_LIGHTING);
glBegin(GL_LINES);
glColor3f(0.705f, 0.976f, 0.270f); // greenish
for(fit=mesh_.faces_begin(); fit!=mesh_.faces_end(); ++fit)
{
glVertex( mesh_.property(fp_normal_base_, *fit) );
glVertex( mesh_.property(fp_normal_base_, *fit) +
normal_scale_*mesh_.normal( *fit ) );
}
glEnd();
}
}
//-----------------------------------------------------------------------------
template <typename M>
void
MeshViewerWidgetT<M>::enable_strips()
{
if (!f_strips_)
{
f_strips_ = true;
add_draw_mode("Strips'n VertexArrays");
add_draw_mode("Show Strips");
}
}
//-----------------------------------------------------------------------------
template <typename M>
void
MeshViewerWidgetT<M>::disable_strips()
{
if (f_strips_)
{
f_strips_ = false;
del_draw_mode("Show Strips");
del_draw_mode("Strip'n VertexArrays");
}
}
//-----------------------------------------------------------------------------
#define TEXMODE( Mode ) \
tex_mode_ = Mode; std::cout << "Texture mode set to " << #Mode << std::endl
template <typename M>
void
MeshViewerWidgetT<M>::keyPressEvent( QKeyEvent* _event)
{
switch( _event->key() )
{
case Key_D:
if ( mesh_.has_vertex_colors() && (current_draw_mode()=="Points") )
{
use_color_ = !use_color_;
std::cout << "use color: " << (use_color_?"yes\n":"no\n");
if (!use_color_)
glColor3f(1.0f, 1.0f, 1.0f);
updateGL();
}
break;
case Key_N:
if ( _event->modifiers() & ShiftModifier )
{
show_fnormals_ = !show_fnormals_;
std::cout << "show face normals: " << (show_fnormals_?"yes\n":"no\n");
}
else
{
show_vnormals_ = !show_vnormals_;
std::cout << "show vertex normals: " << (show_vnormals_?"yes\n":"no\n");
}
updateGL();
break;
case Key_I:
std::cout << "\n# Vertices : " << mesh_.n_vertices() << std::endl;
std::cout << "# Edges : " << mesh_.n_edges() << std::endl;
std::cout << "# Faces : " << mesh_.n_faces() << std::endl;
std::cout << "binary input : " << opt_.check(opt_.Binary) << std::endl;
std::cout << "swapped input : " << opt_.check(opt_.Swap) << std::endl;
std::cout << "vertex normal : "
<< opt_.check(opt_.VertexNormal) << std::endl;
std::cout << "vertex texcoord: "
<< opt_.check(opt_.VertexTexCoord) << std::endl;
std::cout << "vertex color : "
<< opt_.check(opt_.VertexColor) << std::endl;
std::cout << "face normal : "
<< opt_.check(opt_.FaceNormal) << std::endl;
std::cout << "face color : "
<< opt_.check(opt_.FaceColor) << std::endl;
this->QGLViewerWidget::keyPressEvent( _event );
break;
case Key_T:
switch( tex_mode_ )
{
case GL_MODULATE: TEXMODE(GL_DECAL); break;
case GL_DECAL: TEXMODE(GL_BLEND); break;
case GL_BLEND: TEXMODE(GL_REPLACE); break;
case GL_REPLACE: TEXMODE(GL_MODULATE); break;
}
updateGL();
break;
default:
this->QGLViewerWidget::keyPressEvent( _event );
}
}
#undef TEXMODE
//=============================================================================
Timer.hh
A timer class.
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition MeshItems.hh:59
OpenMesh::vector_cast
void vector_cast(const src_t &_src, dst_t &_dst, GenProg::Int2Type< n >)
Cast vector type to another vector type by copying the vector elements.
Definition vector_cast.hh:81
OpenMesh::Vec3f
VectorT< float, 3 > Vec3f
3-float vector
Definition Vector11T.hh:851
OpenMesh::IO::read_mesh
bool read_mesh(Mesh &_mesh, const std::string &_filename)
Read a mesh from file _filename.
Definition MeshIO.hh:95
MeshViewerWidgetT::open_texture
virtual bool open_texture(const char *_filename)
load texture
Definition MeshViewerWidgetT_impl.hh:206
MeshViewerWidgetT::open_mesh
virtual bool open_mesh(const char *_filename, OpenMesh::IO::Options _opt)
open mesh
Definition MeshViewerWidgetT_impl.hh:75
MeshViewerWidgetT::draw_scene
virtual void draw_scene(const std::string &_draw_mode) override
inherited drawing method
Definition MeshViewerWidgetT_impl.hh:572
MeshViewerWidgetT::draw_openmesh
virtual void draw_openmesh(const std::string &_drawmode)
draw the mesh
Definition MeshViewerWidgetT_impl.hh:284
QGLViewerWidget::add_draw_mode
QAction * add_draw_mode(const std::string &_s)
add draw mode to popup menu, and return the QAction created
Definition QGLViewerWidget.cc:650
OpenMesh::VectorT::min
VectorT< Scalar, DIM > min(const VectorT< Scalar, DIM > &_v1, const VectorT< Scalar, DIM > &_v2)
non-member min
Definition Vector11T.hh:797
OpenMesh::VectorT::maximize
vector_type & maximize(const vector_type &_rhs)
maximize values: same as *this = max(*this, _rhs), but faster
Definition Vector11T.hh:588
OpenMesh::VectorT::minimize
vector_type & minimize(const vector_type &_rhs)
minimize values: same as *this = min(*this, _rhs), but faster
Definition Vector11T.hh:560
OpenMesh::VectorT::norm
Scalar norm(const VectorT< Scalar, DIM > &_v)
non-member norm
Definition Vector11T.hh:749
OpenMesh::IO::Options
Set options for reader/writer modules.
Definition Options.hh:92
OpenMesh::IO::Options::FaceNormal
@ FaceNormal
Has (r) / store (w) face normals.
Definition Options.hh:109
OpenMesh::IO::Options::FaceColor
@ FaceColor
Has (r) / store (w) face colors.
Definition Options.hh:110
OpenMesh::IO::Options::VertexNormal
@ VertexNormal
Has (r) / store (w) vertex normals.
Definition Options.hh:105
OpenMesh::IO::Options::VertexTexCoord
@ VertexTexCoord
Has (r) / store (w) texture coordinates.
Definition Options.hh:107
OpenMesh::IO::Options::VertexColor
@ VertexColor
Has (r) / store (w) vertex colors.
Definition Options.hh:106
OpenMesh::PolyMeshT< AttribKernel >::ConstFaceIter
AttribKernel::ConstFaceIter ConstFaceIter
Definition PolyMeshT.hh:151
OpenMesh::PolyMeshT< AttribKernel >::VertexHandle
AttribKernel::VertexHandle VertexHandle
Definition PolyMeshT.hh:136
OpenMesh::PolyMeshT< AttribKernel >::ConstFaceVertexIter
AttribKernel::ConstFaceVertexIter ConstFaceVertexIter
Definition PolyMeshT.hh:177
OpenMesh::PolyMeshT< AttribKernel >::FaceIter
AttribKernel::FaceIter FaceIter
Definition PolyMeshT.hh:146
OpenMesh::PolyMeshT< AttribKernel >::ConstVertexIter
AttribKernel::ConstVertexIter ConstVertexIter
Definition PolyMeshT.hh:148
OpenMesh::PolyMeshT< AttribKernel >::Point
AttribKernel::Point Point
Definition PolyMeshT.hh:112
OpenMesh::PolyMeshT< AttribKernel >::VertexIter
AttribKernel::VertexIter VertexIter
Definition PolyMeshT.hh:143
OpenMesh::Utils::Timer
Timer class.
Definition Timer.hh:83
OpenMesh::Utils::Timer::stop
void stop(void)
Stop measurement.
OpenMesh::Utils::Timer::as_string
std::string as_string(Format format=Automatic)
Returns the measured time as a string.
OpenMesh::Utils::Timer::start
void start(void)
Start measurement.