GT_DAClampedArray.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.
 *
 * NAME:        GT_DAClampedArray.h ( GT Library, C++)
 *
 * COMMENTS:
 */
#ifndef __GT_DAClampedArray__
#define __GT_DAClampedArray__

#include "GT_API.h"
#include "GT_DAInherit.h"

#include <UT/UT_StringArray.h> 
#include <UT/UT_ValArray.h>

/// @brief A value-clamped version of another array, useful for data ranges.
class GT_API GT_DAClampedArray : public GT_DAInherit
{
public:
    GT_DAClampedArray()
        : myMin(-SYS_FP64_MAX),
          myMax(SYS_FP64_MAX)
    {}
    GT_DAClampedArray(const GT_DataArrayHandle &data,
                      fpreal64 min_v, fpreal64 max_v)
        : GT_DAInherit(data),
          myMin(min_v),
          myMax(max_v)
    {}
    GT_DAClampedArray(const GT_DAClampedArray &src)
        : GT_DAInherit(src),
          myMin(src.myMin),
          myMax(src.myMax)
    {}
    ~GT_DAClampedArray() override;
    
    const char *className() const override { return "GT_DAClampedArray"; }
    GT_Size     entries() const override { return myData->entries(); }
#define CLAMP(EXPR, TYPE) SYSclamp((EXPR), (TYPE)myMin, (TYPE)myMax)
    fpreal16    getF16(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getF16(offset, idx), fpreal16); }
    fpreal32    getF32(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getF32(offset, idx), fpreal32); }
    fpreal64    getF64(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getF64(offset, idx), fpreal64); }
    uint8       getU8(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getU8(offset, idx), uint8); }
    int32       getI32(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getI32(offset, idx), int32); }
    int64       getI64(GT_Offset offset, int idx=0) const override
        { return CLAMP(myData->getI64(offset, idx), int64); }
    GT_String   getS(GT_Offset offset, int idx=0) const override
                    { return myData->getS(offset, idx); }
    GT_Size     getStringIndexCount() const override
                    { return myData->getStringIndexCount(); }
    GT_Offset   getStringIndex(GT_Offset offset, int idx) const override
                    { return myData->getStringIndex(offset, idx); }
    void        getIndexedStrings(UT_StringArray &strings,
                                  UT_IntArray &indices) const override
                    { myData->getIndexedStrings(strings, indices); }
    bool        getSA(UT_StringArray &a, GT_Offset offset) const override
                    { return myData->getSA(a, offset); }
    GT_Size         getDictIndexCount() const override
                    { return myData->getDictIndexCount(); }
    GT_Offset   getDictIndex(GT_Offset offset, int idx) const override
                    { return myData->getDictIndex(offset, idx); }
    void        getIndexedDicts(UT_Array<UT_OptionsHolder> &dicts,
                                  UT_IntArray &indices) const override
                    { myData->getIndexedDicts(dicts, indices); }
#undef CLAMP
#define CLAMP_VALUES(TYPE)    \
    for(exint i=0; i<sz; i++) \
        d[i] = SYSclamp(d[i], TYPE(myMin), TYPE(myMax))
    
    void        doImport(GT_Offset off, uint8 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(uint8); }
    void        doImport(GT_Offset off, int8 *d, GT_Size sz) const override
                    { myData->import(off, d, sz); 
                      CLAMP_VALUES(int8); }
    void        doImport(GT_Offset off, int16 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(int16); }
    void        doImport(GT_Offset off, int32 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(int32); }
    void        doImport(GT_Offset off, int64 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(int64); }
    void        doImport(GT_Offset off, fpreal16 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(fpreal16); }
    void        doImport(GT_Offset off, fpreal32 *d, GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(fpreal32); }
    void        doImport(GT_Offset off, fpreal64 *d,
                         GT_Size sz) const override
                    { myData->import(off, d, sz);
                      CLAMP_VALUES(fpreal64); }
#undef CLAMP_VALUES
#define CLAMP_ARRAY(TYPE) \
    for(int i=0; i<data.entries(); i++) \
        data(i) = SYSclamp(data(i), (TYPE)myMin, (TYPE)myMax)
    
    void        doImportArray(GT_Offset off,
                              UT_ValArray<fpreal16> &data) const override
                    { myData->import(off, data);
                      CLAMP_ARRAY(fpreal16); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<fpreal32> &data) const override
                    { myData->import(off, data); 
                      CLAMP_ARRAY(fpreal32); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<fpreal64> &data) const override
                    { myData->import(off, data); 
                      CLAMP_ARRAY(fpreal64); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<uint8> &data) const override
                    { myData->import(off, data);  
                      CLAMP_ARRAY(uint8);}
    void        doImportArray(GT_Offset off,
                              UT_ValArray<int8> &data) const override
                    { myData->import(off, data);  
                      CLAMP_ARRAY(int8); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<int16> &data) const override
                    { myData->import(off, data);  
                      CLAMP_ARRAY(int16); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<int32> &data) const override
                    { myData->import(off, data);  
                      CLAMP_ARRAY(int32); }
    void        doImportArray(GT_Offset off,
                              UT_ValArray<int64> &data) const override
                    { myData->import(off, data);  
                      CLAMP_ARRAY(int64); }
    void        fillStringArray(UT_StringArray &data,
                                UT_ValArray<int> &sizes,
                                GT_Offset start, GT_Size length) const override
                    {
                        UT_ASSERT(start >= 0 && length <= entries());
                        if (myData->getStorage() == GT_STORE_STRING)
                        {
                            UT_StringArray attr_strings;
                            for (GT_Offset off = start; off < length; ++off)
                            {
                                attr_strings.clear();
                                getSA(attr_strings, off);
                                sizes.append(attr_strings.entries());
                                data.concat(attr_strings);
                            }
                        }
                    }
    
#undef CLAMP_ARRAY
    
private:
    double myMin;
    double myMax;
};

#endif