iglyphsclusters.h

Go to the documentation of this file.

/*
 * Copyright (C) 2009-2023 Global Graphics Software Ltd. All rights reserved.
 */

 
 
#ifndef GLYPHSCLUSTERS_H
#define GLYPHSCLUSTERS_H
 
#include <edl/edlnamespaces.h>
#include <edl/edltypes.h>
#include <edl/ircobject.h>
#include <edl/edlstring.h>
#include <edl/edlvector.h>
#include <edl/edlmath.h>
 
_BEGIN_EDL_DOM_NAMESPACE

class CIndicesGlyph
{
  public:
    CIndicesGlyph()
    {
        hasGlyphId = false;
        hasAdvance = false;
        hasUOffset = false;
        hasVOffset = false;
        advance    = 0.0;
        glyphId    = 0;
        uOffset    = 0.0;
        vOffset    = 0.0;
    }
    bool   hasGlyphId; 
    uint16 glyphId;    
    bool   hasAdvance; 
    float  advance;    
    bool   hasUOffset; 
    float  uOffset;    
    bool   hasVOffset; 
    float  vOffset;    
 
    bool operator== (const CIndicesGlyph &other) const
    {
        bool bEq =      (other.hasGlyphId == hasGlyphId)
                    &&  (other.hasAdvance == hasAdvance)
                    &&  (other.hasUOffset == hasUOffset)
                    &&  (other.hasVOffset == hasVOffset);
 
        if (bEq && hasGlyphId)
            bEq = (other.glyphId == glyphId);
 
        if (bEq && hasAdvance)
            bEq = (other.advance == advance);
 
        if (bEq && hasUOffset)
            bEq = (other.uOffset == uOffset);
 
        if (bEq && hasVOffset)
            bEq = (other.vOffset == vOffset);
 
        return bEq;
    }

    bool similar(const CIndicesGlyph &other, float eps) const
    {
        bool bSimilar =      (other.hasGlyphId == hasGlyphId)
                        &&  (other.hasAdvance == hasAdvance)
                        &&  (other.hasUOffset == hasUOffset)
                        &&  (other.hasVOffset == hasVOffset);
 
        if (bSimilar && hasGlyphId)
        {
            bSimilar = (other.glyphId == glyphId);
        }
 
        if (bSimilar && hasAdvance)
        {
            bSimilar = fabs(other.advance - advance) <= eps;
        }
 
        if (bSimilar && hasUOffset)
        {
            bSimilar = fabs(other.uOffset - uOffset) <= eps;
        }
 
        if (bSimilar && hasVOffset)
        {
            bSimilar = fabs(other.vOffset - vOffset) <= eps;
        }
 
        return bSimilar;
    }
 
    bool operator!= (const CIndicesGlyph &other) const
    {
        return ! (*this == other);
    }
};
 
// A vector of CIndicesGlyph
typedef CEDLVector<CIndicesGlyph, 2> CIndicesGlyphList;

class CGlyphsCluster
{
  public:
    CGlyphsCluster() {}
    CGlyphsCluster(uint32 codePoint)
    {
        unicode.resize(1);
        unicode[0] = codePoint;
    }
    CEDLVector<uint32, 5> unicode; 
    CIndicesGlyphList     glyphs;  

    bool similar(const CGlyphsCluster &other, float eps) const
    {
        bool bSimilar = (other.unicode == unicode) &&
                        (other.glyphs.size() == glyphs.size());
 
        for (uint32 i = 0; bSimilar && i < glyphs.size(); i++)
        {
            bSimilar = glyphs[i].similar(other.glyphs[i], eps);
        }
 
        return bSimilar;
    }
 
};
 
class IGlyphsClusters;
DECL_SMART_PTR(IGlyphsClusters);

class IGlyphsClusters : public IRCObject
{
  public:
    virtual ~IGlyphsClusters() {}

    static EDL_API IGlyphsClustersPtr create();

    static EDL_API IGlyphsClustersPtr create(const EDLString &unicodeString, const EDLSysString &indices);

    virtual IGlyphsClustersPtr clone() const = 0;

    virtual void populateUnicodeAndIndices(EDLString &unicodeString, EDLSysString &indices) = 0;

    virtual void clear() = 0;

    virtual uint32 getNumClusters() const = 0;

    virtual CGlyphsCluster &getCluster(uint32 index) = 0;

    virtual void deleteCluster(uint32 index) = 0;

    virtual void insertCluster(uint32 index, const CGlyphsCluster &cluster) = 0;

    virtual void appendCluster(const CGlyphsCluster &cluster) = 0;

    virtual CGlyphsCluster &newCluster() = 0;

    virtual bool similar(const IGlyphsClustersPtr &other, float eps) const = 0;
 
};
 
_END_EDL_DOM_NAMESPACE
 
#endif