GD/GD_Face.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *
 */

#ifndef __GD_Face_H__
#define __GD_Face_H__

#include "GD_API.h"
#include <UT/UT_Vector2.h>
#include <UT/UT_RefArray.h>
#include "GD_Vertex.h"
#include "GD_Primitive.h"

class   GD_Detail;
class   GD_TrimLoop;
class   GD_TrimHitInfo;
class UT_Vector3Array;

class GD_API GD_FaceFlags {
public:
        GD_FaceFlags()  { closed = 0; }
        unsigned          closed:1;
};

#define GD_FOR_FACE_VERTICES(face, vtx, cnt) \
        for (cnt=0; (cnt < face->getVertexCount()) && \
                    (vtx = &((*face)(cnt))); cnt++)

class GD_API GD_Face : public GD_Primitive
{
public:
    GD_Face(GD_Detail *d);
    virtual ~GD_Face();

    virtual int         getBBox(UT_BoundingBox  *bbox) const;
    virtual void        addToBSphere(UT_BoundingSphere  *bsphere) const;
    virtual void        getBRect(UT_BoundingRect *brect) const;
    virtual UT_Vector3  computeNormal() const;
    virtual UT_Vector3  baryCenter() const;

    virtual int         save(ostream &os, int binary) const;
    virtual bool        load(UT_IStream &is);

    virtual GD_Primitive *copy(int preserve_shared_pts = 0) const;
    virtual int           copy(const GD_Primitive &src, int ptoffset);

    // Evaluate one point (when du=0), or the du-th derivative.
    // Return 0 if successful, and -1 otherwise.
    virtual int         evaluate(float u, UT_Vector3 &pos,
                                 unsigned du=0, int uOffset=-1) const = 0;

    virtual void        addPointRefToGroup(GB_PointGroup &grp) const;
    virtual void        changePointRef(GB_Element *from, GB_Element *to);

    virtual int         isDegenerate() const;

    virtual unsigned    getOrder(void) const = 0;

    // Adjust the size of the vertex array.
    void                 setSize(unsigned int sz);

    // Delete the vertex that uses the point.
    virtual int         detachPoint  (GB_Element *ppt, int allVertices=1);
    virtual int         ifDetachPoint(GB_Element *ppt) const;

    // Take the whole set of points into consideration when applying the
    // point removal operation to this primitive. The method returns 0 if
    // successful, -1 if it failed because it would have become degenerate,
    // and -2 if it failed because it would have had to remove the primitive
    // altogether.
    virtual int          detachPoints (GB_PointGroup &grp);

//  Remove all repeated vertices - (only gets consecutive vertices)
    virtual int          removeRepeatedVertices(int check_order = 0);

    // Insert or delete vertices. The insertion methods return the index if
    // successful and -1 otherwise. The deletion methods return 0 if ok and
    // -1 otherwise.
    virtual int         insertVertex(GD_Point  *ppt, unsigned int where=0);
    virtual int         appendVertex(GD_Point  *ppt);
    virtual int         deleteVertex(GD_Vertex &vtx);
    virtual int         deleteVertex(unsigned int num);

    // Query the number of vertices in the array. This number may be smaller
    // than the actual size of the array.
    virtual unsigned    getVertexCount() const;

    // Both methods find the index of the given vertex (vtx or the vertex
    // that contains ppt). Return -1 if not found. 
    int         find(const GD_Vertex &vtx) const { return myVtxList.find(vtx);}
    int         find(const GD_Point  &ppt) const;

    // Subscript operators. The () operator does not check the boundaries.
    const GD_Vertex     &operator()(unsigned i) const { return myVtxList(i); }
    GD_Vertex           &operator()(unsigned i)       { return myVtxList(i); }
    const GD_Vertex     &operator[](unsigned i) const 
                        {
                            return (i < myVtxList.entries()) ? myVtxList(i)
                                                             : myVtxList(0);
                        }
    GD_Vertex           &operator[](unsigned i)  
                        {
                            return (i < myVtxList.entries()) ? myVtxList(i) 
                                                             : myVtxList(0);
                        }
    const GD_Vertex     &getVertex(unsigned i) const;
    GD_Vertex           &getVertex(unsigned i);
    void                 setVertex(unsigned int i, GD_Point *pt)
                         {
                            if (i < myVtxList.entries())
                                myVtxList(i).setPt(pt);
                         }

    unsigned             isClosed() const { return myFlags.closed; }
    virtual void         close(int rounded = 1, int preserveShape = 0);
    virtual void         open(int preserveShape = 0, int safe = 0);

    int                  isClockwise(void) const;

    virtual int          isPointUsed(GB_Element *pt) const;

    // Find out if we're visible at all (ie. in the valid interval of the
    // parent surface). Partial visibility returns 1. Full visibility
    // returns 2. 0 is returned if the face is completely invisible.
    virtual int          isVisible(void) const;

    // Return the barycenter of the part that visible (inside the surf domain).
    // 1 if found, 0 otherwise.
    virtual int          visibleBaryCenter(float &uctr, float &vctr) const;

    // Append n points equally spaced between the 1st and last vertex.
    void                 sampleEnds(int n);

    // Methods to handle vertex properties:
    virtual int          vertexApply(int (*apply)(GB_Vertex &vtx, void *),
                                    void  *data = 0);
    virtual int          vertexApply(int (*apply)(const GB_Vertex &vtx, void *),
                                    void  *data = 0) const;

    // Shift the array of vertices by an offset and wrap around. The offset
    // can be either negative or positive.
    virtual int          cycle(int amount, int = 1);

    // Reverses the vertices of a given face. It's virtual because some faces,
    // such as rational splines, need to be aware of it.
    virtual void         reverse();

    // Return the bounds of the valid evaluation interval in domain space:
    virtual void        validInterval(int   &a,  int   &b ) const;
    virtual void        validRange   (float &ua, float &ub) const;

    // Find the first visible range, i.e. one that is at most as big as the
    // valid interval and is visible on the surface. Partial visibility returns
    // 1. Full visibility returns 2. 0 is returned if completely invisible.
    int                 visibleRange(float &ua,float &ub, float tol=1E-4F) const;

    // Evaluate the face betw. breakpoints by taking a start and a stop index
    // in the valid domain and an lod representing number of points to
    // be interpolated between every two breakpoints. The methods ALWAYS
    // interpolate the encountered breakpoints (aka "edit points").They return
    // the number of points in the list or -1 if unsuccessful.
    virtual int         evaluateBreakSegm(int ustartidx, int ustopidx,
                            int lod, UT_Vector3 *pos, unsigned du=0) const;

    // Build a trim loop (which will be open unless the face is closed). The
    // loop is build every time you call this method, so it's expensive. You
    // must free the loop yourself when you are done with it. The trim pieces
    // are generated in the [ustart,ustop] or [ustop,ustart] interval, where
    // ustart and ustop are parametric values.
    virtual GD_TrimLoop *trimLoop(float ustart, float ustop) const = 0;

    // Intersects us with the domain boundaries. The list is sorted in t:
    int                  intersectDomain(UT_RefArray<GD_TrimHitInfo> &hitlist,
                                         float tol = 1E-4F) const;

    // Express the points in homogeneous coordinates or vice-versa. endcv can
    // be greater than the number of vertices or smaller than startcv. In 
    // both these cases we will wrap the index.
    void                homogenize  (int startcv = 0, int endcv = -1);
    void                dehomogenize(int startcv = 0, int endcv = -1);

    virtual int         breakCount() const = 0;
    // Get approximately "numdivs" number of points.  if the flag "usebreak"
    // is set, then, use the "evaluateBreakSeg" to get breakpoints along with
    // other points.  Otherwise, just get numdiv+1 points.
    int                 getPoints(int numdivs, UT_Vector3Array &domain,
                                  int usebreak);

    // Determine rationality of face.
    virtual void        weights(unsigned short) {}

protected:
    // Methods for finding out about point references
    virtual int  savePrivate(ostream &os, int binary) const = 0;
    virtual bool         loadPrivate(UT_IStream &is) = 0;
    virtual int  pointCanDelete(GB_Element *) const;
    virtual void pointDeleted(GB_Element *pt);

    // Check the validity of the data. Meant to be called especially at loading
    // time. The method returns 1 if OK and 0 if trouble.
    virtual bool         validate(void) const;

    // Insert a vertex multiple times in the list. Return the index.
    int                  multipleInsert(unsigned int where, 
                                        unsigned int count,
                                        unsigned int appendPoints = 1);


private:
    UT_RefArray<GD_Vertex>      myVtxList;
    GD_FaceFlags                myFlags;

    friend ostream      &operator<<(ostream &os, const GD_Face &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
};
#endif

---