0030623: Draw Harness - support hex color codes within ViewerTest::ParseColor()
[occt.git] / src / ViewerTest / ViewerTest.cxx
index 5500112..bee28db 100644 (file)
@@ -82,9 +82,169 @@ extern int ViewerMainLoop(Standard_Integer argc, const char** argv);
 #define DEFAULT_FREEBOUNDARY_COLOR Quantity_NOC_GREEN
 #define DEFAULT_MATERIAL           Graphic3d_NOM_BRASS
 
+namespace
+{
+
+  const Standard_Integer THE_MAX_INTEGER_COLOR_COMPONENT = 255;
+
+  const Standard_ShortReal THE_MAX_REAL_COLOR_COMPONENT = 1.0f;
+
+  //! Parses string and get an integer color component (only values within range 0 .. 255 are allowed)
+  //! @param theColorComponentString the string representing the color component
+  //! @param theIntegerColorComponent an integer color component that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  static bool parseNumericalColorComponent (const Standard_CString theColorComponentString,
+                                            Standard_Integer&      theIntegerColorComponent)
+  {
+    Standard_Integer anIntegerColorComponent;
+    if (!Draw::ParseInteger (theColorComponentString, anIntegerColorComponent))
+    {
+      return false;
+    }
+    if ((anIntegerColorComponent < 0) || (anIntegerColorComponent > THE_MAX_INTEGER_COLOR_COMPONENT))
+    {
+      return false;
+    }
+    theIntegerColorComponent = anIntegerColorComponent;
+    return true;
+  }
+
+  //! Parses the string and gets a real color component from it (only values within range 0.0 .. 1.0 are allowed)
+  //! @param theColorComponentString the string representing the color component
+  //! @param theRealColorComponent a real color component that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  static bool parseNumericalColorComponent (const Standard_CString theColorComponentString,
+                                            Standard_ShortReal&    theRealColorComponent)
+  {
+    Standard_Real aRealColorComponent;
+    if (!Draw::ParseReal (theColorComponentString, aRealColorComponent))
+    {
+      return false;
+    }
+    const Standard_ShortReal aShortRealColorComponent = static_cast<Standard_ShortReal> (aRealColorComponent);
+    if ((aShortRealColorComponent < 0.0f) || (aShortRealColorComponent > THE_MAX_REAL_COLOR_COMPONENT))
+    {
+      return false;
+    }
+    theRealColorComponent = aShortRealColorComponent;
+    return true;
+  }
+
+  //! Parses the string and gets a real color component from it (integer values 2 .. 255 are scaled to the 0.0 .. 1.0
+  //! range, values 0 and 1 are leaved as they are)
+  //! @param theColorComponentString the string representing the color component
+  //! @param theColorComponent a color component that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  static bool parseColorComponent (const Standard_CString theColorComponentString,
+                                   Standard_ShortReal&    theColorComponent)
+  {
+    Standard_Integer anIntegerColorComponent;
+    if (parseNumericalColorComponent (theColorComponentString, anIntegerColorComponent))
+    {
+      if (anIntegerColorComponent == 1)
+      {
+        theColorComponent = THE_MAX_REAL_COLOR_COMPONENT;
+      }
+      else
+      {
+        theColorComponent = anIntegerColorComponent * 1.0f / THE_MAX_INTEGER_COLOR_COMPONENT;
+      }
+      return true;
+    }
+    return parseNumericalColorComponent (theColorComponentString, theColorComponent);
+  }
+
+  //! Parses the array of strings and gets an integer color (only values within range 0 .. 255 are allowed and at least
+  //! one of components must be greater than 1)
+  //! @tparam TheNumber the type of resulting color vector elements
+  //! @param theNumberOfColorComponents the number of color components
+  //! @param theColorComponentStrings the array of strings representing color components
+  //! @param theNumericalColor a 4-component vector that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  template <typename TheNumber>
+  static bool parseNumericalColor (Standard_Integer&            theNumberOfColorComponents,
+                                   const char* const* const     theColorComponentStrings,
+                                   NCollection_Vec4<TheNumber>& theNumericalColor)
+  {
+    for (Standard_Integer aColorComponentIndex = 0; aColorComponentIndex < theNumberOfColorComponents;
+         ++aColorComponentIndex)
+    {
+      const char* const aColorComponentString = theColorComponentStrings[aColorComponentIndex];
+      TheNumber         aNumericalColorComponent;
+      if (parseNumericalColorComponent (aColorComponentString, aNumericalColorComponent))
+      {
+        theNumericalColor[aColorComponentIndex] = aNumericalColorComponent;
+      }
+      else
+      {
+        if (aColorComponentIndex == 3)
+        {
+          theNumberOfColorComponents = 3;
+        }
+        else
+        {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  //! Parses an array of strings and get an integer color (only values within range 0 .. 255 are allowed and at least
+  //! one of components must be greater than 1)
+  //! @param theNumberOfColorComponents the number of color components
+  //! @param theColorComponentStrings the array of strings representing color components
+  //! @param theColor a color that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  static bool parseIntegerColor (Standard_Integer&        theNumberOfColorComponents,
+                                 const char* const* const theColorComponentStrings,
+                                 Quantity_ColorRGBA&      theColor)
+  {
+    const Standard_Integer THE_COLOR_COMPONENT_NOT_PARSED = -1;
+    Graphic3d_Vec4i        anIntegerColor (THE_COLOR_COMPONENT_NOT_PARSED);
+    if (!parseNumericalColor (theNumberOfColorComponents, theColorComponentStrings, anIntegerColor))
+    {
+      return false;
+    }
+
+    const bool hasColorComponentGreaterThanOne = (anIntegerColor.maxComp() > 1);
+    if (anIntegerColor.a() == THE_COLOR_COMPONENT_NOT_PARSED)
+    {
+      anIntegerColor.a() = THE_MAX_INTEGER_COLOR_COMPONENT;
+    }
+
+    Graphic3d_Vec4 aRealColor (anIntegerColor);
+    if (hasColorComponentGreaterThanOne)
+    {
+      aRealColor /= static_cast<Standard_ShortReal> (THE_MAX_INTEGER_COLOR_COMPONENT);
+    }
+    theColor = Quantity_ColorRGBA (aRealColor);
+    return true;
+  }
+
+  //! Parses an array of strings and get a real color (only values within range 0.0 .. 1.0 are allowed)
+  //! @param theNumberOfColorComponents the number of color components
+  //! @param theColorComponentStrings the array of strings representing color components
+  //! @param theColor a color that is a result of parsing
+  //! @return true if parsing was successful, or false otherwise
+  static bool parseRealColor (Standard_Integer&        theNumberOfColorComponents,
+                              const char* const* const theColorComponentStrings,
+                              Quantity_ColorRGBA&      theColor)
+  {
+    Graphic3d_Vec4 aRealColor (THE_MAX_REAL_COLOR_COMPONENT);
+    if (!parseNumericalColor (theNumberOfColorComponents, theColorComponentStrings, aRealColor))
+    {
+      return false;
+    }
+    theColor = Quantity_ColorRGBA (aRealColor);
+    return true;
+  }
+
+} // namespace
+
 //=======================================================================
-//function : GetColorFromName
-//purpose  : get the Quantity_NameOfColor from a string
+// function : GetColorFromName
+// purpose  : get the Quantity_NameOfColor from a string
 //=======================================================================
 
 Quantity_NameOfColor ViewerTest::GetColorFromName (const Standard_CString theName)
@@ -94,67 +254,47 @@ Quantity_NameOfColor ViewerTest::GetColorFromName (const Standard_CString theNam
   return aColor;
 }
 
-
 //=======================================================================
-//function : parseColor
-//purpose  :
+// function : parseColor
+// purpose  :
 //=======================================================================
-Standard_Integer ViewerTest::parseColor (Standard_Integer  theArgNb,
-                                         const char**      theArgVec,
-                                         Quantity_ColorRGBA& theColor,
-                                         bool theToParseAlpha)
+Standard_Integer ViewerTest::parseColor (const Standard_Integer   theArgNb,
+                                         const char* const* const theArgVec,
+                                         Quantity_ColorRGBA&      theColor,
+                                         const bool               theToParseAlpha)
 {
-  Quantity_NameOfColor aColor = Quantity_NOC_BLACK;
-  if (theArgNb >= 1
-   && Quantity_Color::ColorFromName (theArgVec[0], aColor))
+  if ((theArgNb >= 1) && Quantity_ColorRGBA::ColorFromHex (theArgVec[0], theColor, !theToParseAlpha))
+  {
+    return 1;
+  }
+  if (theArgNb >= 1 && Quantity_ColorRGBA::ColorFromName (theArgVec[0], theColor))
   {
-    theColor = Quantity_ColorRGBA (aColor);
-    if (theArgNb >= 2
-     && theToParseAlpha)
+    if (theArgNb >= 2 && theToParseAlpha)
     {
-      const TCollection_AsciiString anAlphaStr (theArgVec[1]);
-      if (anAlphaStr.IsRealValue())
+      const Standard_CString anAlphaStr = theArgVec[1];
+      Standard_ShortReal     anAlphaComponent;
+      if (parseColorComponent (anAlphaStr, anAlphaComponent))
       {
-        float anAlpha = (float )anAlphaStr.RealValue();
-        if (anAlpha < 0.0f || anAlpha > 1.0f)
-        {
-          std::cout << "Syntax error: alpha should be within range 0..1!\n";
-          return 0;
-        }
+        theColor.SetAlpha (anAlphaComponent);
         return 2;
       }
     }
     return 1;
   }
-  else if (theArgNb >= 3)
+  if (theArgNb >= 3)
   {
-    Graphic3d_Vec4 anRgba (0.0f, 0.0f, 0.0f, 1.0f);
-    Standard_Integer aNbComps = Min (theArgNb, theToParseAlpha ? 4 : 3);
-    for (int aCompIter = 0; aCompIter < aNbComps; ++aCompIter)
+    const Standard_Integer aNumberOfColorComponentsToParse = Min (theArgNb, theToParseAlpha ? 4 : 3);
+    Standard_Integer       aNumberOfColorComponentsParsed  = aNumberOfColorComponentsToParse;
+    if (parseIntegerColor (aNumberOfColorComponentsParsed, theArgVec, theColor))
     {
-      const TCollection_AsciiString anRgbaStr (theArgVec[aCompIter]);
-      if (!anRgbaStr.IsRealValue())
-      {
-        if (aCompIter == 3)
-        {
-          anRgba.a() = 1.0f;
-          aNbComps = 3;
-          break;
-        }
-        return 0;
-      }
-
-      anRgba[aCompIter] = (float )anRgbaStr.RealValue();
-      if (anRgba[aCompIter] < 0.0 || anRgba[aCompIter] > 1.0)
-      {
-        std::cout << "Error: RGBA color values should be within range 0..1!\n";
-        return 0;
-      }
+      return aNumberOfColorComponentsParsed;
+    }
+    if (parseRealColor (aNumberOfColorComponentsParsed, theArgVec, theColor))
+    {
+      return aNumberOfColorComponentsParsed;
     }
-    theColor = Quantity_ColorRGBA (anRgba);
-    return aNbComps;
+    return 0;
   }
-
   return 0;
 }