GiPalette.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, 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-2022 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, g, b;
 
  OdGiIntRGB(OdInt32 _r, OdInt32 _g, OdInt32 _b)
    : r(_r), g(_g), b(_b)
  { }
  OdGiIntRGB() { }
  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__