mi32/dither.h

Go to the documentation of this file.

/*************************************************************************
 * \file mi32/dither.h
 * \brief Dither pattern classes.
 *
 * \if NODOC
 * $Log: dither.h_v $
 * Revision 1.13  2011/10/25 17:48:52  mju
 * Remove redundant hdr.
 *
 * Revision 1.12  2006/12/21 23:06:14  dwilliss
 * Decided to change the name
 *
 * Revision 1.11  2006/12/21 22:58:37  dwilliss
 * Added GetPatternLongName
 *
 * Revision 1.10  2006/04/20 15:41:02  dwilliss
 * made some virtual methods non-inline to silence unused parameter warnings
 *
 * Revision 1.7  2003/07/03 21:18:44  dwilliss
 * Added a dither line CMYK function
 *
 * Revision 1.4  2003/04/15 17:57:33  dwilliss
 * Added methods for setting dot gain, screen angles, and screen freq, as well
 * as methods to determine if a pattern supports any of those settings
 *
 * Revision 1.1  2002/10/22 20:56:56  dwilliss
 * Initial revision
 * \endif
 *****************************************************************************************/

#ifndef INC_MI32_DITHER_H
#define INC_MI32_DITHER_H

#ifndef INC_MI32_COLOR_H
#include <mi32/color.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
#include <mi32/simplear.h>
#endif

class MISTRING;

class DITHER {
   public:

      static DITHER* Allocate (
         const char* PatternName,
         int numcolors,
         int cols,
         bool bForceMono
         );

      static const char *GetPatternName (
         int num
         ); 

      static int GetPatternNum (
         const char *name
         ); 

      static char **GetPatternList (
         int *countp, 
         bool bAllowErrorDiffusion = true 
         );

      static MISTRING GetPatternLongName (
         const char *name
         );

      virtual ~DITHER();

      virtual void DitherSolidColor (
         const COLOR& color,
         UINT8** out,
         int lin,
         int col, 
         int numcols
         );
      
      virtual bool CanUseCMYKcm (
         ) const {
         return false;
         };

      virtual void DitherSolidColor (
         const UINT8 *rgb, 
         UINT8 **out, 
         int lin, 
         int col, 
         int cols, 
         UINT32 flags
         );

      void DitherSolidGray (
         UINT8 in,
         UINT8* out,
         int lin,
         int col,
         int numcols
         ) {
         DitherSolidComponent(0, in, out, lin, col, numcols);
         }

      virtual void DitherLineCMYK (
         const UINT8* const* trans,
         const UINT8* in,
         UINT8** out,
         const UINT8* mask,
         int lin,
         int col, 
         int NumCols
         );

      virtual void DitherLineRGB24 (
         const UINT8* const* trans,
         const UINT8* in,
         UINT8** out,
         const UINT8* mask,
         int lin,
         int col, 
         int NumCols
         );

      virtual void DitherLineGray (
         const UINT8* trans,
         const UINT8* in,
         UINT8* out,
         const UINT8* mask,
         int lin,
         int col,
         int numcols
         ) {
         DitherComponent(0, trans, in, out, mask, lin, col, numcols, 1);
         }
      


      int GetNumLevels (
         ) const {
         return m_NumLevels;
         }

      int GetMaxVal (
         ) const {
         return m_NumLevels - 1;
         }

      virtual bool HasDotGainCompensation (
         ) const {
         return (false);
         }

      virtual bool HasVariableScreenAngle (
         ) const {
         return (false);
         }

      virtual bool HasVariableScreenFreq (
         ) const {
         return (false);
         }

      virtual void SetDotGain (
         int comp,
         double size       
         );

      virtual void SetScreenAngle (
         int comp,
         double angle      
         );

      virtual void SetScreenFreq (
         double HalftoneDPI,
         double PrinterDPI
         );

      double ComputeCoverage (
         int level,        
         double DotGain    
         );

      bool SetUseCMYKcm (
         bool val = true
         ) {
         if (!CanUseCMYKcm()) return false;
         m_bUseCMYKcm = val;  
         return (val);
         };

   protected:

      DITHER();

      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void DitherComponent (
         int color,
         const UINT8* trans,
         const UINT8* in,
         UINT8* out,
         const UINT8* mask,
         int lin,
         int col,
         int numcols,
         int step
         ) = 0;
      
      virtual void DitherSolidComponent (
         int color,
         UINT8 in,
         UINT8* out,
         int lin,
         int col,
         int numcols
         ) = 0;

      virtual int Init (
         int PatternNum,
         int numcolors,
         int cols,
         bool bForceMono
         ) = 0;

      void SetNumLevels (
         int n
         ) {
         m_NumLevels = n;
         }

      bool m_bUseCMYKcm;
      #endif 

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      static int ReadPatternNames();

      int m_NumLevels;
      SIMPLE_ARRAY<UINT8> m_TempBuf;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };



#endif  // INC_MI32_DITHER_H

---