UT/UT_Filter.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:
 *      Mark Elendt
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT_Filter.h ( UT Library, C++)
 *
 * COMMENTS:    Circular symmetric separable filters.  This class allows you to
 *              perform approximate filter weights given different filter
 *              kernels
 *
 *              The lookup tables are valid for 0-1 and should be called with
 *              the square of the distance...  The getWeight() methods can be
 *              used if given simple cartesian coordinates.
 */

#ifndef __UT_Filter__
#define __UT_Filter__

#include "UT_API.h"
#include <SYS/SYS_Types.h>
#include "UT_FilterType.h"

class UT_Filter;

// Build a convolution window for a given filter
class UT_API UT_FilterWindow {
public:
     UT_FilterWindow();
    ~UT_FilterWindow();

    void         setWeights(const UT_Filter &filter,
                            fpreal center, fpreal radius,
                            int res, UT_FilterWrap mode)
                 {
                      fpreal    iradius = 0.5F / radius;
                      setWeights(filter, center, radius, iradius, res, mode);
                 }
    void         setWeights(const UT_Filter &filter, fpreal center,
                            fpreal radius, fpreal iradius,
                            int res, UT_FilterWrap mode);

    // To fill weights allocated by the caller, use initWeights() followed
    // by fillWeights().  The required number of floats can be retrieved
    // with getSize() after calling initWeights().
    void         initWeights(fpreal center, fpreal radius);

    // Fill weights.  This operation will modify the filter start and end
    // values, ensuring that the start and end pixel are in the range
    // [0, res-1]
    void         fillWeights(fpreal *weights, const UT_Filter &filter,
                             fpreal center, fpreal iradius,
                             int res, UT_FilterWrap mode);

    void         allocWeights(int size);
    float       *getWeights()           { return myWeights; }
    const float *getWeights() const     { return myWeights; }
    int          getStart() const       { return myStart; }
    int          getEnd() const         { return myEnd; }
    int          getSize() const        { return mySize; }
    float        getVisible() const     { return myVisible; }

    void         trim(int min, int max);

private:
    float       *myWeights;
    int          myStart, myEnd, mySize, myAlloc;
    float        myVisible;
};


class UT_API UT_Filter {
public:
    // Method to lookup the filter by name.
    static UT_FilterType         lookupFilter(const char *name);
    static const char           *getFilterName(UT_FilterType type);
    static const char           *getFilterLabel(UT_FilterType type);

    // Get a well known filter type
    static UT_Filter            *getFilter(UT_FilterType type);

    // Get a custom filter kernel
    static UT_Filter            *getFilter(float (*evalfunc)(float, void *),
                                           int size, int support = 2,
                                           void *data = 0);

    static void                  releaseFilter(UT_Filter *filter);
    void                         access()       { myRefCount++; }

    UT_FilterType                getType() const;

    // Compute average weight over the span l-r.  l does not have to be less
    // than r (i.e. it will work as getWeight(r, l) just as well.
    // The valid range for samples is -0.5F to 0.5F (i.e. a filter width of 1)
    virtual fpreal      getWeight(fpreal l, fpreal r) const = 0;

    // This method assumes that l < r and both l and r are within valid ranges.
    // That is, no bounds checking is done.
    virtual fpreal      getFastWeight(fpreal l, fpreal r) const = 0;

    // Retrieve the filter area to the left of l
    virtual fpreal      getFastArea(fpreal l) const = 0;

    // Given four corners, compute the area under the trapezoidal prism.
    // Again, the filter width is defined over -0.5 to 0.5
    fpreal              getAreaWeight(fpreal l, fpreal r, fpreal b, fpreal t) const
                        {
                            return getWeight(l, r) * getWeight(b, t);
                        }
    fpreal              getFastAreaWeight(fpreal l, fpreal r,
                                          fpreal b, fpreal t) const
                        {
                            return getFastWeight(l, r) * getFastWeight(b, t);
                        }

    // Get the filters desired support radius (i.e. 2 for gaussian)
    fpreal              getSupport() const      { return mySupport; }

public:
    virtual ~UT_Filter();

protected:
     UT_Filter()        { myRefCount = 0; }

    int                  myRefCount;
    float                mySupport;
};

#endif

---