GDT/GDT_PointList.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:
 *      George ElKoura
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GDT Library. (Geo Delta)
 *
 * COMMENTS:    GDT_PointList contains tokens for point attributes and
 *              a position token.  All these tokens are not sparse.
 *
 */
#ifndef __GDT_PointList_h__
#define __GDT_PointList_h__

#include "GDT_API.h"
#include "GDT_TokenList.h"

#include <GEO/GEO_Detail.h>
#include "GDT_CaptureWeight.h"
#include "GDT_Position.h"
#include "GDT_CoordinateFrames.h"

class GB_PointGroup;

class GDT_API GDT_PointList : public GDT_TokenList
{
public:
            GDT_PointList() : myPosition(0), myCaptureWeight(0), myCoordinateFrames(0) {}
            GDT_PointList(const GDT_PointList &other);
    virtual ~GDT_PointList();

    // We have to override applyDeltas because we have an extra delta
    virtual void         applyDeltas(GEO_Detail &gdp, bool inverse=false) const;

    virtual void         applyScaledDelta(GEO_Detail &gdp,
                                        GEO_Point &pt, float scale) const;
    virtual void         applyScaledPosDeltas(GEO_Detail &gdp,
                                              float scale,
                                              const GB_PointGroup *ptgroup = 0) const;

    // Merge the point deltas from another GDT_PointList into this one
    void                 mergePointDeltas(const GDT_PointList &other,
                                          bool inverse = false);

    // Begin/end a change to a point position
    void                 beginPointPositionChange(const UT_Vector4 &startpos);
    void                 endPointPositionChange(const UT_Vector4 &endpos,
                                                unsigned int index);

    void                 getOpPaths( UT_StringList &paths );
    void                 getOpPathsCopy( UT_PtrArray<char *> &paths );
    void                 setOpPaths( const UT_PtrArray<char *> &paths );
    int                  changeOpPaths( const char *old_name,
                                        const char *new_name );
    bool                 changeCaptureRegionRoot( const char *old_root,
                                                  const char *new_root );
    void                 refreshCaptureFrameInfo( 
                                const GEO_Detail &gdp,
                                GDT_CaptureRegionCB get_region,
                                void *user_data );
    void                 initCaptureWeightChange( const GEO_Detail &gdp );
    void                 beginCaptureWeightChange(
                                const GB_AttributeData &data );
    void                 endCaptureWeightChange(
                                const GB_AttributeData &data,
                                unsigned int point_index );

    // takePositionSnapshot fails if the topologies of the two gdp's are
    // different.
    // Returns true if successful, false otherwise.
//    bool               takePositionSnapshot(const GEO_Detail &beforegdp,
//                                            const GEO_Detail &aftergdp,
//                                            const GB_PointGroup *grp=0);

    // Can't take const gdps because even looking at an attribute requires
    // write access.
//    virtual bool       takeAttributeSnapshot(const GEO_Detail &beforegdp,
//                                const GEO_Detail &aftergdp,
//                                const UT_String &name,
//                                int size,
//                                GB_AttribType type,
//                                const GB_BaseGroup *grp=0);

    virtual unsigned int        getElementCount(const GEO_Detail &gdp) const
                                { return gdp.points().entries(); }

    virtual void                initIterate() const { myLastIndex = -1; }
    virtual GB_AttributeElem   *getNextAttributeElement(GEO_Detail &gdp) const
                                { return gdp.points()(++myLastIndex); }
    virtual GB_AttributeElem   *getAttributeElement(GEO_Detail &gdp,
                                                   unsigned int index) const
                                { return gdp.points()(index); }



    virtual GB_AttributeDict    &getAttributeDict(GEO_Detail &gdp) const
                                 { return gdp.pointAttribs(); }


    virtual int                  appendGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int size,
                                                GB_AttribType type,
                                                const void *defvalue) const
                                 {
                                    return gdp.pointAttribs().append(
                                            name, size, type, defvalue);
                                 }

    virtual int                  growGdpAttribute(GEO_Detail &gdp,
                                                const char *name, int oldsize,
                                                GB_AttribType type,
                                                unsigned int addedsize) const
                                 { 
                                    return gdp.pointAttribs().grow(
                                            name, oldsize, type, addedsize); 
                                 }

    virtual bool                 hasChange() const;
    virtual bool                 haveAttributesChanged() const
                                 { return GDT_TokenList::hasChange(); }
    // Returns true if point position data is present, return false otherwise
    bool                         hasPositionChanged() const 
                                 { 
                                     return (myPosition && 
                                             myPosition->changed() > 0); 
                                 }
    bool                         hasCaptureWeightChanged() const
                                 {
                                     return (myCaptureWeight && 
                                             myCaptureWeight->changed() > 0); 
                                 }

    virtual unsigned int         entries() const;

    int                          savePos(ostream &os, int binary = 0) const;

    // If myPosition has been blanked out, then loadPos will pre-allocate
    // numtotal slots in the position array.  If myPosition exists, then this
    // number is ignored and the data is loaded and merged with what already
    // exists.
    bool                         loadPos(UT_IStream &is, uint numtotal);

    int                          saveCaptureWeight(ostream &os,
                                                   int binary = 0) const;
    bool                         loadCaptureWeight(UT_IStream &is,
                                                   unsigned int numtotal);

    // Zero the point deltas
    virtual void                 zeroDeltas();
    // Destroy the point deltas, but not the attribute lists
    virtual void                 clearDeltas();
    // Destroy the point deltas
    virtual void                 destroy();

    void                         setCoordinateFrames(const GDT_CoordinateFrames *coords);
    const GDT_CoordinateFrames  *getCoordinateFrames();

    void                         createSymmetryDeltas(const GDT_PointList &input, GDT_SymmetryTransform *transform);

protected:

    virtual void         getAttributeElements(const GEO_Detail &beforegdp,
                                  const GEO_Detail &aftergdp,
                                  unsigned int before_elem_index,
                                  unsigned int after_elem_index,
                                  const GB_AttributeElem *&beforeelem,
                                  const GB_AttributeElem *&afterelem) const
                         {
                            beforeelem = beforegdp.points()(before_elem_index);
                            afterelem  = aftergdp.points()(after_elem_index);
                         }
    

    GDT_Position        *newPosition(const GDT_Position &p);
    GDT_Position        *newPosition(unsigned int numpos);

private:

    // The position token is kept apart from the token list, so that
    // we can make the token list general and not have to check extra cases.
    GDT_Position        *myPosition;

    GDT_CaptureWeight   *myCaptureWeight;

    mutable int          myLastIndex;   // keeps track of last accessed point
                                        // for looping through points

    const GDT_CoordinateFrames  *myCoordinateFrames;
};
#endif

---