1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 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
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/* *****************************************************************
    MESQUITE -- The Mesh Quality Improvement Toolkit

    Copyright 2004 Sandia Corporation and Argonne National
    Laboratory.  Under the terms of Contract DE-AC04-94AL85000
    with Sandia Corporation, the U.S. Government retains certain
    rights in this software.

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    (lgpl.txt) along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    [email protected], [email protected], [email protected],
    [email protected], [email protected], [email protected]

  ***************************************************************** */

/*! \file MsqVertex.hpp
  \brief Mesquite's vertex object.

  \author Darryl Melander
  \author Thomas Leurent
*/
#ifndef MSQVERTEX_HPP
#define MSQVERTEX_HPP

#include "Mesquite.hpp"
#include "Vector3D.hpp"

namespace MBMesquite
{
/*!
  \class MsqVertex
  \brief MsqVertex is the Mesquite object that stores information about
  the vertices in the mesh.

  This class has no virtual destructor for performance reasons.
  !!! Make sure NOT to delete a MsqVertex object from a pointer
      to Vector3D !!!
*/
class MESQUITE_EXPORT MsqVertex : public Vector3D
{
  public:
    //! Construct vertex using three doubles.
    MsqVertex( double p_x, double p_y, double p_z ) : Vector3D( p_x, p_y, p_z ), vertexBitFlags( 0 ) {}

    //! Construct vertex using Vector3D.
    MsqVertex( const Vector3D& vec ) : Vector3D( vec ), vertexBitFlags( 0 ) {}

    //! Construct default vertex with coordinates (0.0,0.0,0.0)
    MsqVertex() : Vector3D( 0, 0, 0 ), vertexBitFlags( 0 ) {}

    //! Construct default vertex with coordinates (0.0,0.0,0.0)
    MsqVertex( const MsqVertex& rhs ) : Vector3D( rhs ), vertexBitFlags( rhs.vertexBitFlags ) {}

    //! Initializes with coordinates. Sets tag data/pointer to 0.
    MsqVertex& operator=( const Vector3D& rhs )
    {
        Vector3D::operator=( rhs );
        return *this;
    }

    // This allows for 8 flag bits.
    // I don't think we'll want more than that (yet).
    typedef unsigned char FlagMask;

    //! \enum FlagMaskID
    //!   Those are the available flags... currently only return
    //!   is_free.
    //!   Developers: The values used in that enum are used by a bitset,
    //!               so they have to be 2-based (2,4,8,16,32, ...)
    enum FlagMaskID
    {
        MSQ_HARD_FIXED  = 1 << 0,  //!< vertex is always fixed. This can only be set on and never off.
        MSQ_DEPENDENT   = 1 << 1,  //!< higher-order node w/ position determined by mapping function
        MSQ_CULLED      = 1 << 2,  //!< vertex is fixed. This flag can be set on and off.
        MSQ_PATCH_FIXED = 1 << 3,  //!< vertex is fixed only because it is on patch boundary (not by app request)
        MSQ_MARK        = 1 << 4,  //!< arbitrary mark for use by code - clear before using
        MSQ_FIXED       = ( MSQ_HARD_FIXED | MSQ_CULLED | MSQ_PATCH_FIXED )
    };
    //! Returns true if vertex is ``free''.
    bool is_free_vertex() const
    {
        return ( vertexBitFlags & ( MSQ_HARD_FIXED | MSQ_PATCH_FIXED ) ) == 0;
    }

    void set_soft_fixed_flag()
    {
        vertexBitFlags |= MSQ_CULLED;
    }

    void remove_soft_fixed_flag()
    {
        vertexBitFlags &= ( ~MSQ_CULLED );
    }

    void set_hard_fixed_flag()
    {
        vertexBitFlags |= MSQ_HARD_FIXED;
    }

    void set_vertex_flag( FlagMaskID flag )
    {
        vertexBitFlags |= flag;
    }

    void remove_vertex_flag( FlagMaskID flag )
    {
        vertexBitFlags &= ( ~flag );
    }

    bool is_flag_set( FlagMaskID flag ) const
    {
        return ( vertexBitFlags & flag ) != 0;
    }

    FlagMask get_flags() const
    {
        return vertexBitFlags;
    }

    FlagMask& flags()
    {
        return vertexBitFlags;
    }

    void set_flags( FlagMask p_flags )
    {
        vertexBitFlags = p_flags;
    }

  private:
    FlagMask vertexBitFlags;
};

}  // namespace MBMesquite

#endif  // MsqVertex_hpp