Fix Windows CI

Towards clean

(cherry picked from commit d298681)
Signed-off-by: Doug Walker <[email protected]>

Author: larochj

include/OpenColorIO/OpenColorTransforms.h

@@ -575,18 +575,6 @@ extern OCIOEXPORT bool operator==(const GradingRGBCurve & lhs, const GradingRGBC
 extern OCIOEXPORT bool operator!=(const GradingRGBCurve & lhs, const GradingRGBCurve & rhs);
 extern OCIOEXPORT std::ostream & operator<<(std::ostream &, const GradingRGBCurve &);
 
-struct OCIOEXPORT GradingHueCurves
-{
-   ConstGradingBSplineCurveRcPtr hueHue;
-   ConstGradingBSplineCurveRcPtr hueSat;
-   ConstGradingBSplineCurveRcPtr hueLum;
-   ConstGradingBSplineCurveRcPtr lumSat;
-   ConstGradingBSplineCurveRcPtr satSat;
-   ConstGradingBSplineCurveRcPtr lumLum;
-   ConstGradingBSplineCurveRcPtr satLum;
-   ConstGradingBSplineCurveRcPtr hueFx;
-};
-
 /**
  * A set of HUE/SAT/LUM curves. It is used by GradingHueCurveTransform and can be used as
  * a dynamic property (see \ref DynamicPropertyGradingHueCurve).
@@ -596,7 +584,15 @@ class OCIOEXPORT GradingHueCurve
 public:
     static GradingHueCurveRcPtr Create(GradingStyle style);
     static GradingHueCurveRcPtr Create(const ConstGradingHueCurveRcPtr & rhs);
-    static GradingHueCurveRcPtr Create(const GradingHueCurves & curves);
+    static GradingHueCurveRcPtr Create(
+       ConstGradingBSplineCurveRcPtr hueHue,
+       ConstGradingBSplineCurveRcPtr hueSat,
+       ConstGradingBSplineCurveRcPtr hueLum,
+       ConstGradingBSplineCurveRcPtr lumSat,
+       ConstGradingBSplineCurveRcPtr satSat,
+       ConstGradingBSplineCurveRcPtr lumLum,
+       ConstGradingBSplineCurveRcPtr satLum,
+       ConstGradingBSplineCurveRcPtr hueFx);
 
     virtual GradingHueCurveRcPtr createEditableCopy() const = 0;
     virtual void validate() const = 0;

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurve.cpp

@@ -90,16 +90,24 @@ GradingHueCurveImpl::GradingHueCurveImpl(GradingStyle style)
    }
 }
 
-GradingHueCurveImpl::GradingHueCurveImpl(const GradingHueCurves & curves)
+GradingHueCurveImpl::GradingHueCurveImpl(
+   ConstGradingBSplineCurveRcPtr hueHue,
+   ConstGradingBSplineCurveRcPtr hueSat,
+   ConstGradingBSplineCurveRcPtr hueLum,
+   ConstGradingBSplineCurveRcPtr lumSat,
+   ConstGradingBSplineCurveRcPtr satSat,
+   ConstGradingBSplineCurveRcPtr lumLum,
+   ConstGradingBSplineCurveRcPtr satLum,
+   ConstGradingBSplineCurveRcPtr hueFx)
 {
-    m_curves[HUE_HUE] = curves.hueHue->createEditableCopy();
-    m_curves[HUE_SAT] = curves.hueSat->createEditableCopy();
-    m_curves[HUE_LUM] = curves.hueLum->createEditableCopy();
-    m_curves[LUM_SAT] = curves.lumSat->createEditableCopy();
-    m_curves[SAT_SAT] = curves.satSat->createEditableCopy();
-    m_curves[LUM_LUM] = curves.lumLum->createEditableCopy();
-    m_curves[SAT_LUM] = curves.satLum->createEditableCopy();
-    m_curves[HUE_FX] = curves.hueFx->createEditableCopy();
+    m_curves[HUE_HUE] = hueHue->createEditableCopy();
+    m_curves[HUE_SAT] = hueSat->createEditableCopy();
+    m_curves[HUE_LUM] = hueLum->createEditableCopy();
+    m_curves[LUM_SAT] = lumSat->createEditableCopy();
+    m_curves[SAT_SAT] = satSat->createEditableCopy();
+    m_curves[LUM_LUM] = lumLum->createEditableCopy();
+    m_curves[SAT_LUM] = satLum->createEditableCopy();
+    m_curves[HUE_FX] = hueFx->createEditableCopy();
 }
 
 GradingHueCurveImpl::GradingHueCurveImpl(const ConstGradingHueCurveRcPtr & rhs)
@@ -227,9 +235,25 @@ GradingHueCurveRcPtr GradingHueCurve::Create(const ConstGradingHueCurveRcPtr & r
     return res;
 }
 
-GradingHueCurveRcPtr GradingHueCurve::Create(const GradingHueCurves & curves)
+GradingHueCurveRcPtr GradingHueCurve::Create(
+   ConstGradingBSplineCurveRcPtr hueHue,
+   ConstGradingBSplineCurveRcPtr hueSat,
+   ConstGradingBSplineCurveRcPtr hueLum,
+   ConstGradingBSplineCurveRcPtr lumSat,
+   ConstGradingBSplineCurveRcPtr satSat,
+   ConstGradingBSplineCurveRcPtr lumLum,
+   ConstGradingBSplineCurveRcPtr satLum,
+   ConstGradingBSplineCurveRcPtr hueFx)
 {
-    auto newCurve = std::make_shared<GradingHueCurveImpl>(curves);
+    auto newCurve = std::make_shared<GradingHueCurveImpl>(
+       hueHue,
+       hueSat,
+       hueLum,
+       lumSat,
+       satSat,
+       lumLum,
+       satLum,
+       hueFx);
     GradingHueCurveRcPtr res = newCurve;
     return res;
 }

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurve.h

@@ -21,7 +21,15 @@ class GradingHueCurveImpl : public GradingHueCurve
 public:
     GradingHueCurveImpl();
     GradingHueCurveImpl(GradingStyle style);
-    GradingHueCurveImpl(const GradingHueCurves & curves );
+    GradingHueCurveImpl(
+      ConstGradingBSplineCurveRcPtr hueHue,
+      ConstGradingBSplineCurveRcPtr hueSat,
+      ConstGradingBSplineCurveRcPtr hueLum,
+      ConstGradingBSplineCurveRcPtr lumSat,
+      ConstGradingBSplineCurveRcPtr satSat,
+      ConstGradingBSplineCurveRcPtr lumLum,
+      ConstGradingBSplineCurveRcPtr satLum,
+      ConstGradingBSplineCurveRcPtr hueFx );
     GradingHueCurveImpl(const ConstGradingHueCurveRcPtr & rhs);
 
     GradingHueCurveRcPtr createEditableCopy() const override;

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurveOpData.cpp

@@ -5,6 +5,8 @@
 
 #include <OpenColorIO/OpenColorIO.h>
 
+#include <iostream>
+
 #include "ops/gradinghuecurve/GradingHueCurve.h"
 #include "ops/gradinghuecurve/GradingHueCurveOpData.h"
 #include "Platform.h"
@@ -35,12 +37,27 @@ GradingHueCurveOpData::GradingHueCurveOpData(const GradingHueCurveOpData & rhs)
     *this = rhs;
 }
 
-GradingHueCurveOpData::GradingHueCurveOpData(GradingStyle style, 
-                               const GradingHueCurves & curves)
+GradingHueCurveOpData::GradingHueCurveOpData(GradingStyle style,                     
+   ConstGradingBSplineCurveRcPtr hueHue,
+   ConstGradingBSplineCurveRcPtr hueSat,
+   ConstGradingBSplineCurveRcPtr hueLum,
+   ConstGradingBSplineCurveRcPtr lumSat,
+   ConstGradingBSplineCurveRcPtr satSat,
+   ConstGradingBSplineCurveRcPtr lumLum,
+   ConstGradingBSplineCurveRcPtr satLum,
+   ConstGradingBSplineCurveRcPtr hueFx)
     : OpData()
     , m_style(style)
 {
-    ConstGradingHueCurveRcPtr hueCurve = GradingHueCurve::Create(curves);
+    ConstGradingHueCurveRcPtr hueCurve = GradingHueCurve::Create(
+       hueHue,
+       hueSat,
+       hueLum,
+       lumSat,
+       satSat,
+       lumLum,
+       satLum,
+       hueFx);
     m_value = std::make_shared<DynamicPropertyGradingHueCurveImpl>(hueCurve, false);
 }
 

src/OpenColorIO/ops/gradinghuecurve/GradingHueCurveOpData.h

@@ -26,7 +26,14 @@ class GradingHueCurveOpData : public OpData
     GradingHueCurveOpData(GradingStyle style);
     GradingHueCurveOpData(const GradingHueCurveOpData & rhs);
     GradingHueCurveOpData(GradingStyle style,
-                   const GradingHueCurves & curve);
+       ConstGradingBSplineCurveRcPtr hueHue,
+       ConstGradingBSplineCurveRcPtr hueSat,
+       ConstGradingBSplineCurveRcPtr hueLum,
+       ConstGradingBSplineCurveRcPtr lumSat,
+       ConstGradingBSplineCurveRcPtr satSat,
+       ConstGradingBSplineCurveRcPtr lumLum,
+       ConstGradingBSplineCurveRcPtr satLum,
+       ConstGradingBSplineCurveRcPtr hueFx);
     GradingHueCurveOpData & operator=(const GradingHueCurveOpData & rhs);
     virtual ~GradingHueCurveOpData();
 

src/OpenColorIO/ops/gradingrgbcurve/GradingBSplineCurve.cpp

@@ -170,19 +170,19 @@ float CalcKsi(unsigned i,
 
 //------------------------------------------------------------------------------------------------
 //
-void FitHueSpline(const std::vector<GradingControlPoint>& outCtrlPnts,
+void FitHueSpline(const std::vector<GradingControlPoint>& ctrlPnts,
                   const std::vector<float>& slopes,
                   std::vector<float>& knots,
                   std::vector<float>& coefsA,
                   std::vector<float>& coefsB,
                   std::vector<float>& coefsC)
 {
-    knots.push_back( outCtrlPnts[0].m_x );
-    unsigned numCtrlPnts = outCtrlPnts.size();
+    knots.push_back( ctrlPnts[0].m_x );
+    size_t numCtrlPnts = ctrlPnts.size();
     for (unsigned i = 0; i < numCtrlPnts - 1; ++i)
     {
-        const GradingControlPoint& p0 = outCtrlPnts[i];
-        const GradingControlPoint& p1 = outCtrlPnts[i + 1];
+        const GradingControlPoint& p0 = ctrlPnts[i];
+        const GradingControlPoint& p1 = ctrlPnts[i + 1];
 
         const float dx = p1.m_x - p0.m_x;
         const float secantSlope = (p1.m_y - p0.m_y) / dx;
@@ -196,7 +196,7 @@ void FitHueSpline(const std::vector<GradingControlPoint>& outCtrlPnts,
         else
         {
             // Calculate the middle knot.
-            const float ksi = CalcKsi(i, outCtrlPnts, slopes);
+            const float ksi = CalcKsi(i, ctrlPnts, slopes);
 
             // Calculate the coefficients.
             const float m_bar = (2.f * secantSlope - slopes[i + 1]) +
@@ -217,19 +217,19 @@ void FitHueSpline(const std::vector<GradingControlPoint>& outCtrlPnts,
 
 //------------------------------------------------------------------------------------------------
 //
-void EstimateHueSlopes(std::vector<GradingControlPoint>& outCtrlPnts,
+void EstimateHueSlopes(const std::vector<GradingControlPoint>& ctrlPnts,
                        std::vector<float>& slopes,
                        bool isPeriodic,
                        bool isHorizontal)
 {
     slopes.clear();
-    unsigned numCtrlPnts = outCtrlPnts.size();
+    size_t numCtrlPnts = ctrlPnts.size();
     std::vector<float> secantSlope;
     std::vector<float> secantLen;
     for (unsigned i = 0; i < numCtrlPnts - 1; ++i)
     {
-        const GradingControlPoint& p0 = outCtrlPnts[i];
-        const GradingControlPoint& p1 = outCtrlPnts[i + 1];
+        const GradingControlPoint& p0 = ctrlPnts[i];
+        const GradingControlPoint& p1 = ctrlPnts[i + 1];
 
         const float del_x = p1.m_x - p0.m_x;  // PrepHueCurveData ensures this is > 0
         const float del_y = p1.m_y - p0.m_y;
@@ -653,20 +653,20 @@ bool GradingBSplineCurveImpl::isIdentity() const
     bool isIdentity = true;
     if( m_curveType == DIAGONAL_B_SPLINE || m_curveType == B_SPLINE || m_curveType == HUE_HUE_B_SPLINE )
     {    
-       isIdentity = std::all_of(m_controlPoints.begin(), 
-                                m_controlPoints.end(), 
+       isIdentity = std::all_of(m_controlPoints.cbegin(), 
+                                m_controlPoints.cend(), 
                                 [](const GradingControlPoint& cp) { return cp.m_x == cp.m_y; });
     } 
     else if( m_curveType == PERIODIC_0_B_SPLINE )
     {
-       isIdentity = std::all_of(m_controlPoints.begin(), 
-                                m_controlPoints.end(), 
+       isIdentity = std::all_of(m_controlPoints.cbegin(), 
+                                m_controlPoints.cend(), 
                                 [](const GradingControlPoint& cp) { return cp.m_y == 0.f; });
     } 
     else if( m_curveType == HORIZONTAL1_B_SPLINE || m_curveType == PERIODIC_1_B_SPLINE )
     {
-       isIdentity = std::all_of(m_controlPoints.begin(), 
-                                m_controlPoints.end(), 
+       isIdentity = std::all_of(m_controlPoints.cbegin(), 
+                                m_controlPoints.cend(), 
                                 [](const GradingControlPoint& cp) { return cp.m_y == 1.f; });
     } else
     {
@@ -804,6 +804,12 @@ void GradingBSplineCurveImpl::computeKnotsAndCoefsForHueCurve(KnotsCoefs & knots
     {
         // If the user-supplied slopes are non-zero, use those.
         slopes = m_slopesArray;
+        
+        // We need to ensure equal number of slopes and control points for the spline fit.
+        while(slopes.size() < resultCtrlPnts.size())
+        {
+            slopes.push_back(0.0f);
+        }
     }
     else
     {

tests/cpu/ops/gradinghuecurve/GradingHueCurveOpData_tests.cpp

@@ -123,25 +123,22 @@ OCIO_ADD_TEST(GradingHueCurveOpData, validate)
 
     // Curves with a single control point are not valid.
     auto curve = OCIO::GradingBSplineCurve::Create(1);
-    OCIO::GradingHueCurves curvesStruct{curve, curve, curve, curve, curve, curve, curve, curve};
-    auto curves = OCIO::GradingHueCurve::Create(curvesStruct);
+    auto curves = OCIO::GradingHueCurve::Create(curve, curve, curve, curve, curve, curve, curve, curve);
     OCIO_CHECK_THROW_WHAT(gc.setValue(curves), OCIO::Exception,
                           "There must be at least 2 control points.");
 
     // Curve x coordinates have to increase.
     curve = OCIO::GradingBSplineCurve::Create({ { 0.f,0.f },{ 0.7f,0.3f },
                                                 { 0.5f,0.7f },{ 1.f,1.f } });
 
-    curvesStruct = OCIO::GradingHueCurves{curve, curve, curve, curve, curve, curve, curve, curve};
-    curves = OCIO::GradingHueCurve::Create(curvesStruct);
+    curves = OCIO::GradingHueCurve::Create(curve, curve, curve, curve, curve, curve, curve, curve);
     OCIO_CHECK_THROW_WHAT(gc.setValue(curves), OCIO::Exception,
                           "has a x coordinate '0.5' that is less from previous control "
                           "point x cooordinate '0.7'.");
 
     // Fix the curve x coordinate.
     curve->getControlPoint(1).m_x = 0.3f;
-    curvesStruct = OCIO::GradingHueCurves{curve, curve, curve, curve, curve, curve, curve, curve};
-    curves = OCIO::GradingHueCurve::Create(curvesStruct);
+    curves = OCIO::GradingHueCurve::Create(curve, curve, curve, curve, curve, curve, curve, curve);
     OCIO_CHECK_NO_THROW(gc.setValue(curves));
     OCIO_CHECK_NO_THROW(gc.validate());
 }