GiPalette.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2024 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __ODGIPALETTE_H__
#define __ODGIPALETTE_H__
 
#include "TD_PackPush.h"
 
#include "GiExport.h"
#include "OdArray.h"
#include "StaticRxObject.h"

struct OdGiIntRGB
{
  OdInt32 r;
  OdInt32 g;
  OdInt32 b;

  OdGiIntRGB(OdInt32 _r, OdInt32 _g, OdInt32 _b)
    : r(_r), g(_g), b(_b)
  { }
  
  OdGiIntRGB()
    : r(0), g(0), b(0)
  { }
 
  
  OdGiIntRGB(ODCOLORREF cref)
  {
    setColor(cref);
  }

  OdInt32 red() const { return r; }
  OdInt32 green() const { return g; }
  OdInt32 blue() const { return b; }

  void setRed(OdInt32 _r) { r = _r; }
  void setGreen(OdInt32 _g) { g = _g; }
  void setBlue(OdInt32 _b) { b = _b; }
  void setRGB(OdInt32 _r, OdInt32 _g, OdInt32 _b) { r = _r; g = _g; b = _b; }

  void setColor(ODCOLORREF cref)
  {
    setRGB((OdInt32)ODGETRED(cref), (OdInt32)ODGETGREEN(cref), (OdInt32)ODGETBLUE(cref));
  }

  ODCOLORREF color() const
  {
    return ODRGB(r, g, b);
  }
};

class ODGI_EXPORT OdGiColorCube : public OdStaticRxObject<OdRxObject>
{
  protected:
    OdInt32    m_nBaseOffset;
    OdGiIntRGB m_nGridDivs;
    float      m_fIntensity;
    OdInt32    m_nGridSize;
    OdGiIntRGB m_nOffsets;
    OdGiIntRGB m_nDims;
  protected:
    virtual bool isDynamic() const { return false; }
  public:
    OdGiColorCube(OdGiIntRGB nGridDivs = OdGiIntRGB(2, 2, 2), float fIntensity = 1.0f, OdInt32 nBaseOffset = 0)
      : m_nBaseOffset(nBaseOffset)
      , m_nGridDivs(nGridDivs)
      , m_fIntensity(fIntensity)
    {
      validate();
    }
    static OdSmartPtr<OdGiColorCube> createDynamic(OdGiIntRGB nGridDivs = OdGiIntRGB(2, 2, 2), float fIntensity = 1.0f, OdInt32 nBaseOffset = 0);
 
    virtual OdRxObjectPtr clone() const;
    OdSmartPtr<OdGiColorCube> cloneIfNeed() const { if (!isDynamic()) return clone(); return this; }

    OdInt32 baseOffset() const { return m_nBaseOffset; }
    const OdGiIntRGB &gridDivisions() const { return m_nGridDivs; }
    float intensity() const { return m_fIntensity; }
    OdInt32 gridSize() const { return m_nGridSize; }
    const OdGiIntRGB &offsets() const { return m_nOffsets; }
    const OdGiIntRGB &dimensions() const { return m_nDims; }

    ODCOLORREF color(OdInt32 nColor) const;

    OdInt32 closestMatch(ODCOLORREF cref) const;
 
    struct DtMatchResult
    {
      OdInt32 m_fitColors[4];
      OdInt32 m_pattern[4];
    };

    OdInt32 ditheredMatch(ODCOLORREF cref, DtMatchResult &results) const;
  protected:
    void validate();
};

typedef OdSmartPtr<OdGiColorCube> OdGiColorCubePtr;

class ODGI_EXPORT OdGiGrayRamp : public OdStaticRxObject<OdRxObject>
{
  protected:
    OdInt32 m_nBaseOffset;
    OdInt32 m_nGridDivs;
    float m_fIntensity;
    OdInt32 m_nDim;
  protected:
    virtual bool isDynamic() const { return false; }
  public:
    OdGiGrayRamp(OdInt32 nGridDivs = 2, float fIntensity = 1.0f, OdInt32 nBaseOffset = 0)
      : m_nBaseOffset(nBaseOffset)
      , m_nGridDivs(nGridDivs)
      , m_fIntensity(fIntensity)
    {
      validate();
    }
    static OdSmartPtr<OdGiGrayRamp> createDynamic(OdInt32 nGridDivs = 2, float fIntensity = 1.0f, OdInt32 nBaseOffset = 0);
 
    virtual OdRxObjectPtr clone() const;
    OdSmartPtr<OdGiGrayRamp> cloneIfNeed() const { if (!isDynamic()) return clone(); return this; }

    OdInt32 baseOffset() const { return m_nBaseOffset; }
    OdInt32 gridDivisions() const { return m_nGridDivs; }
    float intensity() const { return m_fIntensity; }
    OdInt32 dimension() const { return m_nDim; }

    ODCOLORREF color(OdInt32 nColor) const;

    OdInt32 closestMatch(ODCOLORREF cref) const;
  protected:
    void validate();
};

typedef OdSmartPtr<OdGiGrayRamp> OdGiGrayRampPtr;

class ODGI_EXPORT OdGiPalette : public OdStaticRxObject<OdRxObject>
{
  protected:
    ODCOLORREF       m_colors[256];
    OdUInt64         m_activities[4];
    OdGiColorCubePtr m_pColorCube;
    OdGiGrayRampPtr  m_pGrayRamp;
  public:
    struct Addressation
    {
      OdInt32 m_nSrcFrom;
      OdInt32 m_nDstTo;
      OdInt32 m_nNumColors;
      Addressation(OdInt32 nFrom = 0, OdInt32 nTo = 0, OdInt32 nNum = 256)
        : m_nSrcFrom(nFrom), m_nDstTo(nTo), m_nNumColors(nNum)
      {}
      bool validate() const { return ((m_nSrcFrom + m_nNumColors) <= 256) && ((m_nDstTo + m_nNumColors) <= 256); }
      bool fullRange() const { return (m_nSrcFrom == 0) && (m_nDstTo == 0) && (m_nNumColors == 256); }
    };
  protected:
    virtual bool isDynamic() const { return false; }
  public:
    OdGiPalette()
    {
      initPalette();
    }
    
    OdGiPalette(const OdGiPalette& obj);
    static OdSmartPtr<OdGiPalette> createDynamic();
 
    OdGiPalette& operator= (const OdGiPalette & obj);
 
    virtual OdRxObjectPtr clone() const;
    OdSmartPtr<OdGiPalette> cloneIfNeed() const { if (!isDynamic()) return clone(); return this; }

    ODCOLORREF color(OdInt32 nColor) const
    {
      return m_colors[nColor];
    }

    bool entryActivity(OdInt32 nColor) const
    {
      return GETBIT(m_activities[nColor >> 6], 1ULL << (OdUInt64(nColor) & 63));
    }

    void setColor(OdInt32 nColor, ODCOLORREF color)
    {
      m_colors[nColor] = color;
    }

    void setEntryActivity(OdInt32 nColor, bool bActivity)
    {
      SETBIT(m_activities[nColor >> 6], 1ULL << (OdUInt64(nColor) & 63), bActivity);
    }

    const ODCOLORREF *asArray() const
    {
      return m_colors;
    }

    const OdGiColorCube *colorCube() const
    {
      return m_pColorCube.get();
    }

    void setColorCube(const OdGiColorCube *pColorCube)
    {
      resetColorCube(pColorCube);
    }

    void resetColorCube()
    {
      resetColorCube(NULL);
    }

    const OdGiGrayRamp *grayRamp() const
    {
      return m_pGrayRamp.get();
    }

    void setGrayRamp(const OdGiGrayRamp *pGrayRamp)
    {
      resetGrayRamp(pGrayRamp);
    }

    void resetGrayRamp()
    {
      resetGrayRamp(NULL);
    }

    bool install(const OdGiColorCube *pColorCube, bool bForceUpdate = false);
    bool install(const OdGiGrayRamp *pGrayRamp, bool bForceUpdate = false);
    bool install(const OdGiPalette *pPalette, bool bForceUpdate = false, const Addressation &address = Addressation());
    bool install(ODCOLORREF const *const pColors, bool bForceUpdate = false, const Addressation &address = Addressation());

    OdInt32 closestMatch(ODCOLORREF cref, bool bThroughPal = false) const;

    OdInt32 firstAvailableBlock(OdInt32 blockSize) const;

    bool isEqualTo(const OdGiPalette *pPalette, const Addressation &address = Addressation()) const;
    bool remove(const OdGiPalette *pPalette, bool bForceUpdate = false, const Addressation &address = Addressation());

    void clear();
  protected:
    void initPalette();
 
    void resetColorCube(const OdGiColorCube *pColorCube);
    void resetGrayRamp(const OdGiGrayRamp *pGrayRamp);
 
    void setColorImpl(OdInt32 nColor, ODCOLORREF color)
    {
      m_colors[nColor] = color;
      setEntryActivity(nColor, true);
    }
};

typedef OdSmartPtr<OdGiPalette> OdGiPalettePtr;
 
// Forward declaration
class OdGiSubEntityTraits;

class ODGI_EXPORT OdGiPaletteOverrideHelper
{
  protected:
    OdGiSubEntityTraits *m_pTraits;
  public:
    OdGiPaletteOverrideHelper() : m_pTraits(NULL) {}
    
    OdGiPaletteOverrideHelper(OdGiSubEntityTraits &pTraits, const OdGiPalette &pOverride) : m_pTraits(NULL)
    { setPaletteOverride(pTraits, pOverride); }
    
    ~OdGiPaletteOverrideHelper();
    void setPaletteOverride(OdGiSubEntityTraits &pTraits, const OdGiPalette &pOverride);
};
 
#include "TD_PackPop.h"
 
#endif //#ifndef __ODGIPALETTE_H__