MeshTopo.h

Go to the documentation of this file.

/****************************************************************************
 *
 * Copyright (c) 2019-2020 Pointwise, Inc.
 * All rights reserved.
 *
 * This sample Pointwise source code is not supported by Pointwise, Inc.
 * It is provided freely for demonstration purposes only.
 * SEE THE WARRANTY DISCLAIMER AT THE BOTTOM OF THIS FILE.
 *
 ***************************************************************************/

#ifndef MESH_TOPO_CLASS
#define MESH_TOPO_CLASS

#include "Types.h"

#include <algorithm>
#include <map>
#include <string>
#include <vector>

#define MESH_TOPO_INVALID_REF -101
#define MESH_TOPO_INDEX_UNUSED -101

/****************************************************************************
 *
 * pwiFnvHash class
 *
 * A simple hashing routine used to uniquely identify mesh topology entities.
 * Fowler-Noll-Vo Hash Function
 * Designed to be fast with decent dispersion.
 * https://en.wikipedia.org/wiki/Fowler%E2%80%93Noll%E2%80%93Vo_hash_function
 *
 ***************************************************************************/
class pwiFnvHash {
public:
    typedef MLUINT FNVHash;

    static FNVHash hashInit();

    static FNVHash hash(MLINT data, FNVHash hash);

private:
    const static FNVHash   fnv_init_;
    const static FNVHash   fnv_prime_;
    const static FNVHash   fnv_num_octets_;
};


#define FNV1_32_INIT ((pwiFnvHash::FNVHash)0x811c9dc5)
#define FNV1_64_INIT ((pwiFnvHash::FNVHash)0xcbf29ce484222325ULL)
#define FNV1_32_PRIME ((pwiFnvHash::FNVHash)0x01000193)
#define FNV1_64_PRIME ((pwiFnvHash::FNVHash)0x100000001b3ULL)


/****************************************************************************
 * ParamVertex class
 ***************************************************************************/
class ParamVertex {
public:
    ParamVertex() :
        gref_(MESH_TOPO_INVALID_REF),
        mid_(MESH_TOPO_INVALID_REF),
        u_(0.0),
        v_(0.0) {}

    ParamVertex(const std::string & vref, MLINT gref, MLINT mid, MLREAL u, MLREAL v) :
        vref_(vref),
        gref_(gref),
        mid_(mid),
        u_(u),
        v_(v) {}

    const std::string &getVref() const { return vref_; }
    MLINT getGref() const { return gref_; }
    MLINT getID() const { return mid_; }
    void  getUV(MLREAL *u, MLREAL *v) const { *u = u_; *v = v_; }
private:
    std::string vref_;  // required attr
    MLINT gref_;  // required attr
    MLINT mid_;   // optional attr
    MLREAL u_;
    MLREAL v_;
};

typedef std::map<std::string /*vref*/, ParamVertex *> ParamVertVrefMap;
typedef std::map<MLINT /*mid*/, std::string /*vref*/> ParamVertIDToVrefMap;

class MeshAssociativity;

/****************************************************************************
 * MeshTopo class
 ***************************************************************************/
class ML_STORAGE_CLASS MeshTopo {
public:
    friend class MeshAssociativity;

    MeshTopo(
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name );

    MeshTopo(
        const std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name );

    virtual MLINT getID() const;

    virtual MLINT getGref() const;

    virtual MLINT getAref() const;

    virtual void getName(const char **name) const;

    virtual const std::string & getName() const;

    virtual const std::string & getRef() const;

    virtual void addParamVertex(ParamVertex *pv, bool mapID);

    virtual ParamVertex * getParamVertByVref(const std::string & vref) const;

    virtual ParamVertex * getParamVertByID(MLINT id) const;

    virtual MLINT getNumParamVerts() const;

    void getParamVerts(std::vector<const ParamVertex *> &pv) const;

    virtual const ParamVertVrefMap & getParamVertVrefMap() const;

    virtual void setID( MLINT id );

    virtual void setGref( MLINT gref );

    virtual void setAref( MLINT aref );

    //
    virtual void setRef(const char *ref);

    void setName(const std::string &name);

    //
    void setName(const char *name);

    bool hasID() const;

    bool hasGref() const;

    bool hasAref() const;

    std::vector<MLINT> getAttributeIDs(const MeshAssociativity &meshAssoc) const;

    std::string getNextName();

    virtual const std::string &getBaseName() const;
    virtual MLUINT &getNameCounter();

    void setOrderCounter(MLUINT counter);

    MLUINT getOrderCounter() const ;

    static bool OrderCompare(const MeshTopo *topo1, const MeshTopo *topo2);

    MeshTopo();
    ~MeshTopo();
protected:
    std::string ref_;

    // MeshLink schema: MeshElementAttributes
    MLINT mid_;
    MLINT aref_;
    MLINT gref_;
    std::string name_;
    MLUINT orderCounter_;

    ParamVertVrefMap paramVertVrefMap_;
    ParamVertIDToVrefMap paramVertIDToVrefMap_;

private:
    static MLUINT nameCounter_;
};

typedef std::map<MLINT, std::string> MeshTopoIDToNameMap;

typedef std::vector<MeshTopo *> MeshTopoArray;

typedef std::map<std::string, std::string> MeshTopoRefToNameMap;



/****************************************************************************
 * MeshPoint class
 ***************************************************************************/
class MeshPoint : public MeshTopo {
public:
    friend class MeshAssociativity;
    friend class MeshModel;
    friend class MeshSheet;
    friend class MeshString;

    MeshPoint(MLINT i1,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1
    );

    MeshPoint(
        const std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1
    );

    ParamVertex * const getParamVert() const {
        return paramVert_;
    }

    MLINT getParamVerts(ParamVertex * const ** pvs) const {
        *pvs = &(paramVert_);
        return 1;
    }

    ~MeshPoint();

    virtual const std::string &getBaseName() const;
    virtual MLUINT &getNameCounter();

private:
    static MLUINT nameCounter_;

    MeshPoint():
        i1_(-1),
        paramVert_(NULL)
    {};

    static pwiFnvHash::FNVHash computeHash(MLINT i1);

    pwiFnvHash::FNVHash getHash() const;

    MLINT i1_;
    ParamVertex * paramVert_;
};

typedef std::map<std::string, MeshPoint *> MeshPointNameMap;


/****************************************************************************
 * MeshEdge class
 ***************************************************************************/
class MeshEdge : public MeshTopo {
public:
    friend class MeshAssociativity;
    friend class MeshModel;
    friend class MeshSheet;
    friend class MeshString;

    MeshEdge(MLINT i1, MLINT i2,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2);

    //
    MeshEdge(
        const std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2);

    ~MeshEdge();

    MeshEdge(const MeshEdge &other);

    MeshEdge & operator=(const MeshEdge &other);

    virtual const std::string &getBaseName() const;
    virtual MLUINT &getNameCounter();

    void getInds(MLINT *inds, MLINT *numInds) const;

    MLINT getParamVerts( ParamVertex * const ** pvs) const {
        *pvs = &(paramVerts_[0]);
        return getNumParamVerts();
    }

    void getParamVerts(std::vector<ParamVertex*> &pvs) const {
        pvs.clear();
        for (int i = 0; i < 2; ++i) {
            if (NULL != paramVerts_[i]) pvs.push_back(paramVerts_[i]);
        }
        return;
    }

    MLINT getNumParamVerts() const
    {
        MLINT count = 0;
        for (int i = 0; i < 2; ++i) {
            if (NULL != paramVerts_[i]) ++count;
        }
        return count;
    }

private:
    static MLUINT nameCounter_;

    MeshEdge():
        i1_(-1),
        i2_(-1)
    {
        paramVerts_[0] = paramVerts_[1] = NULL;
    };

    pwiFnvHash::FNVHash getHash() const;

    static pwiFnvHash::FNVHash computeHash(MLINT i1, MLINT i2);

    MLINT i1_;
    MLINT i2_;
    ParamVertex * paramVerts_[2];
};
typedef std::map<std::string, MeshEdge *> MeshEdgeNameMap;



/****************************************************************************
 * MeshFace class
 ***************************************************************************/
class MeshFace : public MeshTopo {
public:
    friend class MeshAssociativity;
    friend class MeshModel;
    friend class MeshSheet;
    friend class MeshString;

    MeshFace(MLINT i1, MLINT i2, MLINT i3,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3);

    //
    MeshFace(
        const std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3);

    MeshFace(MLINT i1, MLINT i2, MLINT i3, MLINT i4,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, ParamVertex *pv4);

    MeshFace(
        const std::string &ref,
        MLINT mid,
        MLINT aref,
        MLINT gref,
        const std::string &name,
        ParamVertex *pv1, ParamVertex *pv2,
        ParamVertex *pv3, ParamVertex *pv4);

    ~MeshFace();

    virtual const std::string &getBaseName() const;
    virtual MLUINT &getNameCounter();

    void getInds(MLINT *inds, MLINT *numInds) const;

    MLINT getParamVerts(ParamVertex * const ** pvs) const {
        *pvs = &(paramVerts_[0]);
        return getNumParamVerts();
    }

    void getParamVerts(std::vector<ParamVertex*> &pvs) const {
        pvs.clear();
        for (int i = 0; i < 4; ++i) {
            if (NULL != paramVerts_[i]) pvs.push_back(paramVerts_[i]);
        }
        return;
    }

    MLINT getNumParamVerts() const
    {
        MLINT count = 0;
        for (int i = 0; i < 4; ++i) {
            if (NULL != paramVerts_[i]) ++count;
        }
        return count;
    }

private:
    static MLUINT nameCounter_;

    MeshFace():
        i1_(-1),
        i2_(-1),
        i3_(-1),
        i4_(-1)
    {
        paramVerts_[0] = paramVerts_[1] = paramVerts_[2] = paramVerts_[3] = NULL;
    };

    pwiFnvHash::FNVHash getHash() const;

    static pwiFnvHash::FNVHash computeHash(MLINT i1, MLINT i2, MLINT i3,
        MLINT i4 = MESH_TOPO_INDEX_UNUSED);

    MLINT i1_;
    MLINT i2_;
    MLINT i3_;
    MLINT i4_;
    ParamVertex * paramVerts_[4];
};

typedef std::map<std::string, MeshFace *> MeshFaceNameMap;

#endif

/****************************************************************************
 *
 * DISCLAIMER:
 * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, POINTWISE DISCLAIMS
 * ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED
 * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE, WITH REGARD TO THIS SCRIPT. TO THE MAXIMUM EXTENT PERMITTED
 * BY APPLICABLE LAW, IN NO EVENT SHALL POINTWISE BE LIABLE TO ANY PARTY
 * FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
 * WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF
 * BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) ARISING OUT OF THE
 * USE OF OR INABILITY TO USE THIS SCRIPT EVEN IF POINTWISE HAS BEEN
 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGES AND REGARDLESS OF THE
 * FAULT OR NEGLIGENCE OF POINTWISE.
 *
 ***************************************************************************/