EgtGeomKernel/Color.cpp

//----------------------------------------------------------------------------
//  EgalTech 2014-2014
//----------------------------------------------------------------------------
// File : Color.cpp          Data : 12.03.14          Versione : 1.5a5
// Contenuto : Implementazione funzioni per gestione colori.
//
//
//
// Modifiche : 12.03.14 DS Creazione modulo.
//             24.04.14 DS Agg. GetSurfBackColor.
//
//----------------------------------------------------------------------------

//--------------------------- Include ----------------------------------------
#include "stdafx.h"
#include "/EgtDev/Include/EGkGeoConst.h"
#include "/EgtDev/Include/EGkColor.h"
#include "/EgtDev/Include/EGkAngle.h"
#include "/EgtDev/Include/EGnStringUtils.h"
#include "/EgtDev/Include/EgtNumUtils.h"
#include <algorithm>

using namespace std ;

//------------------------- Constants ----------------------------------------
struct NamedColor {
   const char* szName ;
   Color       colC ;
} ;
static const NamedColor StdColor[] = {
   { "WHITE", WHITE},
   { "LGRAY", LGRAY},
   { "GRAY", GRAY},
   { "BLACK", BLACK},
   { "RED", RED},
   { "MAROON", MAROON},
   { "YELLOW", YELLOW},
   { "OLIVE", OLIVE},
   { "LIME", LIME},
   { "GREEN", GREEN},
   { "AQUA", AQUA},
   { "TEAL", TEAL},
   { "BLUE", BLUE},
   { "NAVY", NAVY},
   { "FUCHSIA", FUCHSIA},
   { "PURPLE", PURPLE},
   { "ORANGE", ORANGE},
   { "BROWN", BROWN},
   { "INVISIBLE", INVISIBLE}
} ;
static const int NUM_STDCOLOR = ( sizeof(StdColor) / sizeof(StdColor[0]) ) ;

//----------------------------------------------------------------------------
bool
GetStdColor( const string& sName, Color& cCol)
{
   string sCol = sName ;
   ToUpper( sCol) ;
   for ( int i = 0 ; i < NUM_STDCOLOR ; ++ i) {
      if ( sCol == StdColor[i].szName) {
         cCol = StdColor[i].colC ;
         return true ;
      }
   }

   return false ;
}

//----------------------------------------------------------------------------
bool
GetNameOfStdColor( Color cCol, string& sName)
{
   for ( int i = 0 ; i < NUM_STDCOLOR ; ++ i) {
      if ( cCol == StdColor[i].colC) {
         sName = StdColor[i].szName ;
         return true ;
      }
   }

   return false ;
}

//----------------------------------------------------------------------------
Color
GetOppositeColor( Color cCol)
{
   return Color( MAX_RGB - cCol.GetIntRed(),
                 MAX_RGB - cCol.GetIntGreen(),
                 MAX_RGB - cCol.GetIntBlue(),
                 cCol.GetIntAlpha()) ;
}

//----------------------------------------------------------------------------
Color
GetSurfBackColor( Color cCol)
{
   float fLum = ( cCol.GetRed() + cCol.GetGreen() + cCol.GetBlue()) / 3 ;
  // se opache
   if ( cCol.GetIntAlpha() > ALPHA_LIM)
      return Color( 0.4 * fLum + 0.4 * cCol.GetRed(),
                    0.4 * fLum + 0.4 * cCol.GetGreen(),
                    0.4 * fLum + 0.4 * cCol.GetBlue(),
                    cCol.GetAlpha()) ;
  // altrimenti semitrasparenti
   else
      return Color( 0.4 * fLum + 0.6 * cCol.GetRed(),
                    0.4 * fLum + 0.6 * cCol.GetGreen(),
                    0.4 * fLum + 0.6 * cCol.GetBlue(),
                    cCol.GetAlpha()) ;
}

//----------------------------------------------------------------------------
HSV
GetHSVFromColor( const Color& cCol)
{
   double dMin = std::min( std::min( cCol.GetRed(), cCol.GetGreen()), cCol.GetBlue()) ;
   double dMax = std::max( std::max( cCol.GetRed(), cCol.GetGreen()), cCol.GetBlue()) ;
   double dDelta = dMax - dMin ;

   if ( dDelta < EPS_ZERO)
      return HSV( 0, 0, dMax) ;

   if ( dMax < EPS_ZERO)
      return HSV( 0, 0, 0) ;

   HSV hsv ;
   hsv.dVal = dMax ;
   hsv.dSat = dDelta / dMax ;
   if ( cCol.GetRed() >= dMax)                                        // tra giallo e magenta
       hsv.dHue = ( cCol.GetGreen() - cCol.GetBlue()) / dDelta ;
   else if ( cCol.GetGreen() >= dMax)                                  // tra ciano e giallo
       hsv.dHue = 2.0 + ( cCol.GetBlue() - cCol.GetRed()) / dDelta ;
   else                                                               // tra magenta e ciano
       hsv.dHue = 4.0 + ( cCol.GetRed() - cCol.GetGreen()) / dDelta ;
  // trasformo in gradi
   hsv.dHue *= 60.0 ;
  // porto in 0-360 deg
   if ( hsv.dHue < 0.0)
      hsv.dHue += 360.0 ;

   return hsv;
}

//----------------------------------------------------------------------------
Color
GetColorFromHSV( const HSV& hsv)
{
  // porto i valori nei limiti
   double dHue = AngleNearAngle( hsv.dHue, ANG_STRAIGHT) ;
   double dSat = Clamp( hsv.dSat, 0., 1.) ;
   double dVal = Clamp( hsv.dVal, 0., 1.) ;
  // se saturazione nulla
   if ( dSat < EPS_ZERO)
      return Color( dVal, dVal, dVal) ;
  // calcolo
   double dFraz = dHue / 60. ;
   int nInd = int( dFraz) ;
   double dRem = dFraz - nInd ;
   double dP = dVal * ( 1.0 - dSat) ;
   double dQ = dVal * ( 1.0 - ( dSat * dRem)) ;
   double dT = dVal * ( 1.0 - ( dSat * (1.0 - dRem))) ;

   switch ( nInd) {
   case 0 :
      return Color( dVal, dT, dP) ;
   case 1 :
      return Color( dQ, dVal, dP) ;
   case 2 :
      return Color( dP, dVal, dT) ;
   case 3 :
      return Color( dP, dQ, dVal) ;
   case 4 :
      return Color( dT, dP, dVal) ;
   default :
      return Color( dVal, dP, dQ) ;
   }
}