GEO/GEO_Profiles.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:
 *      This defines the detail of domain profiles.
 */

#ifndef __GEO_Profiles_h__
#define __GEO_Profiles_h__

#include "GEO_API.h"
#include <GD/GD_Detail.h>
#include <GD/GD_TrimLoop.h>

class UT_BoundingBox;
class GB_Basis;
class GB_PrimitiveGroup;
class GD_Face;
class GD_TrimLoop;
class GEO_Face;
class GEO_TPSurf;
class GEO_Detail;

class GEO_API GEO_Profiles : public GD_Detail
{
    friend class GEO_TPSurf;

public:
             GEO_Profiles(GEO_TPSurf &tpsurf);
    virtual ~GEO_Profiles();

    // Take a GEO face and map it parametrically onto our surface. If the
    // bbox pointer is zero, we compute the face's bbox. Otherwise, we use
    // the given bbox instead.
    GD_Face             *map(const GEO_Face &face, UT_Axis3::axis uaxis,
                             UT_Axis3::axis vaxis, float umin, float umax,
                             float vmin, float vmax, int unif,
                             UT_BoundingBox *bbox = 0);

    // Take a GEO face and map it parametrically onto our surface without
    // constraining it to a uvmin/uvmax range.
    GD_Face             *map(const GEO_Face &face,
                             UT_Axis3::axis uaxis = UT_Axis3::XAXIS,
                             UT_Axis3::axis vaxis = UT_Axis3::YAXIS);

    // Map a whole group of primitives onto the surface. The method filters
    // out the non face types and returns the number of faces mapped (0 or
    // more). If problems occur, the value returned is -1. If gdp is 0, we
    // assume it's the gdp our surface lives in.
    int                  map(const GB_PrimitiveGroup &faces,
                             UT_Axis3::axis uaxis,
                             UT_Axis3::axis vaxis, float umin, float umax,
                             float vmin, float vmax, int unif,
                             GEO_Detail *gdp = 0);

    // Remap an existing curve on surface so that it translates and/or 
    // scales itself in the domain of the surface. Return 0 if OK and -1
    // otherwise.
    int                 remap(GD_Primitive &profile, float umin, float umax,
                              float vmin, float vmax, int unif)
                        {
                            return remap(profile.getNum(),umin, umax, vmin,
                                         vmax, unif);
                        }
    int                 remap(int profileidx, float umin, float umax,
                              float vmin, float vmax, int unif);

    //
    // Reverse the faces and the trim regions:
    void                 reverseU(void);
    void                 reverseV(void);

    // Return the bounds of the valid interval of the surface we're defined
    // for.
    virtual void         getDomainBBox(float &u0, float &v0,
                                       float &u1, float &v1) const;

    GD_TrimLoop         *getTrimLoops(GD_TrimRule rule);

    int                  getMaxHeight();
    int                  getBaseDir();

    const GEO_TPSurf    &getSurf() const { return mySurf; }

private:
    // The surface we belong to:
    GEO_TPSurf          &mySurf;

    int                  getUVRange(float umin, float umax, float vmin,
                                    float vmax, int unif, float &uka,
                                    float &ukb, float &vka, float &vkb,
                                    GB_Basis *&ubunif, GB_Basis *&vbunif,
                                    GB_Basis *&uchrd, GB_Basis *&vchrd) const;

    GD_Face             *doMap(const GEO_Face &face,
                                UT_Axis3::axis uaxis, UT_Axis3::axis vaxis,
                                float uka, float ulen, float vka, float vlen,
                                int unif, GB_Basis *ubunif,  GB_Basis *vbunif,
                                GB_Basis *ubchord, GB_Basis *vbchord,
                                UT_BoundingBox *bbox);

    void                 doMap(GD_Face &face,
                                float uka, float ulen, float vka, float vlen,
                                int unif, GB_Basis *ubunif,  GB_Basis *vbunif,
                                GB_Basis *ubchord, GB_Basis *vbchord);

    //  Friends:
    friend ostream      &operator<<(ostream &os, const GEO_Profiles &d)
                        {
                            d.save(os, 0, 0);
                            return os;
                        }
};

#endif

---