Difference between revisions of "Color Model HSV"

From The Foundry MODO SDK wiki
Jump to: navigation, search
Line 369: Line 369:
 
         bool withHexPrefix = false)
 
         bool withHexPrefix = false)
 
{
 
{
        ostrstream os;
+
      ...
        string result;
+
 
+
        if (asHexadecimal) {
+
                os << hex;
+
        }
+
 
+
        if (padding) {
+
                unsigned padThreshold = static_cast<unsigned>(powf(
+
                        10, static_cast<float>(padding)));
+
                while ((value < padThreshold)) {
+
                        os << 0;
+
                        padThreshold /= 10;
+
                        if (padThreshold == 1) {
+
                                break;
+
                        }
+
                }
+
        }
+
 
+
        os << value << ends;
+
 
+
        if (asHexadecimal && withHexPrefix) {
+
                result = string("0x");
+
        }
+
        result += os.str ();
+
 
+
        return result;
+
 
}
 
}
  
Line 421: Line 395:
 
         float *hsv)
 
         float *hsv)
 
{
 
{
         float min, max, delta;
+
         ...
 
+
        min = LXxMIN (LXxMIN (_R, _G), _B);
+
        max = LXxMAX (LXxMAX (_R, _G), _B);
+
        delta = max - min;
+
 
+
        _V = max;
+
        if (max) {
+
                _S = delta / max;
+
                if (delta) {
+
                        if (_R == max) {
+
                                _H = (_G - _B) / delta; // between yellow and magenta
+
                        }
+
                        else if (_G == max) {
+
                                _H = (_B - _R) / delta + 2.0f; // between cyan and yellow
+
                        }
+
                        else {
+
                                _H = (_R - _G) / delta + 4.0f; // between magenta and cyan
+
                        }
+
                }
+
                else {
+
                        _H = 0;
+
                }
+
 
+
                _H *= (float) (PI / 3.0f);
+
                if (_H < 0) {
+
                        _H += (float) TWO_PI;
+
                }
+
        }
+
        else {
+
                _S = 0.0;
+
                _H = 0.0; // black: hue undefined, so make it red
+
        }
+
 
}
 
}
  
Line 464: Line 406:
 
         float *rgb)
 
         float *rgb)
 
{
 
{
        float h, f, p, q, t;
+
      ...
        int i;
+
 
+
        if (_S < FLT_EPSILON) {
+
                _R = _G = _B = _V; // grey
+
                return;
+
        }
+
 
+
        h = _H;
+
        if (h == TWO_PI) {
+
                h = 0;
+
        }
+
        f = (float)(_H / THIRD_PI); // f now in [0, 6]
+
 
+
        i = static_cast<int>(floor (f)); // sector 0 to 5
+
        f = f - i; // factorial part of Hue
+
        p = _V * (1.0f - _S);
+
        q = _V * (1.0f - _S *        f);
+
        t = _V * (1.0f - _S * (1.0f - f));
+
 
+
        switch (i) {
+
            case 0:
+
                _R = _V;
+
                _G =  t;
+
                _B =  p;
+
                break;
+
 
+
            case 1:
+
                _R =  q;
+
                _G = _V;
+
                _B =  p;
+
                break;
+
 
+
            case 2:
+
                _R =  p;
+
                _G = _V;
+
                _B =  t;
+
                break;
+
 
+
            case 3:
+
                _R =  p;
+
                _G =  q;
+
                _B = _V;
+
                break;
+
 
+
            case 4:
+
                _R =  t;
+
                _G =  p;
+
                _B = _V;
+
                break;
+
 
+
            default:
+
                _R = _V;
+
                _G =  p;
+
                _B =  q;
+
                break;
+
        }
+
 
}
 
}
 
</pre>
 
</pre>
Line 532: Line 418:
 
QueryCommandString (const char *cmdName, const char *argName)
 
QueryCommandString (const char *cmdName, const char *argName)
 
{
 
{
        string value;
+
      ...
 
+
        char textChars[MAX_COMMAND_VALUE_LEN];
+
        CLxCommandQuery cmdValue (cmdName);
+
        if (cmdValue.Query (0)) {
+
                const char *valueChars = cmdValue.GetString (
+
                        textChars, MAX_COMMAND_VALUE_LEN);
+
                value = string(valueChars);
+
        }
+
 
+
        return value;
+
 
}
 
}
  
Line 548: Line 424:
 
QueryCommandInt (const char *cmdName, int defaultValue = 0)
 
QueryCommandInt (const char *cmdName, int defaultValue = 0)
 
{
 
{
         int value;
+
         ...
        CLxCommandQuery cmdValue (cmdName);
+
        if (cmdValue.Query (0)) {
+
                value = cmdValue.GetInt ();
+
        }
+
        else {
+
                value = defaultValue;
+
        }
+
 
+
        return value;
+
}
+
  
 
         static double
 
         static double
 
QueryCommandFloat (const char *cmdName, double defaultValue = 0.0)
 
QueryCommandFloat (const char *cmdName, double defaultValue = 0.0)
 
{
 
{
         double value;
+
         ...
        CLxCommandQuery cmdValue (cmdName);
+
        if (cmdValue.Query (0)) {
+
                value = cmdValue.GetFloat ();
+
        }
+
        else {
+
                value = defaultValue;
+
        }
+
 
+
        return value;
+
 
}</pre>
 
}</pre>
  
Line 579: Line 436:
 
  ExecuteCommand (const char *cmdName)
 
  ExecuteCommand (const char *cmdName)
 
  {
 
  {
        CLxUser_CommandService svc;
+
      ...
        CLxLoc_Command updateColorCmd;
+
        if (svc.NewCommand (updateColorCmd, cmdName)) {
+
                updateColorCmd.Execute (0);
+
        }
+
 
  }
 
  }
  
Line 593: Line 446:
 
         HSVColor &baseColor)
 
         HSVColor &baseColor)
 
{
 
{
         bool foundValues = false;
+
         ...
 
+
        for (unsigned index = 0; index < 3; ++index) {
+
                bool foundValue = false;
+
                CLxCommandQuery colorValueQuery("color.value");
+
                CLxUser_Attributes &arg(colorValueQuery.Arguments ());
+
 
+
                /*
+
                * Look up the argument indices.
+
                */
+
                int modelNameArgIndex = arg.FindIndex ("model");
+
                int componentArgIndex = arg.FindIndex ("component");
+
                int valueArgIndex = arg.FindIndex ("value");
+
 
+
                /*
+
                * Set the color model name argument.
+
                */
+
                if (arg.Set (modelNameArgIndex, SERVER_HSV_COLOR_MODEL) &&
+
                    arg.Set (componentArgIndex, static_cast<int>(index))) {
+
                        if (colorValueQuery.Query (valueArgIndex)) {
+
                                baseColor.vec[index] = static_cast<float>(
+
                                        colorValueQuery.GetFloat ());
+
                                foundValue = true;
+
                        }
+
                }
+
 
+
                foundValues = foundValue;
+
                if (!foundValue) {
+
                        break;
+
                }
+
        }
+
 
+
        return foundValues;
+
 
}
 
}
  
Line 632: Line 453:
 
         string &path)
 
         string &path)
 
{
 
{
        bool foundValue = false;
+
      ...
        CLxCommandQuery pathQuery("pbview.currentPath");
+
        CLxUser_Attributes &arg(pathQuery.Arguments ());
+
 
+
        int argIndex = arg.FindIndex ("path");
+
        if (pathQuery.Query (argIndex)) {
+
                pathQuery.GetString (path);
+
                foundValue = !path.empty ();
+
        }
+
 
+
        return foundValue;
+
 
}
 
}
  
Line 655: Line 466:
 
         string &swatchPath)
 
         string &swatchPath)
 
{
 
{
        CLxUser_CommandService cmdSvc;
+
      ...
        CLxLoc_Command presetSaveWithModelCmd;
+
        if (cmdSvc.NewCommand (presetSaveWithModelCmd, "color.presetSaveWithModel")) {
+
                CLxUser_Attributes arg;
+
                arg.set (presetSaveWithModelCmd);
+
 
+
                /*
+
                * Generate unique file names for successive
+
                * calls, by scanning for unique indices.
+
                */
+
                bool uniqueFileName;
+
                const char* BASE_COLOR_FILE_NAME = "color";
+
                const char* LXsCOLOR_PRESET_FILE_EXTENSION = ".lxc";
+
                const unsigned FILE_NAME_PADDING = 7;
+
                const unsigned maxIndex = static_cast<unsigned>(powf (
+
                        10, static_cast<float>(FILE_NAME_PADDING)));
+
                string fullPath;
+
                for (unsigned index = swatchIndex; index <= maxIndex; ++index) {
+
                        /*
+
                        * File names are formatted as "color00001.lxc".
+
                        */
+
                        string fileName = string(BASE_COLOR_FILE_NAME) +
+
                                IntegerToString(
+
                                        index,
+
                                        FILE_NAME_PADDING) +
+
                                string(LXsCOLOR_PRESET_FILE_EXTENSION);
+
 
+
                        /*
+
                        * Concatenate the generated file name to the path.
+
                        */
+
                        CLxUser_FileService fileSvc;
+
                        LxResult result = fileSvc.ComposePath (
+
                                fullPath, fileName, swatchPath);
+
                        if (LXx_OK (result)) {
+
                                /*
+
                                * Test if the file path is unique.
+
                                */
+
                                int fileType;
+
                                result = fileSvc.TestFileType (
+
                                        fullPath, &fileType);
+
                                uniqueFileName = LXx_OK (result) &&
+
                                        (fileType == LXiFILETYPE_NONE);
+
                                if (uniqueFileName) {
+
                                        break;
+
                                }
+
                        }
+
                }
+
 
+
                if (uniqueFileName) {
+
                        /*
+
                        * Look up the argument indices and set their values.
+
                        */
+
                        int filepathArgIndex = arg.FindIndex ("path");
+
                        int modelNameArgIndex = arg.FindIndex ("modelName");
+
                        int c0ArgIndex = arg.FindIndex ("c0");
+
                        int c1ArgIndex = arg.FindIndex ("c1");
+
                        int c2ArgIndex = arg.FindIndex ("c2");
+
                        if ((filepathArgIndex != -1) &&
+
                            (modelNameArgIndex != -1) &&
+
                            (c0ArgIndex != -1) &&
+
                            (c1ArgIndex != -1) &&
+
                            (c2ArgIndex != -1)) {
+
                                if (arg.Set (filepathArgIndex, fullPath.c_str ()) &&
+
                                    arg.Set (modelNameArgIndex, SERVER_HSV_COLOR_MODEL)) {
+
                                        /*
+
                                        * Tell the command to set up
+
                                        * the data types for its
+
                                        * variable arguments.
+
                                        */
+
                                        if (LXx_OK (presetSaveWithModelCmd.ArgSetDatatypes ())) {
+
                                                /*
+
                                                * Set the color component values.
+
                                                */
+
                                                if (arg.Set (c0ArgIndex, hsvColor.vec[0]) &&
+
                                                    arg.Set (c1ArgIndex, hsvColor.vec[1]) &&
+
                                                    arg.Set (c2ArgIndex, hsvColor.vec[2])) {
+
                                                        presetSaveWithModelCmd.Execute (0);
+
                                                }
+
                                        }
+
                                }
+
                        }
+
                }
+
        }
+
 
}</pre>
 
}</pre>
  
Line 749: Line 478:
 
         Metrics &metrics)
 
         Metrics &metrics)
 
{
 
{
        metrics.slice_width = static_cast<float>(sliceWidth);
+
      ...
        metrics.slice_height = static_cast<float>(sliceHeight);
+
 
+
        metrics.wheel_aspect = (metrics.slice_width > metrics.slice_height) ?
+
                WHEEL_ASPECT_HORIZONTAL : WHEEL_ASPECT_VERTICAL;
+
 
+
        unsigned swatchCount = CHSVColorModel::SwatchCount ();
+
        if (swatchCount > 1) {
+
                if (metrics.wheel_aspect == WHEEL_ASPECT_HORIZONTAL) {
+
                        float minSwatchWidth = metrics.slice_width * MINIMUM_SWATCH_SIZE;
+
                        metrics.swatch_width = LXxMAX (
+
                                minSwatchWidth, metrics.slice_width - metrics.slice_height);
+
                        metrics.swatch_height = metrics.slice_height / swatchCount;
+
 
+
                        metrics.wheel_back_width = metrics.slice_width - metrics.swatch_width;
+
                        metrics.wheel_back_height = metrics.slice_height;
+
                }
+
                else {
+
                        float minSwatchHeight = metrics.slice_height * MINIMUM_SWATCH_SIZE;
+
                        metrics.swatch_height = LXxMAX (
+
                                minSwatchHeight, metrics.slice_height - metrics.slice_width);
+
                        metrics.swatch_width = metrics.slice_width / swatchCount;
+
 
+
                        metrics.wheel_back_width = metrics.slice_width;
+
                        metrics.wheel_back_height = metrics.slice_height - metrics.swatch_height;
+
                }
+
        }
+
        else {
+
                metrics.swatch_width = 0;
+
                metrics.swatch_height = 0;
+
                metrics.wheel_back_width = metrics.slice_width;
+
                metrics.wheel_back_height = metrics.slice_height;
+
        }
+
       
+
        if (metrics.wheel_back_width < metrics.wheel_back_height) {
+
                metrics.wheel_radius = metrics.wheel_back_width * 0.5f;
+
        }
+
        else {
+
                metrics.wheel_radius = metrics.wheel_back_height * 0.5f;
+
        }
+
 
+
        metrics.wheel_radius -= HUE_WHEEL_MARGIN;
+
 
+
        metrics.wheel_centerX = metrics.wheel_back_width * 0.5f;
+
        metrics.wheel_centerY = metrics.wheel_back_height * 0.5f;
+
 
}</pre>
 
}</pre>
  
Line 810: Line 495:
 
         LXtFVector hsv)
 
         LXtFVector hsv)
 
{
 
{
         bool trackingSwatch = false;
+
         ...
 
+
        if ((xAxis == 0) &&
+
            CHSVColorModel::HueAsWheel () &&
+
            (CHSVColorModel::Rule () != HSV_RULE_SOLO)) {
+
                if (metrics.wheel_aspect == WHEEL_ASPECT_VERTICAL) {
+
                        trackingSwatch = imageY > metrics.wheel_back_height;
+
                }
+
                else {
+
                        trackingSwatch = imageX > metrics.wheel_back_width;
+
                }
+
 
+
                if (trackingSwatch) {
+
                        HSVColor baseColor;
+
                        LXx_VCPY (baseColor.vec, downVec);
+
                        std::vector<HSVColor> swatchColors;
+
                        unsigned baseColorIndex;
+
                        CHSVColorModel::BuildSwatches (
+
                                baseColor, swatchColors, baseColorIndex);
+
 
+
                        unsigned swatchIndex;
+
                        if (metrics.wheel_aspect == WHEEL_ASPECT_VERTICAL) {
+
                                swatchIndex = static_cast<unsigned>(
+
                                        static_cast<float>(imageX) / metrics.swatch_width);
+
                        }
+
                        else {
+
                                swatchIndex = static_cast<unsigned>(
+
                                        static_cast<float>(imageY) / metrics.swatch_height);
+
                        }
+
                        swatchIndex = LXxMIN (
+
                                swatchIndex,
+
                                static_cast<unsigned>(swatchColors.size () - 1));
+
 
+
                        LXx_VCPY (hsv, swatchColors[swatchIndex].vec);
+
                }
+
        }
+
 
+
        return trackingSwatch;
+
 
}</pre>
 
}</pre>
  
Line 855: Line 503:
 
HueRGBtoRYB (float hue)
 
HueRGBtoRYB (float hue)
 
{
 
{
         float newHue;
+
         ...
 
+
        float hueRGB[9] = {0, 30 * DEG2RADF, 60 * DEG2RADF, 90 * DEG2RADF, 120 * DEG2RADF, 150 * DEG2RADF, 180 * DEG2RADF, 210 * DEG2RADF, 240 * DEG2RADF};
+
        float hueRYB[9] = {0, 15 * DEG2RADF, 30 * DEG2RADF, 45 * DEG2RADF,  60 * DEG2RADF,  90 * DEG2RADF, 120 * DEG2RADF, 180 * DEG2RADF, 240 * DEG2RADF};
+
 
+
        unsigned index = static_cast<unsigned>(hue / SIXTH_PI);
+
        if (index < 8) {
+
                float low, hi, t;
+
 
+
                low = hueRGB[index];
+
                hi = hueRGB[index + 1];
+
                t = (hue - low) / (hi - low);
+
 
+
                low = hueRYB[index];
+
                hi = hueRYB[index + 1];
+
 
+
                newHue = LERP (t, low, hi);
+
        }
+
        else {
+
                newHue = hue;
+
        }
+
 
+
        return newHue;
+
 
}
 
}
  
Line 886: Line 512:
 
HueRYBtoRGB (float hue)
 
HueRYBtoRGB (float hue)
 
{
 
{
        float newHue;
+
      ...
 
+
        float hueRYB[9] = {0, 15 * DEG2RADF, 30 * DEG2RADF, 45 * DEG2RADF,  60 * DEG2RADF,  90 * DEG2RADF, 120 * DEG2RADF, 180 * DEG2RADF, 240 * DEG2RADF};
+
        float hueRGB[9] = {0, 30 * DEG2RADF, 60 * DEG2RADF, 90 * DEG2RADF, 120 * DEG2RADF, 150 * DEG2RADF, 180 * DEG2RADF, 210 * DEG2RADF, 240 * DEG2RADF};
+
 
+
        bool convert = false;
+
        unsigned index;
+
        for (index = 0; index < 8; ++index) {
+
                if (hue >= hueRYB[index] && hue <= hueRYB[index + 1]) {
+
                        convert = true;
+
                        break;
+
                }
+
        }
+
        if (convert) {
+
                float low, hi, t;
+
 
+
                low = hueRYB[index];
+
                hi = hueRYB[index + 1];
+
                t = (hue - low) / (hi - low);
+
 
+
                low = hueRGB[index];
+
                hi = hueRGB[index + 1];
+
 
+
                newHue = LERP (t, low, hi);
+
        }
+
        else {
+
                newHue = hue;
+
        }
+
 
+
        return newHue;
+
 
}</pre>
 
}</pre>
  
Line 924: Line 521:
 
  struct CHSVColorModelPersist
 
  struct CHSVColorModelPersist
 
  {
 
  {
         CLxUser_PersistentEntry hue_as_wheel;
+
         ...
        CLxUser_PersistentEntry wheel;
+
        CLxUser_PersistentEntry rule;
+
        CLxUser_PersistentEntry rule_adjust_complementary;
+
        CLxUser_PersistentEntry rule_adjust_analogous;
+
        CLxUser_PersistentEntry rule_adjust_triadic;
+
        CLxUser_PersistentEntry rule_adjust_tetradic;
+
        CLxUser_PersistentEntry rule_adjust_compound;
+
        CLxUser_PersistentEntry m_levels;
+
+
        CLxUser_Attributes hue_as_wheel_value;
+
        CLxUser_Attributes wheel_value;
+
        CLxUser_Attributes rule_value;
+
        CLxUser_Attributes rule_adjust_value_complementary;
+
        CLxUser_Attributes rule_adjust_value_analogous;
+
        CLxUser_Attributes rule_adjust_value_triadic;
+
        CLxUser_Attributes rule_adjust_value_tetradic;
+
        CLxUser_Attributes rule_adjust_value_compound;
+
        CLxUser_Attributes levels_value;
+
 
  };
 
  };
  
Line 950: Line 529:
 
class CHSVColorModelPersistVisitor : public CLxImpl_AbstractVisitor
 
class CHSVColorModelPersistVisitor : public CLxImpl_AbstractVisitor
 
{
 
{
     public:
+
     ...
        virtual ~CHSVColorModelPersistVisitor () {}
+
        LxResult Evaluate ();
+
 
};
 
};
  
Line 968: Line 545:
 
CHSVColorModelPersistVisitor::Evaluate ()
 
CHSVColorModelPersistVisitor::Evaluate ()
 
{
 
{
        CLxUser_PersistenceService srv;
+
      ...
 
+
        // Hue as Wheel.
+
        srv.Start (ATOM_TAG_HUE_AS_WHEEL, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_BOOLEAN);
+
        srv.EndDef (persist->hue_as_wheel);
+
 
+
        persist->hue_as_wheel_value.set (persist->hue_as_wheel);
+
 
+
        // Wheel.
+
        srv.Start (ATOM_TAG_WHEEL, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_INTEGER);
+
        srv.EndDef (persist->wheel);
+
 
+
        persist->wheel_value.set (persist->wheel);
+
 
+
        // Rule.
+
        srv.Start (ATOM_TAG_RULE, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_INTEGER);
+
        srv.EndDef (persist->rule);
+
 
+
        persist->rule_value.set (persist->rule);
+
 
+
        // Rule Adjust Complementary.
+
        srv.Start (ATOM_TAG_RULE_ADJUST_COMPLEMENTARY, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_ANGLE);
+
        srv.EndDef (persist->rule_adjust_complementary);
+
 
+
        persist->rule_adjust_value_complementary.set (persist->rule_adjust_complementary);
+
 
+
        // Rule Adjust Analogous.
+
        srv.Start (ATOM_TAG_RULE_ADJUST_ANALOGOUS, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_ANGLE);
+
        srv.EndDef (persist->rule_adjust_analogous);
+
 
+
        persist->rule_adjust_value_analogous.set (persist->rule_adjust_analogous);
+
 
+
        // Rule Adjust Triadic.
+
        srv.Start (ATOM_TAG_RULE_ADJUST_TRIADIC, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_ANGLE);
+
        srv.EndDef (persist->rule_adjust_triadic);
+
 
+
        persist->rule_adjust_value_triadic.set (persist->rule_adjust_triadic);
+
 
+
        // Rule Adjust Tetradic.
+
        srv.Start (ATOM_TAG_RULE_ADJUST_TETRADIC, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_ANGLE);
+
        srv.EndDef (persist->rule_adjust_tetradic);
+
 
+
        persist->rule_adjust_value_tetradic.set (persist->rule_adjust_tetradic);
+
 
+
        // Rule Adjust Compound.
+
        srv.Start (ATOM_TAG_RULE_ADJUST_COMPOUND, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_ANGLE);
+
        srv.EndDef (persist->rule_adjust_compound);
+
 
+
        persist->rule_adjust_value_compound.set (persist->rule_adjust_compound);
+
 
+
        // Levels.
+
        srv.Start (ATOM_TAG_LEVELS, LXi_PERSIST_ATOM);
+
        srv.AddValue (LXsTYPE_INTEGER);
+
        srv.EndDef (persist->m_levels);
+
 
+
        persist->levels_value.set (persist->m_levels);
+
 
+
        return LXe_OK;
+
 
}</pre>
 
}</pre>
  
Line 1,056: Line 568:
 
CHSVColorModelNotifier::cn_Flags (int code)
 
CHSVColorModelNotifier::cn_Flags (int code)
 
{
 
{
         return LXfCMDNOTIFY_DISABLE | LXfCMDNOTIFY_VALUE;
+
         ...
 
}</pre>
 
}</pre>
  
Line 1,067: Line 579:
 
enum
 
enum
 
{
 
{
        HUE_AS_WHEEL_HSV_COLOR_MODEL_VALUE
+
      ...
 
};
 
};
  
Line 1,074: Line 586:
 
CHueAsWheelHSVColorModelCommand::CHueAsWheelHSVColorModelCommand ()
 
CHueAsWheelHSVColorModelCommand::CHueAsWheelHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_BOOLEAN);
+
         ...
 
+
        basic_SetFlags (HUE_AS_WHEEL_HSV_COLOR_MODEL_VALUE, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,082: Line 592:
 
CHueAsWheelHSVColorModelCommand::basic_CmdFlags ()
 
CHueAsWheelHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
         return LXfCMD_UI;
+
         ...
 
}
 
}
  
Line 1,091: Line 601:
 
         string &args)
 
         string &args)
 
{
 
{
         bool result;
+
         ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,110: Line 607:
 
CHueAsWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CHueAsWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
         /*
+
         ...
        * Enable if the strip is not set to the hue axis.
+
        */
+
        return !CHSVColorModel::HueAxisOnStrip ();
+
 
}
 
}
  
 
enum
 
enum
 
{
 
{
        NOTIFICATION_HUE_AS_WHEEL,
+
      ...
        NOTIFICATION_RULE
+
 
};
 
};
  
Line 1,125: Line 618:
 
CHueAsWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CHueAsWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
         bool hueAsWheel = PRESET_HSV_HUE_AS_WHEEL;
+
         ...
        if (dyna_IsSet (0)) {
+
                attr_GetBool (HUE_AS_WHEEL_HSV_COLOR_MODEL_VALUE, &hueAsWheel);
+
        }
+
 
+
        LxResult result = persist->hue_as_wheel.Append ();
+
        if (LXx_OK (result) &&
+
            persist->hue_as_wheel_value.Set (0, hueAsWheel)) {
+
 
+
                CLxCommandNotifier::Notify (HSV_COLOR_MODEL_NOTIFIER, 0);
+
 
+
                basic_Message().SetCode (LXe_OK);
+
 
+
                ExecuteCommand (LXsCOMMAND_COLOR_UPDATE_VIEW);
+
        }
+
 
}
 
}
  
Line 1,145: Line 624:
 
CHueAsWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
CHueAsWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
{
 
{
        CLxUser_ValueArray  vals (vaQuery);
+
      ...
 
+
        return vals.Add (CHSVColorModel::HueAsWheel ()) ? LXe_OK : LXe_NOTFOUND;
+
 
}</pre>
 
}</pre>
  
Line 1,155: Line 632:
 
enum
 
enum
 
{
 
{
        WHEEL_HSV_COLOR_MODEL_VALUE
+
      ...
 
};
 
};
  
Line 1,161: Line 638:
  
 
static LXtTextValueHint hint_hsvWheel[] = {
 
static LXtTextValueHint hint_hsvWheel[] = {
         HSV_WHEEL_RGB, "rgb",
+
         ...
        HSV_WHEEL_RYB, "ryb",
+
        -1, NULL
+
 
         };
 
         };
  
 
CWheelHSVColorModelCommand::CWheelHSVColorModelCommand ()
 
CWheelHSVColorModelCommand::CWheelHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_INTEGER);
+
         ...
        dyna_SetHint (0, hint_hsvWheel);
+
 
+
        basic_SetFlags (WHEEL_HSV_COLOR_MODEL_VALUE, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,177: Line 649:
 
CWheelHSVColorModelCommand::basic_CmdFlags ()
 
CWheelHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
        return LXfCMD_UI;
+
      ...
 
}
 
}
  
Line 1,186: Line 658:
 
         string &args)
 
         string &args)
 
{
 
{
        bool result;
+
      ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,205: Line 664:
 
CWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
        return CHSVColorModel::HueAsWheel () &&
+
      ...
              !CHSVColorModel::HueAxisOnStrip ();
+
 
}
 
}
  
Line 1,212: Line 670:
 
CWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
         int wheel = PRESET_HSV_WHEEL;
+
         ...
        if (dyna_IsSet (0)) {
+
                attr_GetInt (WHEEL_HSV_COLOR_MODEL_VALUE, &wheel);
+
        }
+
 
+
        LxResult result = persist->wheel.Append ();
+
        if (LXx_OK (result) &&
+
            persist->wheel_value.Set (0, wheel)) {
+
 
+
                CLxCommandNotifier::Notify (HSV_COLOR_MODEL_NOTIFIER, 0);
+
 
+
                basic_Message().SetCode (LXe_OK);
+
 
+
                ExecuteCommand (LXsCOMMAND_COLOR_UPDATE_VIEW);
+
        }
+
 
}
 
}
  
Line 1,232: Line 676:
 
CWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
CWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
{
 
{
        int wheel = persist->wheel_value.Int (0, PRESET_HSV_WHEEL);
+
      ...
 
+
        CLxUser_ValueArray  vals (vaQuery);
+
 
+
        return vals.Add (wheel) ? LXe_OK : LXe_NOTFOUND;
+
 
}
 
}
  
Line 1,253: Line 693:
 
enum
 
enum
 
{
 
{
         RULE_HSV_COLOR_MODEL_VALUE
+
         ...
 
};
 
};
  
Line 1,259: Line 699:
  
 
static LXtTextValueHint hint_hsvRule[] = {
 
static LXtTextValueHint hint_hsvRule[] = {
         HSV_RULE_SOLO, "solo",
+
         ...
        HSV_RULE_COMPLEMENTARY, "complementary",
+
        HSV_RULE_ANALOGOUS, "analogous",
+
        HSV_RULE_TRIADIC, "triadic",
+
        HSV_RULE_TETRADIC, "tetradic",
+
        HSV_RULE_COMPOUND, "compound",
+
        HSV_RULE_TINTS, "tints",
+
        HSV_RULE_SHADES, "shades",
+
        -1, NULL
+
 
         };
 
         };
  
 
CRuleHSVColorModelCommand::CRuleHSVColorModelCommand ()
 
CRuleHSVColorModelCommand::CRuleHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_INTEGER);
+
         ...
        dyna_SetHint (0, hint_hsvRule);
+
 
+
        basic_SetFlags (RULE_HSV_COLOR_MODEL_VALUE, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,281: Line 710:
 
CRuleHSVColorModelCommand::basic_CmdFlags ()
 
CRuleHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
         return LXfCMD_UI;
+
         ...
 
}
 
}
  
Line 1,290: Line 719:
 
         string &args)
 
         string &args)
 
{
 
{
        bool result;
+
      ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,309: Line 725:
 
CRuleHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CRuleHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
        return CHSVColorModel::HueAsWheel () &&
+
      ...
              !CHSVColorModel::HueAxisOnStrip ();
+
 
}
 
}
  
Line 1,316: Line 731:
 
CRuleHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CRuleHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
         int rule = PRESET_HSV_RULE;
+
         ...
        if (dyna_IsSet (0)) {
+
                attr_GetInt (RULE_HSV_COLOR_MODEL_VALUE, &rule);
+
        }
+
 
+
        LxResult result = persist->rule.Append ();
+
        if (LXx_OK (result) &&
+
            persist->rule_value.Set (0, rule)) {
+
 
+
                CLxCommandNotifier::Notify (HSV_COLOR_MODEL_NOTIFIER, 0);
+
 
+
                basic_Message().SetCode (LXe_OK);
+
 
+
                ExecuteCommand (LXsCOMMAND_COLOR_UPDATE_VIEW);
+
        }
+
 
}
 
}
  
Line 1,338: Line 739:
 
         ILxUnknownID vaQuery)
 
         ILxUnknownID vaQuery)
 
{
 
{
         int rule = persist->rule_value.Int (0, PRESET_HSV_RULE);
+
         ...
 
+
        CLxUser_ValueArray  vals (vaQuery);
+
 
+
        return vals.Add (rule) ? LXe_OK : LXe_NOTFOUND;
+
 
}
 
}
  
Line 1,360: Line 757:
 
enum
 
enum
 
{
 
{
        RULE_ADJUST_HSV_COLOR_MODEL_VALUE
+
      ...
 
};
 
};
  
Line 1,376: Line 773:
 
CRuleAdjustHSVColorModelCommand::CRuleAdjustHSVColorModelCommand ()
 
CRuleAdjustHSVColorModelCommand::CRuleAdjustHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_ANGLE);
+
         ...
 
+
        basic_SetFlags (RULE_ADJUST_HSV_COLOR_MODEL_VALUE, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,384: Line 779:
 
CRuleAdjustHSVColorModelCommand::basic_CmdFlags ()
 
CRuleAdjustHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
         return LXfCMD_UI;
+
         ...
 
}
 
}
  
Line 1,393: Line 788:
 
         string &args)
 
         string &args)
 
{
 
{
        bool result;
+
      ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,412: Line 794:
 
CRuleAdjustHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CRuleAdjustHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
         int rule = CHSVColorModel::Rule ();
+
         ...
 
+
        return CHSVColorModel::HueAsWheel () &&
+
              !CHSVColorModel::HueAxisOnStrip () &&
+
              ((rule != HSV_RULE_TINTS) && (rule != HSV_RULE_SHADES) &&
+
              (rule != HSV_RULE_SOLO));
+
 
}
 
}
  
Line 1,423: Line 800:
 
CRuleAdjustHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CRuleAdjustHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
        double ruleAdjust = CHSVColorModel::PresetRuleAdjust ();
+
      ...
        if (dyna_IsSet (0)) {
+
                attr_GetFlt (RULE_ADJUST_HSV_COLOR_MODEL_VALUE, &ruleAdjust);
+
        }
+
 
+
        LxResult result = LXe_OK;
+
        unsigned rule = CHSVColorModel::Rule ();
+
        switch (rule) {
+
                case HSV_RULE_COMPLEMENTARY:
+
                        result = persist->rule_adjust_complementary.Append ();
+
                        if (LXx_OK (result)) {
+
                                persist->rule_adjust_value_complementary.Set (0, ruleAdjust);
+
                        }
+
                        break;
+
 
+
                case HSV_RULE_ANALOGOUS:
+
                        result = persist->rule_adjust_analogous.Append ();
+
                        if (LXx_OK (result)) {
+
                                persist->rule_adjust_value_analogous.Set (0, ruleAdjust);
+
                        }
+
                        break;
+
 
+
                case HSV_RULE_TRIADIC:
+
                        result = persist->rule_adjust_triadic.Append ();
+
                        if (LXx_OK (result)) {
+
                                persist->rule_adjust_value_triadic.Set (0, ruleAdjust);
+
                        }
+
                        break;
+
 
+
                case HSV_RULE_TETRADIC:
+
                        result = persist->rule_adjust_tetradic.Append ();
+
                        if (LXx_OK (result)) {
+
                                persist->rule_adjust_value_tetradic.Set (0, ruleAdjust);
+
                        }
+
                        break;
+
 
+
                case HSV_RULE_COMPOUND:
+
                        result = persist->rule_adjust_compound.Append ();
+
                        if (LXx_OK (result)) {
+
                                persist->rule_adjust_value_compound.Set (0, ruleAdjust);
+
                        }
+
                        break;
+
        }
+
 
+
        if (LXx_OK (result)) {
+
                basic_Message().SetCode (LXe_OK);
+
 
+
                ExecuteCommand (LXsCOMMAND_COLOR_UPDATE_VIEW);
+
        }
+
 
}
 
}
  
Line 1,479: Line 808:
 
         ILxUnknownID vaQuery)
 
         ILxUnknownID vaQuery)
 
{
 
{
         CLxUser_ValueArray  vals (vaQuery);
+
         ...
 
+
        return vals.Add (CHSVColorModel::RuleAdjust ()) ? LXe_OK : LXe_NOTFOUND;
+
 
}
 
}
  
Line 1,489: Line 816:
 
         CLxUser_UIHints &hints)
 
         CLxUser_UIHints &hints)
 
{
 
{
         // Angles are in radians.
+
         ...
        hints.MinFloat (-PI);
+
        hints.MaxFloat (PI);
+
 
}
 
}
  
Line 1,502: Line 827:
 
enum
 
enum
 
{
 
{
        LEVELS_HSV_COLOR_MODEL_VALUE
+
      ...
 
};
 
};
  
Line 1,509: Line 834:
 
CLevelsHSVColorModelCommand::CLevelsHSVColorModelCommand ()
 
CLevelsHSVColorModelCommand::CLevelsHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_INTEGER);
+
         ...
 
+
        basic_SetFlags (LEVELS_HSV_COLOR_MODEL_VALUE, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,517: Line 840:
 
CLevelsHSVColorModelCommand::basic_CmdFlags ()
 
CLevelsHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
         return LXfCMD_UI;
+
         ...
 
}
 
}
  
Line 1,526: Line 849:
 
         string &args)
 
         string &args)
 
{
 
{
         bool result;
+
         ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,545: Line 855:
 
CLevelsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CLevelsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
        int rule = CHSVColorModel::Rule ();
+
      ...
 
+
        return CHSVColorModel::HueAsWheel () &&
+
              !CHSVColorModel::HueAxisOnStrip () &&
+
              ((rule == HSV_RULE_TINTS) || (rule == HSV_RULE_SHADES));
+
 
}
 
}
  
Line 1,555: Line 861:
 
CLevelsHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CLevelsHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
        int levels = PRESET_HSV_LEVELS;
+
      ...
        if (dyna_IsSet (0)) {
+
                attr_GetInt (LEVELS_HSV_COLOR_MODEL_VALUE, &levels);
+
        }
+
 
+
        LxResult result = persist->m_levels.Append ();
+
        if (LXx_OK (result) &&
+
            persist->levels_value.Set (0, levels)) {
+
 
+
                basic_Message().SetCode (LXe_OK);
+
 
+
                ExecuteCommand (LXsCOMMAND_COLOR_UPDATE_VIEW);
+
        }
+
 
}
 
}
  
Line 1,573: Line 867:
 
CLevelsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
CLevelsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
{
 
{
        CLxUser_ValueArray  vals (vaQuery);
+
      ...
 
+
        return vals.Add (static_cast<int>(CHSVColorModel::Levels ())) ?
+
                LXe_OK : LXe_NOTFOUND;
+
 
}
 
}
  
Line 1,584: Line 875:
 
         CLxUser_UIHints &hints)
 
         CLxUser_UIHints &hints)
 
{
 
{
        hints.MinInt (3);
+
      ...
        hints.MaxInt (21);
+
 
}
 
}
  
Line 1,596: Line 886:
 
enum
 
enum
 
{
 
{
         LEVELS_HSV_COLOR_MODEL_SAVE_AS_PRESETS
+
         ...
 
};
 
};
  
 
CSaveAsPresetsHSVColorModelCommand::CSaveAsPresetsHSVColorModelCommand ()
 
CSaveAsPresetsHSVColorModelCommand::CSaveAsPresetsHSVColorModelCommand ()
 
{
 
{
         dyna_Add ("value",  LXsTYPE_BOOLEAN);
+
         ...
 
+
        basic_SetFlags (LEVELS_HSV_COLOR_MODEL_SAVE_AS_PRESETS, LXfCMDARG_QUERY);
+
 
}
 
}
  
Line 1,609: Line 897:
 
CSaveAsPresetsHSVColorModelCommand::basic_CmdFlags ()
 
CSaveAsPresetsHSVColorModelCommand::basic_CmdFlags ()
 
{
 
{
        return LXfCMD_UI;
+
      ...
 
}
 
}
  
Line 1,618: Line 906:
 
         string &args)
 
         string &args)
 
{
 
{
        bool result;
+
      ...
        if (index == 0) {
+
                name = HSV_COLOR_MODEL_NOTIFIER;
+
                result = true;
+
        }
+
        else if (index == 1) {
+
                name = LXs_NOTIFIER_COLOR_CHANGED;
+
                result = true;
+
        }
+
        else {
+
                result = false;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 1,637: Line 912:
 
CSaveAsPresetsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
CSaveAsPresetsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
 
{
 
{
        return CHSVColorModel::HueAsWheel () &&
+
      ...
              !CHSVColorModel::HueAxisOnStrip ();
+
 
}
 
}
  
Line 1,650: Line 924:
 
         HSVColor &baseColor)
 
         HSVColor &baseColor)
 
{
 
{
         bool foundValues = false;
+
         ...
 
+
        for (unsigned index = 0; index < 3; ++index) {
+
                bool foundValue = false;
+
                CLxCommandQuery colorValueQuery("color.value");
+
                CLxUser_Attributes &arg(colorValueQuery.Arguments ());
+
 
+
                /*
+
                * Look up the argument indices.
+
                */
+
                int modelNameArgIndex = arg.FindIndex ("model");
+
                int componentArgIndex = arg.FindIndex ("component");
+
                int valueArgIndex = arg.FindIndex ("value");
+
 
+
                /*
+
                * Set the color model name argument.
+
                */
+
                if (arg.Set (modelNameArgIndex, SERVER_HSV_COLOR_MODEL) &&
+
                    arg.Set (componentArgIndex, static_cast<int>(index))) {
+
                        if (colorValueQuery.Query (valueArgIndex)) {
+
                                baseColor.vec[index] = static_cast<float>(
+
                                        colorValueQuery.GetFloat ());
+
                                foundValue = true;
+
                        }
+
                }
+
 
+
                foundValues = foundValue;
+
                if (!foundValue) {
+
                        break;
+
                }
+
        }
+
 
+
        return foundValues;
+
 
}
 
}
  
Line 1,689: Line 931:
 
         string &path)
 
         string &path)
 
{
 
{
        bool foundValue = false;
+
      ...
        CLxCommandQuery pathQuery("pbview.currentPath");
+
        CLxUser_Attributes &arg(pathQuery.Arguments ());
+
 
+
        int argIndex = arg.FindIndex ("path");
+
        if (pathQuery.Query (argIndex)) {
+
                pathQuery.GetString (path);
+
                foundValue = !path.empty ();
+
        }
+
 
+
        return foundValue;
+
 
}
 
}
  
Line 1,712: Line 944:
 
         string &swatchPath)
 
         string &swatchPath)
 
{
 
{
        CLxUser_CommandService cmdSvc;
+
      ...
        CLxLoc_Command presetSaveWithModelCmd;
+
        if (cmdSvc.NewCommand (presetSaveWithModelCmd, "color.presetSaveWithModel")) {
+
                CLxUser_Attributes arg;
+
                arg.set (presetSaveWithModelCmd);
+
 
+
                /*
+
                * Generate unique file names for successive
+
                * calls, by scanning for unique indices.
+
                */
+
                bool uniqueFileName;
+
                const char* BASE_COLOR_FILE_NAME = "color";
+
                const char* LXsCOLOR_PRESET_FILE_EXTENSION = ".lxc";
+
                const unsigned FILE_NAME_PADDING = 7;
+
                const unsigned maxIndex = static_cast<unsigned>(powf (
+
                        10, static_cast<float>(FILE_NAME_PADDING)));
+
                string fullPath;
+
                for (unsigned index = swatchIndex; index <= maxIndex; ++index) {
+
                        /*
+
                        * File names are formatted as "color00001.lxc".
+
                        */
+
                        string fileName = string(BASE_COLOR_FILE_NAME) +
+
                                IntegerToString(
+
                                        index,
+
                                        FILE_NAME_PADDING) +
+
                                string(LXsCOLOR_PRESET_FILE_EXTENSION);
+
 
+
                        /*
+
                        * Concatenate the generated file name to the path.
+
                        */
+
                        CLxUser_FileService fileSvc;
+
                        LxResult result = fileSvc.ComposePath (
+
                                fullPath, fileName, swatchPath);
+
                        if (LXx_OK (result)) {
+
                                /*
+
                                * Test if the file path is unique.
+
                                */
+
                                int fileType;
+
                                result = fileSvc.TestFileType (
+
                                        fullPath, &fileType);
+
                                uniqueFileName = LXx_OK (result) &&
+
                                        (fileType == LXiFILETYPE_NONE);
+
                                if (uniqueFileName) {
+
                                        break;
+
                                }
+
                        }
+
                }
+
 
+
                if (uniqueFileName) {
+
                        /*
+
                        * Look up the argument indices and set their values.
+
                        */
+
                        int filepathArgIndex = arg.FindIndex ("path");
+
                        int modelNameArgIndex = arg.FindIndex ("modelName");
+
                        int c0ArgIndex = arg.FindIndex ("c0");
+
                        int c1ArgIndex = arg.FindIndex ("c1");
+
                        int c2ArgIndex = arg.FindIndex ("c2");
+
                        if ((filepathArgIndex != -1) &&
+
                            (modelNameArgIndex != -1) &&
+
                            (c0ArgIndex != -1) &&
+
                            (c1ArgIndex != -1) &&
+
                            (c2ArgIndex != -1)) {
+
                                if (arg.Set (filepathArgIndex, fullPath.c_str ()) &&
+
                                    arg.Set (modelNameArgIndex, SERVER_HSV_COLOR_MODEL)) {
+
                                        /*
+
                                        * Tell the command to set up
+
                                        * the data types for its
+
                                        * variable arguments.
+
                                        */
+
                                        if (LXx_OK (presetSaveWithModelCmd.ArgSetDatatypes ())) {
+
                                                /*
+
                                                * Set the color component values.
+
                                                */
+
                                                if (arg.Set (c0ArgIndex, hsvColor.vec[0]) &&
+
                                                    arg.Set (c1ArgIndex, hsvColor.vec[1]) &&
+
                                                    arg.Set (c2ArgIndex, hsvColor.vec[2])) {
+
                                                        presetSaveWithModelCmd.Execute (0);
+
                                                }
+
                                        }
+
                                }
+
                        }
+
                }
+
        }
+
 
}
 
}
  
Line 1,800: Line 950:
 
CSaveAsPresetsHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
CSaveAsPresetsHSVColorModelCommand::cmd_Execute (unsigned int flags)
 
{
 
{
        /*
+
      ...
        * Query the color.value command for each HSV component value.
+
        */
+
        HSVColor baseColor;
+
        if (QueryColorValueCmd (baseColor)) {
+
                /*
+
                * Build the color swatches according to the selected color wheel rule.
+
                */
+
                vector<HSVColor> swatchColors;
+
                unsigned baseColorIndex;
+
                CHSVColorModel::BuildSwatches (
+
                        baseColor, swatchColors, baseColorIndex);
+
 
+
                /*
+
                * Ask the preset browser for the file path.
+
                */
+
                string swatchPath;
+
                if (QueryPBViewPathCmd (swatchPath)) {
+
                        /*
+
                        * Execute a series of color.presetSaveWithModel commmands,
+
                        * to generate a preset for each color swatch.
+
                        */
+
                        unsigned swatchCount = static_cast<unsigned>(swatchColors.size ());
+
                        for (unsigned swatchIndex = 0;
+
                            swatchIndex < swatchCount; ++swatchIndex) {
+
                                ExecuteHSVPresetSaveWithModelCmd (
+
                                        swatchColors[swatchIndex],
+
                                        swatchIndex,
+
                                        swatchPath);
+
                        }
+
                }
+
        }
+
 
}
 
}
  
Line 1,837: Line 956:
 
CSaveAsPresetsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
CSaveAsPresetsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
 
{
 
{
         int saveAsPresets = 0;
+
         ...
 
+
        CLxUser_ValueArray  vals (vaQuery);
+
 
+
        return vals.Add (saveAsPresets) ? LXe_OK : LXe_NOTFOUND;
+
 
}
 
}
  
Line 1,849: Line 964:
 
         CLxUser_UIHints &hints)
 
         CLxUser_UIHints &hints)
 
{
 
{
        hints.BooleanStyle (LXiBOOLEANSTYLE_BUTTON);
+
      ...
 
}</pre>
 
}</pre>
  
Line 1,882: Line 997:
 
struct Metrics
 
struct Metrics
 
{
 
{
        float slice_width;
+
      ...
        float slice_height;
+
 
+
        unsigned wheel_aspect;
+
 
+
        float wheel_radius;
+
        float wheel_centerX;
+
        float wheel_centerY;
+
 
+
        float swatch_width;
+
        float swatch_height;
+
 
+
        float wheel_back_width;
+
        float wheel_back_height;
+
 
};
 
};
  
Line 1,904: Line 1,006:
 
         Metrics &metrics)
 
         Metrics &metrics)
 
{
 
{
        metrics.slice_width = static_cast<float>(sliceWidth);
+
      ...
        metrics.slice_height = static_cast<float>(sliceHeight);
+
 
+
        metrics.wheel_aspect = (metrics.slice_width > metrics.slice_height) ?
+
                WHEEL_ASPECT_HORIZONTAL : WHEEL_ASPECT_VERTICAL;
+
 
+
        unsigned swatchCount = CHSVColorModel::SwatchCount ();
+
        if (swatchCount > 1) {
+
                if (metrics.wheel_aspect == WHEEL_ASPECT_HORIZONTAL) {
+
                        float minSwatchWidth = metrics.slice_width * MINIMUM_SWATCH_SIZE;
+
                        metrics.swatch_width = LXxMAX (
+
                                minSwatchWidth, metrics.slice_width - metrics.slice_height);
+
                        metrics.swatch_height = metrics.slice_height / swatchCount;
+
 
+
                        metrics.wheel_back_width = metrics.slice_width - metrics.swatch_width;
+
                        metrics.wheel_back_height = metrics.slice_height;
+
                }
+
                else {
+
                        float minSwatchHeight = metrics.slice_height * MINIMUM_SWATCH_SIZE;
+
                        metrics.swatch_height = LXxMAX (
+
                                minSwatchHeight, metrics.slice_height - metrics.slice_width);
+
                        metrics.swatch_width = metrics.slice_width / swatchCount;
+
 
+
                        metrics.wheel_back_width = metrics.slice_width;
+
                        metrics.wheel_back_height = metrics.slice_height - metrics.swatch_height;
+
                }
+
        }
+
        else {
+
                metrics.swatch_width = 0;
+
                metrics.swatch_height = 0;
+
                metrics.wheel_back_width = metrics.slice_width;
+
                metrics.wheel_back_height = metrics.slice_height;
+
        }
+
       
+
        if (metrics.wheel_back_width < metrics.wheel_back_height) {
+
                metrics.wheel_radius = metrics.wheel_back_width * 0.5f;
+
        }
+
        else {
+
                metrics.wheel_radius = metrics.wheel_back_height * 0.5f;
+
        }
+
 
+
        metrics.wheel_radius -= HUE_WHEEL_MARGIN;
+
 
+
        metrics.wheel_centerX = metrics.wheel_back_width * 0.5f;
+
        metrics.wheel_centerY = metrics.wheel_back_height * 0.5f;
+
 
}
 
}
  
Line 1,967: Line 1,025:
 
         LXtFVector hsv)
 
         LXtFVector hsv)
 
{
 
{
        bool trackingSwatch = false;
+
      ...
 
+
        if ((xAxis == 0) &&
+
            CHSVColorModel::HueAsWheel () &&
+
            (CHSVColorModel::Rule () != HSV_RULE_SOLO)) {
+
                if (metrics.wheel_aspect == WHEEL_ASPECT_VERTICAL) {
+
                        trackingSwatch = imageY > metrics.wheel_back_height;
+
                }
+
                else {
+
                        trackingSwatch = imageX > metrics.wheel_back_width;
+
                }
+
 
+
                if (trackingSwatch) {
+
                        HSVColor baseColor;
+
                        LXx_VCPY (baseColor.vec, downVec);
+
                        std::vector<HSVColor> swatchColors;
+
                        unsigned baseColorIndex;
+
                        CHSVColorModel::BuildSwatches (
+
                                baseColor, swatchColors, baseColorIndex);
+
 
+
                        unsigned swatchIndex;
+
                        if (metrics.wheel_aspect == WHEEL_ASPECT_VERTICAL) {
+
                                swatchIndex = static_cast<unsigned>(
+
                                        static_cast<float>(imageX) / metrics.swatch_width);
+
                        }
+
                        else {
+
                                swatchIndex = static_cast<unsigned>(
+
                                        static_cast<float>(imageY) / metrics.swatch_height);
+
                        }
+
                        swatchIndex = LXxMIN (
+
                                swatchIndex,
+
                                static_cast<unsigned>(swatchColors.size () - 1));
+
 
+
                        LXx_VCPY (hsv, swatchColors[swatchIndex].vec);
+
                }
+
        }
+
 
+
        return trackingSwatch;
+
 
}
 
}
  
Line 2,011: Line 1,032:
 
         rangeWorker(NULL)
 
         rangeWorker(NULL)
 
{
 
{
        range_factory.AddInterface (new CLxIfc_ThreadRangeWorker<CHSVColorModelThreadRangeWorker>);
+
      ...
 
+
        if (persist == NULL) {
+
                /*
+
                * Set up the persistent values.
+
                */
+
                persist = new CHSVColorModelPersist;
+
 
+
                CLxUser_PersistenceService srv;
+
                CHSVColorModelPersistVisitor vis;
+
                srv.ConfigureVis (SERVER_HSV_COLOR_MODEL, &vis);
+
        }
+
 
+
        /*
+
        * Pre-load the primary and secondary marker images.
+
        */
+
        #define HSV_PRIMARY_SLICE_MARKER "colorMarkerPrimary.tga"
+
        #define HSV_SECONDARY_SLICE_MARKER "colorMarkerSecondary.tga"
+
 
+
        CLxUser_FileService fileSvc;
+
        string systemPath;
+
        if (LXx_OK (fileSvc.FileSystemPath (LXsSYSTEM_PATH_RESOURCE, systemPath))) {
+
                std::string primaryMarkerPath(systemPath);
+
                primaryMarkerPath = primaryMarkerPath + std::string("/") +
+
                        std::string(HSV_PRIMARY_SLICE_MARKER);
+
 
+
                std::string secondaryMarkerPath(systemPath);
+
                secondaryMarkerPath = secondaryMarkerPath + std::string("/") +
+
                        std::string(HSV_SECONDARY_SLICE_MARKER);
+
 
+
                CLxUser_ImageService imageSvc;
+
                imageSvc.Load (primary_marker, primaryMarkerPath);
+
                imageSvc.Load (secondary_marker, secondaryMarkerPath);
+
        }
+
 
}
 
}
  
Line 2,062: Line 1,050:
 
         const char **type)
 
         const char **type)
 
{
 
{
         if (componentIndex == 0) {
+
         ...
                *type = LXsTYPE_ANGLE;
+
        }
+
        else {
+
                *type = LXsTYPE_COLOR1;
+
        }
+
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 2,078: Line 1,059:
 
         float *maxValue)
 
         float *maxValue)
 
{
 
{
        *minValue = 0.0f;
+
      ...
 
+
        if (componentIndex == 0) {
+
                *maxValue = static_cast<float>(TWO_PI);
+
        }
+
        else {
+
                *maxValue = 1.0f;
+
        }
+
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 2,095: Line 1,067:
 
         float *rgb)
 
         float *rgb)
 
{
 
{
        HSV2RGB (hsv, rgb);
+
      ...
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 2,105: Line 1,075:
 
         float *hsv)
 
         float *hsv)
 
{
 
{
         RGB2HSV (rgb, hsv);
+
         ...
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 2,120: Line 1,088:
 
HueRGBtoRYB (float hue)
 
HueRGBtoRYB (float hue)
 
{
 
{
        float newHue;
+
      ...
 
+
        float hueRGB[9] = {0, 30 * DEG2RADF, 60 * DEG2RADF, 90 * DEG2RADF, 120 * DEG2RADF, 150 * DEG2RADF, 180 * DEG2RADF, 210 * DEG2RADF, 240 * DEG2RADF};
+
        float hueRYB[9] = {0, 15 * DEG2RADF, 30 * DEG2RADF, 45 * DEG2RADF,  60 * DEG2RADF,  90 * DEG2RADF, 120 * DEG2RADF, 180 * DEG2RADF, 240 * DEG2RADF};
+
 
+
        unsigned index = static_cast<unsigned>(hue / SIXTH_PI);
+
        if (index < 8) {
+
                float low, hi, t;
+
 
+
                low = hueRGB[index];
+
                hi = hueRGB[index + 1];
+
                t = (hue - low) / (hi - low);
+
 
+
                low = hueRYB[index];
+
                hi = hueRYB[index + 1];
+
 
+
                newHue = LERP (t, low, hi);
+
        }
+
        else {
+
                newHue = hue;
+
        }
+
 
+
        return newHue;
+
 
}
 
}
  
Line 2,151: Line 1,097:
 
HueRYBtoRGB (float hue)
 
HueRYBtoRGB (float hue)
 
{
 
{
         float newHue;
+
         ...
 
+
        float hueRYB[9] = {0, 15 * DEG2RADF, 30 * DEG2RADF, 45 * DEG2RADF,  60 * DEG2RADF,  90 * DEG2RADF, 120 * DEG2RADF, 180 * DEG2RADF, 240 * DEG2RADF};
+
        float hueRGB[9] = {0, 30 * DEG2RADF, 60 * DEG2RADF, 90 * DEG2RADF, 120 * DEG2RADF, 150 * DEG2RADF, 180 * DEG2RADF, 210 * DEG2RADF, 240 * DEG2RADF};
+
 
+
        bool convert = false;
+
        unsigned index;
+
        for (index = 0; index < 8; ++index) {
+
                if (hue >= hueRYB[index] && hue <= hueRYB[index + 1]) {
+
                        convert = true;
+
                        break;
+
                }
+
        }
+
        if (convert) {
+
                float low, hi, t;
+
 
+
                low = hueRYB[index];
+
                hi = hueRYB[index + 1];
+
                t = (hue - low) / (hi - low);
+
 
+
                low = hueRGB[index];
+
                hi = hueRGB[index + 1];
+
 
+
                newHue = LERP (t, low, hi);
+
        }
+
        else {
+
                newHue = hue;
+
        }
+
 
+
        return newHue;
+
 
}
 
}
  
Line 2,193: Line 1,110:
 
typedef struct st_HSVColorModelDrawSlice_env
 
typedef struct st_HSVColorModelDrawSlice_env
 
{
 
{
         CLxUser_ImageWrite *writeImage;
+
         ...
        float halfWidth;
+
        float halfHeight;
+
        Metrics *metrics;
+
        int yAxis;
+
        const float *vec;
+
        unsigned wheel;
+
 
} HSVColorModelDrawSlice_env;
 
} HSVColorModelDrawSlice_env;
  
Line 2,207: Line 1,118:
 
         void *sharedData)
 
         void *sharedData)
 
{
 
{
         int y = index;
+
         ...
        HSVColorModelDrawSlice_env *env;
+
        LxResult result = LXe_OK;
+
 
+
        env = reinterpret_cast<HSVColorModelDrawSlice_env*>(sharedData);
+
        LXtImageByte *lineBuffer = new LXtImageByte [static_cast<unsigned>(env->metrics->slice_width) * 4];
+
        LXtImageByte *pixel = lineBuffer;
+
        #pragma ivdep
+
        for (unsigned x = 0; x < env->metrics->slice_width; ++x) {
+
                float xt = static_cast<float>(x) - env->halfWidth;
+
                float yt = static_cast<float>(y) - env->halfHeight;
+
                bool inside;
+
                float hsv[3];
+
                float rgb[3];
+
 
+
                // [TODO] Test boundary before radius.
+
                float colorRadius =
+
                        sqrtf (xt * xt + yt * yt);
+
                inside = colorRadius <= env->metrics->wheel_radius;
+
                if (inside) {
+
                        float angle = 0;
+
                        if (yt != 0) {
+
                                angle = atan2 (yt, xt) +
+
                                        static_cast<float>(PI);
+
                        }
+
                        else if (xt > 0) {
+
                                angle = static_cast<float>(PI);
+
                        }
+
 
+
                        /*
+
                        * Position red (0) at 3 o'clock.
+
                        */
+
                        angle = TWO_PI - angle - PI;
+
                        if (angle < 0) {
+
                                angle += TWO_PI;
+
                        }
+
 
+
                        if (env->wheel == HSV_WHEEL_RYB) {
+
                                /*
+
                                * RYB wheel.
+
                                */
+
                                angle = HueRGBtoRYB (angle);
+
                        }
+
 
+
                        hsv[0] = static_cast<float>(angle);
+
 
+
                        /*
+
                        * Vary the saturation or the value,
+
                        * depending on the active center axis.
+
                        */
+
                        if (env->yAxis == 1) {
+
                                hsv[1] = static_cast<float>(colorRadius / env->metrics->wheel_radius);
+
                                hsv[2] = env->vec[2];
+
                        }
+
                        else {
+
                                hsv[1] = env->vec[1];
+
                                hsv[2] = static_cast<float>(colorRadius / env->metrics->wheel_radius);
+
                        }
+
 
+
                        HSV2RGB (hsv, rgb);
+
                        pixel[0] = static_cast<LXtImageByte>(rgb[0] * 255.0);
+
                        pixel[1] = static_cast<LXtImageByte>(rgb[1] * 255.0);
+
                        pixel[2] = static_cast<LXtImageByte>(rgb[2] * 255.0);
+
 
+
                        /*
+
                        * Anti-aliased alpha for the edge.
+
                        */
+
                        const float EDGE_SOFTNESS = 2.0;
+
                        if (colorRadius > env->metrics->wheel_radius - EDGE_SOFTNESS) {
+
                                pixel[3] = static_cast<LXtImageByte>(
+
                                        (env->metrics->wheel_radius - colorRadius) /
+
                                        EDGE_SOFTNESS * 255.0f);
+
                        }
+
                        else {
+
                                pixel[3] = 255;
+
                        }
+
                }
+
                else {
+
                        pixel[0] = pixel[1] = pixel[2] = 128;
+
                        pixel[3] = 0;
+
                }
+
 
+
                pixel += 4;
+
        }
+
 
+
        result = env->writeImage->SetLine (y, LXiIMP_RGBA32, lineBuffer);
+
 
+
        delete [] lineBuffer;
+
 
+
        return result;
+
 
}
 
}
  
Line 2,306: Line 1,128:
 
         const float *vec)
 
         const float *vec)
 
{
 
{
         LxResult result = LXe_OK;
+
         ...
        CLxUser_ImageWrite writeImage;
+
        CLxUser_Image readImage;
+
 
+
        /*
+
        * Save time by fetching the user values outside of the loops.
+
        */
+
        bool hueAsWheel = HueAsWheel ();
+
        unsigned rule = Rule ();
+
 
+
        writeImage.set (image);
+
        readImage.set (image);
+
 
+
        unsigned width, height;
+
        writeImage.Size (&width, &height);
+
 
+
        Metrics metrics;
+
        ResizeWheelAndRuleSwatches (width, height, metrics);
+
 
+
        /*
+
        * Calculate the radius of the wheel, inset by the margin.
+
        */
+
        float halfWidth = metrics.wheel_back_width * 0.5f;
+
        float halfHeight = metrics.wheel_back_height * 0.5f;
+
 
+
        CLxUser_ThreadService threadSvc;
+
        if ((threadSvc.NumProcs () > 1) &&
+
            (xAxis == 0) && hueAsWheel) {
+
                // Multi-threaded version
+
                HSVColorModelDrawSlice_env env;
+
                env.writeImage = &writeImage;
+
                env.halfWidth = halfWidth;
+
                env.halfHeight = halfHeight;
+
                env.metrics = &metrics;
+
                env.yAxis = yAxis;
+
                env.vec = vec;
+
                env.wheel = Wheel ();
+
 
+
                // Create the range worker if this is the first call.
+
                result = LXe_OK;
+
                if (rangeWorker == NULL) {
+
                        rangeWorker = range_factory.Spawn ();
+
                        if (rangeWorker == NULL) {
+
                                result = LXe_FAILED;
+
                        }
+
                }
+
                if (LXx_OK (result)) {
+
                        result = threadSvc.ProcessRange (
+
                                &env,
+
                                0, static_cast<int>(metrics.slice_height - 1),
+
                                rangeWorker);
+
                }
+
        }
+
        else {
+
                // Single-threaded version
+
                LXtImageByte *lineBuffer;
+
                lineBuffer = new LXtImageByte [static_cast<unsigned>(metrics.slice_width) * 4];
+
 
+
                float hsv[3], rgb[3];
+
                for (unsigned y = 0; y < metrics.slice_height; ++y) {
+
                        LXtImageByte *pixel = lineBuffer;
+
                        if (xAxis == 0) {
+
                                if (hueAsWheel) {
+
                                        for (unsigned x = 0; x < metrics.slice_width; ++x) {
+
                                                float xt = static_cast<float>(x) - halfWidth;
+
                                                float yt = static_cast<float>(y) - halfHeight;
+
                                                bool inside;
+
 
+
                                                // [TODO] Test boundary before radius.
+
                                                float colorRadius =
+
                                                        sqrtf (xt * xt + yt * yt);
+
                                                inside = colorRadius <= metrics.wheel_radius;
+
                                                if (inside) {
+
                                                        float angle = 0;
+
                                                        if (yt != 0) {
+
                                                                angle = atan2 (yt, xt) +
+
                                                                        static_cast<float>(PI);
+
                                                        }
+
                                                        else if (xt > 0) {
+
                                                                angle = static_cast<float>(PI);
+
                                                        }
+
 
+
                                                        /*
+
                                                        * Position red (0) at 3 o'clock.
+
                                                        */
+
                                                        angle = TWO_PI - angle - PI;
+
                                                        if (angle < 0) {
+
                                                                angle += TWO_PI;
+
                                                        }
+
 
+
                                                        if (Wheel () == HSV_WHEEL_RYB) {
+
                                                                /*
+
                                                                * RYB wheel.
+
                                                                */
+
                                                                angle = HueRGBtoRYB (angle);
+
                                                        }
+
 
+
                                                        _H = static_cast<float>(angle);
+
 
+
                                                        /*
+
                                                        * Vary the saturation or the value,
+
                                                        * depending on the active center axis.
+
                                                        */
+
                                                        if (yAxis == 1) {
+
                                                                _S = static_cast<float>(colorRadius / metrics.wheel_radius);
+
                                                                _V = vec[2];
+
                                                        }
+
                                                        else {
+
                                                                _S = vec[1];
+
                                                                _V = static_cast<float>(colorRadius / metrics.wheel_radius);
+
                                                        }
+
 
+
                                                        HSV2RGB (hsv, rgb);
+
                                                        pixel[0] = static_cast<LXtImageByte>(_R * 255.0);
+
                                                        pixel[1] = static_cast<LXtImageByte>(_G * 255.0);
+
                                                        pixel[2] = static_cast<LXtImageByte>(_B * 255.0);
+
 
+
                                                        /*
+
                                                        * Anti-aliased alpha for the edge.
+
                                                        */
+
                                                        const float EDGE_SOFTNESS = 2.0;
+
                                                        if (colorRadius > metrics.wheel_radius - EDGE_SOFTNESS) {
+
                                                                pixel[3] = static_cast<LXtImageByte>(
+
                                                                        (metrics.wheel_radius - colorRadius) /
+
                                                                        EDGE_SOFTNESS * 255.0f);
+
                                                        }
+
                                                        else {
+
                                                                pixel[3] = 255;
+
                                                        }
+
                                                }
+
                                                else {
+
                                                        pixel[0] = pixel[1] = pixel[2] = 128;
+
                                                        pixel[3] = 0;
+
                                                }
+
 
+
                                                pixel += 4;
+
                                        }
+
                                }
+
                                else {
+
                                        // Draw the square, variable hue format, varying
+
                                        // the hue and the saturation or value.
+
                                        if (yAxis == 1) {
+
                                                _S = static_cast<float>(y) / metrics.slice_height;
+
                                                _V = vec[2];
+
                                        }
+
                                        else { // yAxis == 2
+
                                                _S = vec[1];
+
                                                _V = static_cast<float>(y) / metrics.slice_height;
+
                                        }
+
                                        for (unsigned x = 0; x < width; ++x) {
+
                                                _H = (static_cast<float>(x) / metrics.slice_width) *
+
                                                        static_cast<float>(TWO_PI);
+
                                                HSV2RGB (hsv, rgb);
+
                                                pixel[0] = static_cast<LXtImageByte>(_R * 255.0);
+
                                                pixel[1] = static_cast<LXtImageByte>(_G * 255.0);
+
                                                pixel[2] = static_cast<LXtImageByte>(_B * 255.0);
+
                                                pixel[3] = 255;
+
                                                pixel += 4;
+
                                        }
+
                                }
+
                        }
+
                        else { // xAxis == 1
+
                                // Draw the square, fixed hue format, varying both
+
                                // the saturation and value.
+
                                _H = vec[0];
+
                                _S = static_cast<float>(y) / metrics.slice_height;
+
                                for (unsigned x = 0; x < width; ++x) {
+
                                        _V = static_cast<float>(x) / metrics.slice_width;
+
                                        HSV2RGB (hsv, rgb);
+
                                        pixel[0] = static_cast<LXtImageByte>(_R * 255.0);
+
                                        pixel[1] = static_cast<LXtImageByte>(_G * 255.0);
+
                                        pixel[2] = static_cast<LXtImageByte>(_B * 255.0);
+
                                        pixel[3] = 255;
+
                                        pixel += 4;
+
                                }
+
                        }
+
 
+
                        result = writeImage.SetLine (y, LXiIMP_RGBA32, lineBuffer);
+
                }
+
                delete [] lineBuffer;
+
        }
+
 
+
 
+
        return result;
+
 
}
 
}
  
 
class RGBColor
 
class RGBColor
 
{
 
{
     public:
+
     ...
        LXtFVector vec;
+
 
};
 
};
  
 
class Point2D
 
class Point2D
 
{
 
{
     public:
+
     ...
        LXtUVector2 vec;
+
 
};
 
};
  
Line 2,512: Line 1,149:
 
         const float *hsv)
 
         const float *hsv)
 
{
 
{
         CLxUser_ImageService imageSvc;
+
         ...
        LxResult result;
+
 
+
        unsigned rule = Rule ();
+
        string msgTxt("DrawSliceMarker Rule: ");
+
        msgTxt += IntegerToString (rule);
+
        m_log.Info (msgTxt.c_str ());
+
 
+
        if ((xAxis == 0) && HueAsWheel ()) {
+
                CLxUser_Image readImage;
+
                readImage.set (image);
+
                unsigned width, height;
+
                readImage.Size (&width, &height);
+
 
+
                Metrics metrics;
+
                ResizeWheelAndRuleSwatches (width, height, metrics);
+
 
+
                HSVColor baseColor;
+
                LXx_VCPY (baseColor.vec, downVec);
+
                vector<HSVColor> swatchColors;
+
                unsigned baseColorIndex;
+
                BuildSwatches (baseColor, swatchColors, baseColorIndex);
+
 
+
                /*
+
                * Convert HSV color array to RGB.
+
                */
+
                vector<RGBColor> rgbSwatchColors;
+
                unsigned swatchCount = static_cast<unsigned>(swatchColors.size ());
+
                for (unsigned swatchIndex = 0; swatchIndex < swatchCount; ++swatchIndex) {
+
                        RGBColor rgbColor;
+
                        HSV2RGB (swatchColors[swatchIndex].vec, rgbColor.vec);
+
                        rgbSwatchColors.push_back (rgbColor);
+
                }
+
 
+
                /*
+
                * Calculate the marker points.
+
                */
+
                vector<Point2D> markerPoints;
+
                unsigned testMarkerCount = static_cast<unsigned>(markerPoints.size ());
+
                m_log.Info (string (string("DrawSliceMarker: testMarkerCount ") +
+
                                    IntegerToString (testMarkerCount)).c_str ());
+
                int rule = Rule ();
+
                if ((rule != HSV_RULE_TINTS) && (rule != HSV_RULE_SHADES)) {
+
                        unsigned markerCount = static_cast<unsigned>(swatchColors.size ());
+
                        m_log.Info (string (string("DrawSliceMarker: markerCount ") +
+
                                            IntegerToString (markerCount)).c_str ());
+
                        for (unsigned markerIndex = 0;
+
                            markerIndex < markerCount; ++markerIndex) {
+
                                unsigned markerX, markerY;
+
                                colm_ToSlicePos (
+
                                        0, yAxis,
+
                                        static_cast<unsigned>(metrics.slice_width),
+
                                        static_cast<unsigned>(metrics.slice_height),
+
                                        swatchColors[markerIndex].vec,
+
                                        &markerX, &markerY);
+
 
+
                                Point2D markerPoint;
+
                                markerPoint.vec[0] = markerX;
+
                                markerPoint.vec[1] = markerY;
+
 
+
                                testMarkerCount = static_cast<unsigned>(markerPoints.size ());
+
                                m_log.Info (string (string("DrawSliceMarker: testMarkerCount' ") +
+
                                                    IntegerToString (testMarkerCount)).c_str ());
+
                                markerPoints.push_back (markerPoint);
+
                                testMarkerCount = static_cast<unsigned>(markerPoints.size ());
+
                                m_log.Info (string (string("DrawSliceMarker: testMarkerCount'' ") +
+
                                                    IntegerToString (testMarkerCount)).c_str ());
+
                        }
+
                }
+
                else { // tints or shades
+
                        unsigned markerX, markerY;
+
                        colm_ToSlicePos (0, yAxis,
+
                                static_cast<unsigned>(metrics.slice_width),
+
                                static_cast<unsigned>(metrics.slice_height),
+
                                baseColor.vec, &markerX, &markerY);
+
 
+
                        Point2D markerPoint;
+
                        markerPoint.vec[0] = markerX;
+
                        markerPoint.vec[1] = markerY;
+
 
+
                        markerPoints.push_back (markerPoint);
+
 
+
                        /*
+
                        * Hue is constant. Saturation or Value is constant
+
                        * based on the major axis for the rule.
+
                        */
+
                        HSVColor hsvColor;
+
                        LXx_VCPY (hsvColor.vec, baseColor.vec);
+
                        int majorAxis = rule == HSV_RULE_TINTS ? 1 : 2;
+
 
+
                        unsigned levels = Levels ();
+
                        for (unsigned levelIndex = 0;
+
                            levelIndex < levels; ++levelIndex) {
+
                                hsvColor.vec[majorAxis] =
+
                                        static_cast<float>(levelIndex) / (levels - 1);
+
 
+
                                if ((yAxis == majorAxis) &&
+
                                    ((levelIndex == 0) || (levelIndex == levels - 1))) {
+
                                        colm_ToSlicePos (
+
                                                0, yAxis,
+
                                                static_cast<unsigned>(metrics.slice_width),
+
                                                static_cast<unsigned>(metrics.slice_height),
+
                                                hsvColor.vec, &markerX, &markerY);
+
                                        markerPoint.vec[0] = markerX;
+
                                        markerPoint.vec[1] = markerY;
+
 
+
                                        markerPoints.push_back (markerPoint);
+
                                }
+
                        }
+
                }
+
 
+
                if (rule != HSV_RULE_SOLO) {
+
                        CLxUser_Image readImage;
+
                        readImage.set (image);
+
 
+
                        /*
+
                        * Draw lines from the wheel center to each marker.
+
                        */
+
                        unsigned markerCount = static_cast<unsigned>(markerPoints.size ());
+
                        for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
+
                                LXtFVector2 p0 = { metrics.wheel_centerX, metrics.wheel_centerY };
+
 
+
                                Point2D markerPoint = markerPoints[markerIndex];
+
                                LXtFVector2 p1 = {
+
                                        static_cast<float>(markerPoint.vec[0]),
+
                                        static_cast<float>(markerPoint.vec[1]) };
+
 
+
                                /*
+
                                * Reduce the line length by 10 pixels.
+
                                */
+
                                p1[0] -= p0[0];
+
                                p1[1] -= p0[1];
+
                                float len = sqrtf (p1[0] * p1[0] + p1[1] * p1[1]);
+
                                if (len > 0.0001f) {
+
                                        float newLen = len - 10.0f;
+
                                        newLen = LXxMAX (newLen, 0.0f);
+
                                        float scale = newLen / len;
+
                                        p1[0] *= scale;
+
                                        p1[1] *= scale;
+
                                        p1[0] += p0[0];
+
                                        p1[1] += p0[1];
+
                                }
+
 
+
                                /*
+
                                * Draw the line in black.
+
                                * [TODO] Flip to white for a dark wheel.
+
                                */
+
                                float rgbBlack[4] = { 0, 0, 0 };
+
                                imageSvc.DrawLine (readImage, p0, p1, rgbBlack);
+
                        }
+
 
+
                        /*
+
                        * Draw the swatches.
+
                        */
+
                        CLxUser_ImageWrite writeImage;
+
                        writeImage.set (image);
+
                        LXtImageByte *lineBuffer;
+
                        lineBuffer = new LXtImageByte [
+
                                static_cast<unsigned>(metrics.slice_width) * 4];
+
 
+
                        /*
+
                        * For a tall aspect ratio, draw the swatches underneath the wheel.
+
                        */
+
                        if (metrics.wheel_aspect == WHEEL_ASPECT_VERTICAL) {
+
                                for (unsigned y2 = static_cast<unsigned>(metrics.wheel_back_height);
+
                                    y2 < static_cast<unsigned>(metrics.slice_height); ++y2) {
+
                                        LXtImageByte *pixel = lineBuffer;
+
                                        unsigned swatchCount = static_cast<unsigned>(
+
                                                                rgbSwatchColors.size ());
+
                                        float swatchPos = 0;
+
                                        for (unsigned hSwatchIndex = 0;
+
                                            hSwatchIndex < swatchCount; ++hSwatchIndex) {
+
                                                RGBColor rgbColor;
+
                                                LXx_VCPY (rgbColor.vec, rgbSwatchColors[hSwatchIndex].vec);
+
                                                pixel = lineBuffer;
+
                                                unsigned swatchLeft = static_cast<unsigned>(swatchPos);
+
                                                pixel += swatchLeft * 4;
+
                                                unsigned swatchRight = static_cast<unsigned>(
+
                                                        swatchPos + metrics.swatch_width + 0.5f);
+
                                                swatchRight = LXxMIN (
+
                                                        swatchRight,
+
                                                        static_cast<unsigned>(metrics.wheel_back_width));
+
                                                for (unsigned x = static_cast<unsigned>(swatchPos);
+
                                                    x < swatchRight; ++x) {
+
                                                        pixel[0] = static_cast<LXtImageByte>(rgbColor.vec[0] * 255.0);
+
                                                        pixel[1] = static_cast<LXtImageByte>(rgbColor.vec[1] * 255.0);
+
                                                        pixel[2] = static_cast<LXtImageByte>(rgbColor.vec[2] * 255.0);
+
                                                        pixel[3] = 255;
+
                                                        pixel += 4;
+
                                                }
+
                                                swatchPos += metrics.swatch_width;
+
                                        }
+
 
+
                                        result = writeImage.SetLine (y2, LXiIMP_RGBA32, lineBuffer);
+
                                }
+
                        }
+
                        else {
+
                                /*
+
                                * For wide aspect ratio, draw the swatches
+
                                * to the right side of the wheel.
+
                                */
+
                                CLxLoc_ImageSegment imageSeg;
+
                                imageSeg.set (image);
+
 
+
                                RGBColor rgbColor;
+
                                int vSwatchIndex = -1;
+
                                unsigned wheelBackWidth =
+
                                        static_cast<unsigned>(metrics.wheel_back_width);
+
                                for (unsigned y = 0; y < metrics.wheel_back_height; ++y) {
+
                                        LXtImageByte *pixel = lineBuffer;
+
                                        unsigned newSwatchIndex = static_cast<unsigned>(
+
                                                static_cast<float>(y) / metrics.swatch_height);
+
                                        newSwatchIndex = LXxMIN (
+
                                                newSwatchIndex,
+
                                                static_cast<unsigned>(rgbSwatchColors.size () - 1));
+
                                        if (newSwatchIndex != vSwatchIndex) {
+
                                                vSwatchIndex = newSwatchIndex;
+
                                                LXx_VCPY (rgbColor.vec, rgbSwatchColors[vSwatchIndex].vec);
+
                                        }
+
 
+
                                        for (unsigned x = wheelBackWidth;
+
                                            x < metrics.slice_width; ++x) {
+
                                                pixel[0] = static_cast<LXtImageByte>(rgbColor.vec[0] * 255.0);
+
                                                pixel[1] = static_cast<LXtImageByte>(rgbColor.vec[1] * 255.0);
+
                                                pixel[2] = static_cast<LXtImageByte>(rgbColor.vec[2] * 255.0);
+
                                                pixel[3] = 255;
+
                                                pixel += 4;
+
                                        }
+
 
+
                                        result = imageSeg.SetSegment (
+
                                                y, wheelBackWidth,
+
                                                static_cast<unsigned>(metrics.slice_width),
+
                                                LXiIMP_RGBA32, lineBuffer);
+
                                }
+
                        }
+
 
+
                        delete [] lineBuffer;
+
                }
+
 
+
                unsigned primarySrcWidth, primarySrcHeight;
+
                primary_marker.Size (&primarySrcWidth, &primarySrcHeight);
+
 
+
                unsigned secondarySrcWidth, secondarySrcHeight;
+
                secondary_marker.Size (&secondarySrcWidth, &secondarySrcHeight);
+
 
+
                CLxUser_Image readDstImage;
+
                readDstImage.set (image);
+
 
+
                unsigned markerCount = static_cast<unsigned>(markerPoints.size ());
+
                m_log.Info (string (string("DrawSliceMarker: markerCount' ") +
+
                                    IntegerToString (markerCount)).c_str ());
+
                for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
+
                        Point2D markerPoint = markerPoints[markerIndex];
+
                        LXtFVector2 point = {
+
                                static_cast<float>(markerPoint.vec[0]),
+
                                static_cast<float>(markerPoint.vec[1]) };
+
 
+
                        if (markerIndex == baseColorIndex) {
+
                                point[0] -= static_cast<float>(primarySrcWidth) * 0.5f;
+
                                point[1] -= static_cast<float>(primarySrcHeight) * 0.5f;
+
                                result = imageSvc.Composite (
+
                                        readDstImage, primary_marker, point);
+
                        }
+
                        else {
+
                                point[0] -= static_cast<float>(secondarySrcWidth) * 0.5f;
+
                                point[1] -= static_cast<float>(secondarySrcHeight) * 0.5f;
+
                                result = imageSvc.Composite (
+
                                        readDstImage, secondary_marker, point);
+
                        }
+
                }
+
        }
+
        else {
+
                result = LXe_NOTIMPL;
+
        }
+
 
+
        return result;
+
 
}
 
}
  
Line 2,797: Line 1,159:
 
         const float *newVec)
 
         const float *newVec)
 
{
 
{
         unsigned zAxis;
+
         ...
        if (xAxis == 0) {
+
                if (yAxis == 1) {
+
                        zAxis = 2;
+
                }
+
                else {
+
                        zAxis = 1;
+
                }
+
        }
+
        else if (xAxis == 1) {
+
                zAxis = 0;
+
        }
+
 
+
        return (oldVec[zAxis] == newVec[zAxis]) ? LXe_TRUE : LXe_FALSE;
+
 
}
 
}
  
Line 2,827: Line 1,176:
 
         unsigned *imgY)
 
         unsigned *imgY)
 
{
 
{
         float x, y;
+
         ...
 
+
        if (xAxis == 0) {
+
                if (HueAsWheel ()) {
+
                        float angle = _H;
+
                        if (Wheel () == HSV_WHEEL_RYB) {
+
                                /*
+
                                * RYB wheel.
+
                                */
+
                                angle = HueRYBtoRGB (angle);
+
                        }
+
 
+
                        /*
+
                        * Position red (0) at 3 o'clock.
+
                        */
+
                        angle = TWO_PI - angle - PI;
+
                        if (angle < 0) {
+
                                angle += TWO_PI;
+
                        }
+
 
+
                        if (yAxis == 1) {
+
                                x = cos (angle) * _S;
+
                                y = sin (angle) * _S;
+
                        }
+
                        else { // yAxis == 2 (value)
+
                                x = cos (angle) * _V;
+
                                y = sin (angle) * _V;
+
                        }
+
 
+
                        x = -x * 0.5f + 0.5f;
+
                        y = -y * 0.5f + 0.5f;
+
                }
+
                else {
+
                        x = _H / static_cast<float>(TWO_PI);
+
                        if (yAxis == 1) {
+
                                y = _S;
+
                        }
+
                        else { // yAxis == 2 (value)
+
                                y = _V;
+
                        }
+
                }
+
        }
+
        else { // xAxis == 1
+
                x = _V;
+
                y = _S;
+
        }
+
 
+
        /*
+
        * For now, use clamping, but this should really clip to the line
+
        * segment formed from the center point to the nearest edge point.
+
        */
+
        x = LXxCLAMP (x, 0, 1);
+
        y = LXxCLAMP (y, 0, 1);
+
 
+
        if ((xAxis == 0) && (HueAsWheel ())) {
+
                Metrics metrics;
+
                ResizeWheelAndRuleSwatches (imgW, imgH, metrics);
+
 
+
                /*
+
                * Scale and translate according to the aspect ratio and swatches.
+
                */
+
                float wheelDiameter = metrics.wheel_radius * 2;
+
 
+
                x *= wheelDiameter / metrics.slice_width;
+
                y *= wheelDiameter / metrics.slice_height;
+
 
+
                x += (metrics.wheel_back_width - wheelDiameter) * 0.5f / metrics.slice_width;
+
                y += (metrics.wheel_back_height - wheelDiameter) * 0.5f / metrics.slice_height;
+
        }
+
 
+
        *imgX = static_cast<unsigned>(x * imgW);
+
        *imgY = static_cast<unsigned>(y * imgH);
+
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 2,922: Line 1,198:
 
         float *hsv)
 
         float *hsv)
 
{
 
{
         float x = static_cast<float>(imgX);
+
         ...
        float y = static_cast<float>(imgY);
+
 
+
        if (xAxis == 0) {
+
                if (HueAsWheel ()) {
+
                        Metrics metrics;
+
                        ResizeWheelAndRuleSwatches (imgW, imgH, metrics);
+
 
+
                        /*
+
                        * Check if tracking in the swatches.
+
                        */
+
                        if (!TrackSwatch (metrics, xAxis, yAxis,
+
                                imgW, imgH, imgX, imgY, downVec, hsv)) {
+
                                /*
+
                                * Translate back to origin.
+
                                */
+
                                float xt = x - metrics.wheel_centerX;
+
                                float yt = y - metrics.wheel_centerY;
+
                                bool inside;
+
                                float colorRadius =
+
                                        sqrtf (xt * xt + yt * yt) / metrics.wheel_radius;
+
 
+
                                /*
+
                                * Convert x, y to an angle.
+
                                */
+
                                float angle = 0;
+
                                if (yt != 0) {
+
                                        angle = atan2 (yt, xt) +
+
                                                static_cast<float>(PI);
+
                                }
+
                                else if (xt > 0) {
+
                                        angle = static_cast<float>(PI);
+
                                }
+
 
+
                                /*
+
                                * Position red (0) at 3 o'clock.
+
                                */
+
                                angle = TWO_PI - angle - PI;
+
                                if (angle < 0) {
+
                                        angle += TWO_PI;
+
                                }
+
 
+
                                if (Wheel () == HSV_WHEEL_RYB) {
+
                                        /*
+
                                        * RYB wheel.
+
                                        */
+
                                        angle = HueRGBtoRYB (angle);
+
                                }
+
 
+
                                _H = static_cast<float>(angle);
+
                                inside = colorRadius <= 1.0f;
+
                                if (inside) {
+
 
+
                                        /*
+
                                        * Vary the saturation or the value,
+
                                        * depending on the active center axis.
+
                                        */
+
                                        if (yAxis == 1) {
+
                                                _S = colorRadius;
+
                                        }
+
                                        else {
+
                                                _V = colorRadius;
+
                                        }
+
                                }
+
                                else {
+
                                        if (yAxis == 1) {
+
                                                _S = 1.0f;
+
                                        }
+
                                        else {
+
                                                _V = 1.0f;
+
                                        }
+
                                }
+
 
+
                                /*
+
                                * Tracking the wheel, so update base color.
+
                                */
+
                                LXx_VCPY (downVec, hsv);
+
                        }
+
                }
+
                else {
+
                        _H = (x / imgW) * static_cast<float>(TWO_PI);
+
                        if (yAxis == 1) {
+
                                _S = y / imgH;
+
                        }
+
                        else { // yAxis == 2
+
                                _V = y / imgH;
+
                        }
+
                }
+
        }
+
        else { // xAxis == 1
+
                _V = x / imgW;
+
                _S = y / imgH;
+
        }
+
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 3,030: Line 1,212:
 
         float *hsv)
 
         float *hsv)
 
{
 
{
        if( axis == 0 ) {
+
      ...
                // Hue
+
                if( !dynamic ) {
+
                        _S = 1.0f;
+
                        _V = 1.0f;
+
                }
+
 
+
        } else if (axis == 1) {
+
                // Saturation
+
                if (!dynamic)
+
                        _V = 1.0;
+
        } else {
+
                // Value
+
                if( !dynamic )
+
                        _H = 0.0;
+
        }
+
 
+
        return LXe_OK;
+
 
}
 
}
  
Line 3,053: Line 1,218:
 
CHSVColorModel::HueAxisOnStrip ()
 
CHSVColorModel::HueAxisOnStrip ()
 
{
 
{
         return QueryCommandInt (LXsCOMMAND_COLOR_MODEL_AXIS) == 0;
+
         ...
 
}
 
}
  
Line 3,059: Line 1,224:
 
CHSVColorModel::HueAsWheel ()
 
CHSVColorModel::HueAsWheel ()
 
{
 
{
         return persist->hue_as_wheel_value.Bool (0, PRESET_HSV_HUE_AS_WHEEL);
+
         ...
 
}
 
}
  
Line 3,065: Line 1,230:
 
CHSVColorModel::Wheel ()
 
CHSVColorModel::Wheel ()
 
{
 
{
         return persist->wheel_value.Int (0, PRESET_HSV_WHEEL);
+
         ...
 
}
 
}
  
Line 3,071: Line 1,236:
 
CHSVColorModel::Rule ()
 
CHSVColorModel::Rule ()
 
{
 
{
         return persist->rule_value.Int (0, PRESET_HSV_RULE);
+
         ...
 
}
 
}
  
Line 3,077: Line 1,242:
 
CHSVColorModel::RuleAdjust ()
 
CHSVColorModel::RuleAdjust ()
 
{
 
{
         float adjust = PresetRuleAdjust ();
+
         ...
        switch (Rule ()) {
+
                case HSV_RULE_COMPLEMENTARY:
+
                        adjust = static_cast<float>(
+
                                persist->rule_adjust_value_complementary.Float (
+
                                        0, adjust));
+
                        break;
+
 
+
                case HSV_RULE_ANALOGOUS:
+
                        adjust = static_cast<float>(
+
                                persist->rule_adjust_value_analogous.Float (
+
                                        0, adjust));
+
                        break;
+
 
+
                case HSV_RULE_TRIADIC:
+
                        adjust = static_cast<float>(
+
                                persist->rule_adjust_value_triadic.Float (
+
                                        0, adjust));
+
                        break;
+
 
+
                case HSV_RULE_TETRADIC:
+
                        adjust = static_cast<float>(
+
                                persist->rule_adjust_value_tetradic.Float (
+
                                        0, adjust));
+
                        break;
+
 
+
                case HSV_RULE_COMPOUND:
+
                        adjust = static_cast<float>(
+
                                persist->rule_adjust_value_compound.Float (
+
                                        0, adjust));
+
                        break;
+
        }
+
 
+
        return adjust;
+
 
}
 
}
  
Line 3,116: Line 1,248:
 
CHSVColorModel::PresetRuleAdjust ()
 
CHSVColorModel::PresetRuleAdjust ()
 
{
 
{
         double presetAdjust;
+
         ...
        switch (Rule ()) {
+
                case HSV_RULE_COMPLEMENTARY:
+
                        presetAdjust = PRESET_HSV_RULE_ADJUST_COMPLEMENTARY;
+
                        break;
+
 
+
                case HSV_RULE_ANALOGOUS:
+
                        presetAdjust = PRESET_HSV_RULE_ADJUST_ANALOGOUS;
+
                        break;
+
 
+
                case HSV_RULE_TRIADIC:
+
                        presetAdjust = PRESET_HSV_RULE_ADJUST_TRIADIC;
+
                        break;
+
 
+
                case HSV_RULE_TETRADIC:
+
                        presetAdjust = PRESET_HSV_RULE_ADJUST_TETRADIC;
+
                        break;
+
 
+
                case HSV_RULE_COMPOUND:
+
                        presetAdjust = PRESET_HSV_RULE_ADJUST_COMPOUND;
+
                        break;
+
        }
+
 
+
        return static_cast<float>(presetAdjust);
+
 
}
 
}
  
Line 3,145: Line 1,254:
 
CHSVColorModel::Levels ()
 
CHSVColorModel::Levels ()
 
{
 
{
         return persist->levels_value.Int (0, PRESET_HSV_LEVELS);
+
         ...
 
}
 
}
  
Line 3,151: Line 1,260:
 
CHSVColorModel::SwatchCount ()
 
CHSVColorModel::SwatchCount ()
 
{
 
{
         unsigned swatchCount = 0;
+
         ...
        switch (Rule ()) {
+
                case HSV_RULE_SOLO:
+
                        // Just the selected color.
+
                        swatchCount = 1;
+
                        break;
+
 
+
                case HSV_RULE_COMPLEMENTARY:
+
                        // Selected color and its opposite.
+
                        swatchCount = 2;
+
                        break;
+
 
+
                case HSV_RULE_ANALOGOUS:
+
                        // Adjacent colors.
+
                        swatchCount = 3;
+
                        break;
+
 
+
                case HSV_RULE_TRIADIC:
+
                        // Three colors at 120 degree stops.
+
                        swatchCount = 3;
+
                        break;
+
 
+
                case HSV_RULE_TETRADIC:
+
                        // Four colors at 45 degree stops.
+
                        swatchCount = 4;
+
                        break;
+
 
+
                case HSV_RULE_COMPOUND:
+
                        // Five colors at 30 and 45 degree stops.
+
                        swatchCount = 5;
+
                        break;
+
 
+
                case HSV_RULE_TINTS:
+
                case HSV_RULE_SHADES:
+
                        // Variations by tint or shade.
+
                        swatchCount = Levels ();
+
                        break;
+
        }
+
 
+
        return swatchCount;
+
 
}
 
}
  
Line 3,199: Line 1,269:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
         swatchColors.clear ();
+
         ...
 
+
        switch (Rule ()) {
+
                case HSV_RULE_SOLO:
+
                        // Just the selected color.
+
                        baseColorIndex = 0;
+
                        swatchColors.push_back (baseColor);
+
                        break;
+
 
+
                case HSV_RULE_COMPLEMENTARY:
+
                        // Selected color and its opposite.
+
                        BuildComplementarySwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_ANALOGOUS:
+
                        // Adjacent colors.
+
                        BuildAnalogousSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_TRIADIC:
+
                        // Three colors at 120 degree stops.
+
                        BuildTriadicSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_TETRADIC:
+
                        // Four colors at 45 degree stops.
+
                        BuildTetradicSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_COMPOUND:
+
                        // Five colors at 30 and 45 degree stops.
+
                        BuildCompoundSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_TINTS:
+
                        // Variations by tint.
+
                        BuildTintsSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
 
+
                case HSV_RULE_SHADES:
+
                        // Variations by shade.
+
                        BuildShadesSwatches (
+
                                baseColor, swatchColors,
+
                                baseColorIndex);
+
                        break;
+
        }
+
 
}
 
}
  
Line 3,268: Line 1,281:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
        HSVColor hsvColor;
+
      ...
 
+
        baseColorIndex = static_cast<unsigned>(swatchColors.size ());
+
        swatchColors.push_back (baseColor);
+
 
+
        float angle = baseColor.vec[0];
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRYBtoRGB (angle);
+
        }
+
 
+
        angle = fmod(angle + RuleAdjust (), TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
 
+
        hsvColor.vec[0] = angle;
+
        hsvColor.vec[1] = baseColor.vec[1];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
 
+
        swatchColors.push_back (hsvColor);
+
 
}
 
}
  
Line 3,299: Line 1,293:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
         HSVColor hsvColor;
+
         ...
 
+
        float baseAngle = baseColor.vec[0];
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                baseAngle = HueRYBtoRGB (baseAngle);
+
        }
+
 
+
        // -45 degrees
+
        float angle = fmod(baseAngle - RuleAdjust (), TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        hsvColor.vec[1] = baseColor.vec[1];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
        swatchColors.push_back (hsvColor);
+
 
+
        // Selected color.
+
        baseColorIndex = static_cast<unsigned>(swatchColors.size ());
+
        swatchColors.push_back (baseColor);
+
 
+
        // +45 degrees
+
        angle = fmod(baseAngle + RuleAdjust (), TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
}
 
}
  
Line 3,341: Line 1,305:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
        HSVColor hsvColor;
+
      ...
 
+
        float baseAngle = baseColor.vec[0];
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                baseAngle = HueRYBtoRGB (baseAngle);
+
        }
+
 
+
        // -120 degrees
+
        float angle = fmod(baseAngle - RuleAdjust (), TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        hsvColor.vec[1] = baseColor.vec[1];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
        swatchColors.push_back (hsvColor);
+
 
+
        // Selected color.
+
        baseColorIndex = static_cast<unsigned>(swatchColors.size ());
+
        swatchColors.push_back (baseColor);
+
 
+
        // +120 degrees
+
        angle = fmod(baseAngle + RuleAdjust (), TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
}
 
}
  
Line 3,383: Line 1,317:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
         HSVColor hsvColor;
+
         ...
 
+
        float baseAngle = baseColor.vec[0];
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                baseAngle = HueRYBtoRGB (baseAngle);
+
        }
+
 
+
        // -45 degrees
+
        float angle = fmod(baseAngle - RuleAdjust (), TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        hsvColor.vec[1] = baseColor.vec[1];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
        swatchColors.push_back (hsvColor);
+
 
+
        // Selected color.
+
        baseColorIndex = static_cast<unsigned>(swatchColors.size ());
+
        swatchColors.push_back (baseColor);
+
 
+
        // +180 degrees
+
        angle = fmod(baseAngle + PI, TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
+
        // +135 degrees
+
        angle = fmod(baseAngle + PI - RuleAdjust (), TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
}
 
}
  
Line 3,436: Line 1,329:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
         float adjust = RuleAdjust ();
+
         ...
        HSVColor hsvColor;
+
 
+
        float baseAngle = baseColor.vec[0];
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                baseAngle = HueRYBtoRGB (baseAngle);
+
        }
+
 
+
        // - rule - half rule
+
        float angle = fmod(baseAngle - adjust - adjust * 0.5f, TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        hsvColor.vec[1] = baseColor.vec[1];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
        swatchColors.push_back (hsvColor);
+
 
+
        // -rule
+
        angle = fmod(baseAngle - adjust, TWO_PI);
+
        if (angle < 0) {
+
                angle += TWO_PI;
+
        }
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
+
        // Selected color.
+
        baseColorIndex = static_cast<unsigned>(swatchColors.size ());
+
        swatchColors.push_back (baseColor);
+
 
+
        // +rule
+
        angle = fmod(baseAngle + adjust, TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
+
        // +rule + half rule
+
        angle = fmod(baseAngle + adjust + adjust * 0.5f, TWO_PI);
+
        if (Wheel () == HSV_WHEEL_RYB) {
+
                angle = HueRGBtoRYB (angle);
+
        }
+
        hsvColor.vec[0] = angle;
+
        swatchColors.push_back (hsvColor);
+
 
}
 
}
  
Line 3,498: Line 1,341:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
        HSVColor hsvColor;
+
    ...
 
+
        baseColorIndex = 0;
+
 
+
        // Hue and value are constant.
+
        hsvColor.vec[0] = baseColor.vec[0];
+
        hsvColor.vec[2] = baseColor.vec[2];
+
 
+
        unsigned levels = Levels ();
+
        for (unsigned levelIndex = 0; levelIndex < levels; ++levelIndex) {
+
                hsvColor.vec[1] = static_cast<float>(levelIndex) / (levels - 1);
+
                swatchColors.push_back (hsvColor);
+
        }
+
 
}
 
}
  
Line 3,522: Line 1,353:
 
         unsigned &baseColorIndex)
 
         unsigned &baseColorIndex)
 
{
 
{
        HSVColor hsvColor;
+
    ...
 
+
        baseColorIndex = 0;
+
 
+
        // Hue and saturation are constant.
+
        hsvColor.vec[0] = baseColor.vec[0];
+
        hsvColor.vec[1] = baseColor.vec[1];
+
 
+
        unsigned levels = Levels ();
+
 
+
        for (unsigned levelIndex = 0; levelIndex < levels; ++levelIndex) {
+
                hsvColor.vec[2] = static_cast<float>(levelIndex) / (levels - 1);
+
                swatchColors.push_back (hsvColor);
+
        }
+
 
}</pre>
 
}</pre>
  
Line 3,547: Line 1,365:
 
typedef struct st_HSVColorModelDrawSlice_env
 
typedef struct st_HSVColorModelDrawSlice_env
 
{
 
{
         CLxUser_ImageWrite *writeImage;
+
         ...
        float halfWidth;
+
        float halfHeight;
+
        Metrics *metrics;
+
        int yAxis;
+
        const float *vec;
+
        unsigned wheel;
+
 
} HSVColorModelDrawSlice_env;
 
} HSVColorModelDrawSlice_env;
  
Line 3,560: Line 1,372:
 
         int index,
 
         int index,
 
         void *sharedData)
 
         void *sharedData)
{
+
{  
        int y = index;
+
      ...
        HSVColorModelDrawSlice_env *env;
+
        LxResult result = LXe_OK;
+
 
+
        env = reinterpret_cast<HSVColorModelDrawSlice_env*>(sharedData);
+
        LXtImageByte *lineBuffer = new LXtImageByte [static_cast<unsigned>(env->metrics->slice_width) * 4];
+
        LXtImageByte *pixel = lineBuffer;
+
        #pragma ivdep
+
        for (unsigned x = 0; x < env->metrics->slice_width; ++x) {
+
                float xt = static_cast<float>(x) - env->halfWidth;
+
                float yt = static_cast<float>(y) - env->halfHeight;
+
                bool inside;
+
                float hsv[3];
+
                float rgb[3];
+
 
+
                // [TODO] Test boundary before radius.
+
                float colorRadius =
+
                        sqrtf (xt * xt + yt * yt);
+
                inside = colorRadius <= env->metrics->wheel_radius;
+
                if (inside) {
+
                        float angle = 0;
+
                        if (yt != 0) {
+
                                angle = atan2 (yt, xt) +
+
                                        static_cast<float>(PI);
+
                        }
+
                        else if (xt > 0) {
+
                                angle = static_cast<float>(PI);
+
                        }
+
 
+
                        /*
+
                        * Position red (0) at 3 o'clock.
+
                        */
+
                        angle = TWO_PI - angle - PI;
+
                        if (angle < 0) {
+
                                angle += TWO_PI;
+
                        }
+
 
+
                        if (env->wheel == HSV_WHEEL_RYB) {
+
                                /*
+
                                * RYB wheel.
+
                                */
+
                                angle = HueRGBtoRYB (angle);
+
                        }
+
 
+
                        hsv[0] = static_cast<float>(angle);
+
 
+
                        /*
+
                        * Vary the saturation or the value,
+
                        * depending on the active center axis.
+
                        */
+
                        if (env->yAxis == 1) {
+
                                hsv[1] = static_cast<float>(colorRadius / env->metrics->wheel_radius);
+
                                hsv[2] = env->vec[2];
+
                        }
+
                        else {
+
                                hsv[1] = env->vec[1];
+
                                hsv[2] = static_cast<float>(colorRadius / env->metrics->wheel_radius);
+
                        }
+
 
+
                        HSV2RGB (hsv, rgb);
+
                        pixel[0] = static_cast<LXtImageByte>(rgb[0] * 255.0);
+
                        pixel[1] = static_cast<LXtImageByte>(rgb[1] * 255.0);
+
                        pixel[2] = static_cast<LXtImageByte>(rgb[2] * 255.0);
+
 
+
                        /*
+
                        * Anti-aliased alpha for the edge.
+
                        */
+
                        const float EDGE_SOFTNESS = 2.0;
+
                        if (colorRadius > env->metrics->wheel_radius - EDGE_SOFTNESS) {
+
                                pixel[3] = static_cast<LXtImageByte>(
+
                                        (env->metrics->wheel_radius - colorRadius) /
+
                                        EDGE_SOFTNESS * 255.0f);
+
                        }
+
                        else {
+
                                pixel[3] = 255;
+
                        }
+
                }
+
                else {
+
                        pixel[0] = pixel[1] = pixel[2] = 128;
+
                        pixel[3] = 0;
+
                }
+
 
+
                pixel += 4;
+
        }
+
 
+
        result = env->writeImage->SetLine (y, LXiIMP_RGBA32, lineBuffer);
+
 
+
        delete [] lineBuffer;
+
 
+
        return result;
+
 
}
 
}
 
</pre>
 
</pre>

Revision as of 23:17, 11 September 2013

Color_Model_HSV is a basic example plugin. This wiki page is intended as a walkthrough of the code in order to help you better understand the SDK.

When installed, this plugin adds a color model that enables picking colors using hue, saturation, and value color components.

Hsv shot1.png

The HSV color model.

Code Walkthrough

Class Declarations

This function allows the plugin to write to the log through by inheriting from the CLxLuxologyLogMessage class.

extern const char* SERVER_HSV_COLOR_MODEL;
class CHSVColorModelLog : public CLxLuxologyLogMessage
{
   public:
                        CHSVColorModelLog ()
                                : CLxLuxologyLogMessage (SERVER_HSV_COLOR_MODEL) { }

       const char *	 GetFormat  () { return "HSV Color Model"; }
};

These functions are basic commands that perform certain actions in running/setting up the color model. They have the general functions for the basic command class(Cmd_Flags, Enable, Notifier, Execute, and Query).

class CHueAsWheelHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CHueAsWheelHSVColorModelCommand ();
        virtual		~CHueAsWheelHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;
};

class CWheelHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CWheelHSVColorModelCommand ();
        virtual		~CWheelHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;

        void		 atrui_UIHints (unsigned int index, CLxUser_UIHints &hints) LXx_OVERRIDE;
};

class CRuleHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CRuleHSVColorModelCommand ();
        virtual		~CRuleHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;

        void		 atrui_UIHints (unsigned int index, CLxUser_UIHints &hints) LXx_OVERRIDE;
};

class CRuleAdjustHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CRuleAdjustHSVColorModelCommand ();
        virtual		~CRuleAdjustHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;

        void		 atrui_UIHints (unsigned int index, CLxUser_UIHints &hints) LXx_OVERRIDE;
};

class CLevelsHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CLevelsHSVColorModelCommand ();
        virtual		~CLevelsHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;

        void		 atrui_UIHints (unsigned int index, CLxUser_UIHints &hints) LXx_OVERRIDE;
};

class CSaveAsPresetsHSVColorModelCommand : public CLxBasicCommand
{
    public:
                         CSaveAsPresetsHSVColorModelCommand ();
        virtual		~CSaveAsPresetsHSVColorModelCommand () {}

        int		 basic_CmdFlags () LXx_OVERRIDE;
        bool		 basic_Notifier (int index, std::string &name, std::string &args) LXx_OVERRIDE;
        bool		 basic_Enable (CLxUser_Message &msg) LXx_OVERRIDE;

        void		 cmd_Execute (unsigned int flags) LXx_OVERRIDE;
        LxResult         cmd_Query (unsigned int index, ILxUnknownID vaQuery) LXx_OVERRIDE;

        void		 atrui_UIHints (unsigned int index, CLxUser_UIHints &hints) LXx_OVERRIDE;
};

This function is a notifier which goes off when changes to the color model occur.

class CHSVColorModelNotifier : public CLxCommandNotifier
{
   public:
                        CHSVColorModelNotifier ();
       virtual		~CHSVColorModelNotifier () {}

       virtual void		cn_Parse (std::string &args);
       virtual unsigned int	cn_Flags (int code);
};

This code block is an enumerated type that set the values corresponding to the different type of wheels.

enum {
       HSV_WHEEL_RGB,			// Red, green, and blue is triadic.
       HSV_WHEEL_RYB			// Red, yellow, and blue is triadic.
};

This code black is an enumerated type that set the values corresponding to the rules related to building swatches.

enum {

       HSV_RULE_SOLO,			// Just the selected color.
       HSV_RULE_COMPLEMENTARY,		// Selected color and its opposite.
       HSV_RULE_ANALOGOUS,		// Adjacent colors.
       HSV_RULE_TRIADIC,		// Three colors at 120 degree stops.
       HSV_RULE_TETRADIC,		// Four colors at 45 degree stops.
       HSV_RULE_COMPOUND,		// Five colors at 30 and 45 degree stops.
       HSV_RULE_TINTS,			// Tinted variations.
       HSV_RULE_SHADES			// Shaded variations.

};

This is the main function from which the color model will be built. It inherits from CLxImpl_ColorModel because it has the functions we need in order to create our color model, which we want the CHSVColorModel to create. Inside the class the functions with the colm prefix perform changes on the color model(the change is usually explained by the rest of the name. The functions without any special prefix either create the name of their function or query a value with its name. The rest of the functions have the Build prefix and build a certain type of swatch made obvious by the rest of the name.

class CHSVColorModel :
        public CLxImpl_ColorModel
{
        CHSVColorModelLog	 m_log;
        ILxUnknownID		 rangeWorker;

    public:
        static LXtTagInfoDesc	 descInfo[];
        CLxPolymorph<CHSVColorModelThreadRangeWorker>	 range_factory;

                                 CHSVColorModel ();
        virtual			~CHSVColorModel ();

        virtual int		 colm_NumComponents (void) LXx_OVERRIDE;

        virtual LxResult	 colm_ComponentType (
                                        unsigned	 componentIndex,
                                        const char	**type) LXx_OVERRIDE;

        virtual LxResult	 colm_ComponentRange (
                                        unsigned	 componentIndex,
                                        float		*minValue,
                                        float		*maxValue) LXx_OVERRIDE;

        virtual LxResult	 colm_ToRGB (
                                        const float	*hsv,
                                        float		*rgb) LXx_OVERRIDE;

        virtual LxResult	 colm_FromRGB (
                                        const float	*rgb,
                                        float		*hsv) LXx_OVERRIDE;

        virtual LxResult	 colm_DrawSlice (
                                        ILxUnknownID	 image,
                                        unsigned	 xAxis,
                                        unsigned	 yAxis,
                                        const float	*vec) LXx_OVERRIDE;

        virtual LxResult	 colm_DrawSliceMarker (
                                        ILxUnknownID	 image,
                                        unsigned	 xAxis,
                                        unsigned	 yAxis,
                                        const float	*downVec,
                                        const float	*hsv) LXx_OVERRIDE;

        virtual LxResult	 colm_CanSliceBeReused (
                                        unsigned	  xAxis,
                                        unsigned	  yAxis,
                                        const float	 *oldVec,
                                        const float	 *newVec) LXx_OVERRIDE;

        virtual LxResult	 colm_ToSlicePos (
                                        unsigned	 xAxis,
                                        unsigned	 yAxis,
                                        unsigned	 imgW,
                                        unsigned	 imgH,
                                        const float	*hsv,
                                        unsigned	*imgX,
                                        unsigned	*imgY) LXx_OVERRIDE;

        virtual LxResult	 colm_FromSlicePos (
                                        unsigned	 xAxis,
                                        unsigned	 yAxis,
                                        unsigned	 imgW,
                                        unsigned	 imgH,
                                        unsigned	 imgX,
                                        unsigned	 imgY,
                                        float		*downVec,
                                        float		*hsv) LXx_OVERRIDE;

        virtual LxResult	 colm_StripBaseVector (
                                        unsigned	 axis,
                                        int		 dynamic,
                                        float		*hsv) LXx_OVERRIDE;

        static bool		 HueAxisOnStrip ();
        static bool		 HueAsWheel ();
        static unsigned		 Wheel ();

        static unsigned		 Rule ();
        static float		 RuleAdjust ();
        static float		 PresetRuleAdjust ();

        static unsigned		 Levels ();

        static unsigned		 SwatchCount ();

        static void		 BuildSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

    private:
        static void		 BuildComplementarySwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildAnalogousSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildTriadicSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildTetradicSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildCompoundSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildTintsSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        static void		 BuildShadesSwatches (
                                        const HSVColor		&baseColor,
                                        std::vector<HSVColor>	&swatchColors,
                                        unsigned		&baseColorIndex);

        CLxUser_Image		 primary_marker;
        CLxUser_Image		 secondary_marker;
};

Initialization

This function initializes each server, or in other words tells Modo that this plugin will be adding certain features.

        void
initialize ()
{
        // Color Model server.
        LXx_ADD_SERVER (ColorModel, CHSVColorModel, SERVER_HSV_COLOR_MODEL);

        CLxGenericPolymorph	*srv;

        // Hue As Wheel command.
        srv = new CLxPolymorph<CHueAsWheelHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CHueAsWheelHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CHueAsWheelHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvHueAsWheel", srv);

        // Wheel command.
        srv = new CLxPolymorph<CWheelHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CWheelHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CWheelHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_AttributesUI<CWheelHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvWheel", srv);

        // Rule command.
        srv = new CLxPolymorph<CRuleHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CRuleHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CRuleHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_AttributesUI<CRuleHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvRule", srv);

        // Rule Adjust command.
        srv = new CLxPolymorph<CRuleAdjustHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CRuleAdjustHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CRuleAdjustHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_AttributesUI<CRuleAdjustHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvRuleAdjust", srv);

        // Levels command.
        srv = new CLxPolymorph<CLevelsHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CLevelsHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CLevelsHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_AttributesUI<CLevelsHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvLevels", srv);

        // Save as Presets command.
        srv = new CLxPolymorph<CSaveAsPresetsHSVColorModelCommand>;
        srv->AddInterface (new CLxIfc_Command   <CSaveAsPresetsHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_Attributes<CSaveAsPresetsHSVColorModelCommand>);
        srv->AddInterface (new CLxIfc_AttributesUI<CSaveAsPresetsHSVColorModelCommand>);
        thisModule.AddServer ("color.hsvSaveAsPresets", srv);

        // Notifier.
        srv = new CLxPolymorph<CHSVColorModelNotifier>;
        srv->AddInterface (new CLxIfc_Notifier<CHSVColorModelNotifier>);
        thisModule.AddServer (HSV_COLOR_MODEL_NOTIFIER, srv);
}

This function cleans up the persistent data

void cleanup ()
{
       if (persist) {
               delete persist;
       }
}

Helper Functions

These are conversion utilities that will be used later on in implementing the class functions.

        string
IntegerToString (
        unsigned value,
        unsigned padding = 0,
        bool asHexadecimal = false,
        bool withHexPrefix = false)
{
       ...
}

const float PI			= 3.1415926535897932384626433832795f;
const float TWO_PI		= PI * 2.0f;	 // 360 degrees
const float TWO_PI_OVER_THREE	= TWO_PI / 3.0f; // 120 degrees
const float HALF_PI		= PI * 0.5f;	 // 90 degrees
const float THIRD_PI		= PI / 3.0f;	 // 60 degrees
const float SIXTH_PI		= PI / 6.0f;	 // 30 degrees
const float QUARTER_PI		= PI * 0.25f;	 // 45 degrees

#define _R		rgb[0]
#define _G		rgb[1]
#define _B		rgb[2]
#define _H		hsv[0]
#define _S		hsv[1]
#define _V		hsv[2]

/*
 * rgb in [0, 1]; h in [0, TWO_PI], s and v in [0, 1]
 */
        static void
RGB2HSV (
        const float	*rgb,
        float		*hsv)
{
        ...
}

/*
 * rgb in [0, 1]; h in [0, TWO_PI], s and v in [0, 1]
 */
        static void
HSV2RGB (
        const float	*hsv,
        float		*rgb)
{
       ...
}

These are utilities that retrieve the values in certain argument indeces.

const unsigned MAX_COMMAND_VALUE_LEN = 256;

        static string
QueryCommandString (const char *cmdName, const char *argName)
{
       ...
}

        static int
QueryCommandInt (const char *cmdName, int defaultValue = 0)
{
        ...

        static double
QueryCommandFloat (const char *cmdName, double defaultValue = 0.0)
{
        ...
}

This function takes a string and executes a command with a name that matches that string.

ExecuteCommand (const char *cmdName)
{
      ...
}

This code block is a set of helper functions that Query a series of color.value commands, to retrieve the selected base color's component values, from which the rule-based color swatches will be built and Execute the color.presetSaveWithModel commmand, to generate a preset for the given swatch. These are then used for the cmd_Execute of CSaveAsPresetsHSVColorModelCommand

        static bool
QueryColorValueCmd (
        HSVColor		&baseColor)
{
        ...
}

        static bool
QueryPBViewPathCmd (
        string		&path)
{
       ...
}

/*
 * Execute the color.presetSaveWithModel commmand,
 * to generate a preset for the given swatch.
 */
        static void
ExecuteHSVPresetSaveWithModelCmd (
        const HSVColor		&hsvColor,
        unsigned		 swatchIndex,
        string			&swatchPath)
{
       ...
}

This function resizes wheel and rule swatches.

        static void
ResizeWheelAndRuleSwatches (
        unsigned	 sliceWidth,
        unsigned	 sliceHeight,
        Metrics		&metrics)
{
       ...
}

This function returns whether or not the given image (X, Y) coordinates are tracking within a swatch.

        static bool
TrackSwatch (
        Metrics		&metrics,
        unsigned	 xAxis,
        unsigned	 yAxis,
        unsigned	 imageWidth,
        unsigned	 imageHeight,
        unsigned	 imageX,
        unsigned	 imageY,
        LXtFVector	 downVec,
        LXtFVector	 hsv)
{
        ...
}

These are helper functions that Remap an HSV hue such that red, yellow, and blue are triadic, instead of red, green, and blue and perform the reverse.

   static inline float
HueRGBtoRYB (float hue)
{
        ...
}

/*
 * The inverse of HueRGBtoRYB.
 */
        static inline float
HueRYBtoRGB (float hue)
{
       ...
}

Persistent Data

This is a struct that holds the persistent data of the color model

struct CHSVColorModelPersist
{
       ...
};

This is a function that visits every attribute in the struct above and sets its value to that of the matching persistent data object.

class CHSVColorModelPersistVisitor : public CLxImpl_AbstractVisitor
{
    ...
};

static const char* ATOM_TAG_HUE_AS_WHEEL		= "hsv.hue.as.wheel";
static const char* ATOM_TAG_WHEEL			= "hsv.wheel";
static const char* ATOM_TAG_RULE			= "hsv.rule";
static const char* ATOM_TAG_RULE_ADJUST_COMPLEMENTARY	= "hsv.rule.adjust_complementary";
static const char* ATOM_TAG_RULE_ADJUST_ANALOGOUS	= "hsv.rule.adjust_analogous";
static const char* ATOM_TAG_RULE_ADJUST_TRIADIC		= "hsv.rule.adjust_triadic";
static const char* ATOM_TAG_RULE_ADJUST_TETRADIC	= "hsv.rule.adjust_tetradic";
static const char* ATOM_TAG_RULE_ADJUST_COMPOUND	= "hsv.rule.adjust_compound";
static const char* ATOM_TAG_LEVELS			= "hsv.levels";

        LxResult
CHSVColorModelPersistVisitor::Evaluate ()
{
       ...
}

This function is a notifier with flags that have it go off whenever a value changes or if the command is not working.


static const char *HSV_COLOR_MODEL_NOTIFIER = "hsv.color.model.notifier";

CHSVColorModelNotifier::CHSVColorModelNotifier ()
        :
        CLxCommandNotifier (HSV_COLOR_MODEL_NOTIFIER)
{
}

        void
CHSVColorModelNotifier::cn_Parse (string &args)
{
}

        unsigned int
CHSVColorModelNotifier::cn_Flags (int code)
{
        ...
}

This section implements the functions of the CHueAsWheelColorModelCommand class. Its constructor sets it so that it takes a boolean value. The CmdFlags function indicates that the command affects the command ui. The notifier goes off whenever the notifier(http://sdk.luxology.com/wiki/Notifier_Object) in 407-424 goes off or the selected color has changed. The enables command enables the command if the strip is not set to the hue axis. The cmd_execute portion is the actual command. Cmd_Query asks for the value of a relevant argument index.

#define LXsCOMMAND_COLOR_UPDATE_VIEW	"color.updateView"
#define LXsCOMMAND_COLOR_MODEL_AXIS	"color.modelAxis"

enum
{
       ...
};

const bool PRESET_HSV_HUE_AS_WHEEL = true;

CHueAsWheelHSVColorModelCommand::CHueAsWheelHSVColorModelCommand ()
{
        ...
}

        int
CHueAsWheelHSVColorModelCommand::basic_CmdFlags ()
{
        ...
}

        bool
CHueAsWheelHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
        ...
}

        bool
CHueAsWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
        ...
}

enum
{
       ...
};

        void
CHueAsWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
        ...
}

        LxResult
CHueAsWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
{
       ...
}

This code block implements the same basic set of functions for the rest of the basic commands plus the atrui_UIHints function, which creates some relevant ui hints.

enum
{
       ...
};

const int PRESET_HSV_WHEEL	= 0;

static LXtTextValueHint hint_hsvWheel[] = {
        ...
        };

CWheelHSVColorModelCommand::CWheelHSVColorModelCommand ()
{
        ...
}

        int
CWheelHSVColorModelCommand::basic_CmdFlags ()
{
       ...
}

        bool
CWheelHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
       ...
}

        bool
CWheelHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
       ...
}

        void
CWheelHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
        ...
}

        LxResult
CWheelHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
{
       ...
}

        void
CWheelHSVColorModelCommand::atrui_UIHints (
        unsigned int		 index,
        CLxUser_UIHints		&hints)
{
}

/*
 * ---------------------------------------------------------------------------
 * CRuleHSVColorModelCommand
 */

enum
{
        ...
};

const int PRESET_HSV_RULE		= 0;

static LXtTextValueHint hint_hsvRule[] = {
        ...
        };

CRuleHSVColorModelCommand::CRuleHSVColorModelCommand ()
{
        ...
}

        int
CRuleHSVColorModelCommand::basic_CmdFlags ()
{
        ...
}

        bool
CRuleHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
       ...
}

        bool
CRuleHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
       ...
}

        void
CRuleHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
        ...
}

        LxResult
CRuleHSVColorModelCommand::cmd_Query (
        unsigned int	 index,
        ILxUnknownID	 vaQuery)
{
        ...
}

        void
CRuleHSVColorModelCommand::atrui_UIHints (
        unsigned int		 index,
        CLxUser_UIHints		&hints)
{
}


/*
 * ---------------------------------------------------------------------------
 * CRuleAdjustHSVColorModelCommand
 */

enum
{
       ...
};

/*
 * Preset rule adjust values vary by rule.
 */
const double DEG2RAD = 0.017453292519943295769236907684886;

const double PRESET_HSV_RULE_ADJUST_COMPLEMENTARY	= 180.0 * DEG2RAD;
const double PRESET_HSV_RULE_ADJUST_ANALOGOUS		= 30.0 * DEG2RAD;
const double PRESET_HSV_RULE_ADJUST_TRIADIC		= 120.0 * DEG2RAD;
const double PRESET_HSV_RULE_ADJUST_TETRADIC		= 45.0 * DEG2RAD;
const double PRESET_HSV_RULE_ADJUST_COMPOUND		= 30.0 * DEG2RAD;

CRuleAdjustHSVColorModelCommand::CRuleAdjustHSVColorModelCommand ()
{
        ...
}

        int
CRuleAdjustHSVColorModelCommand::basic_CmdFlags ()
{
        ...
}

        bool
CRuleAdjustHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
       ...
}

        bool
CRuleAdjustHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
        ...
}

        void
CRuleAdjustHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
       ...
}

        LxResult
CRuleAdjustHSVColorModelCommand::cmd_Query (
        unsigned int	 index,
        ILxUnknownID	 vaQuery)
{
        ...
}

        void
CRuleAdjustHSVColorModelCommand::atrui_UIHints (
        unsigned int		 index,
        CLxUser_UIHints		&hints)
{
        ...
}


/*
 * ---------------------------------------------------------------------------
 * CLevelsHSVColorModelCommand
 */

enum
{
       ...
};

const int PRESET_HSV_LEVELS		= 11;

CLevelsHSVColorModelCommand::CLevelsHSVColorModelCommand ()
{
        ...
}

        int
CLevelsHSVColorModelCommand::basic_CmdFlags ()
{
        ...
}

        bool
CLevelsHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
        ...
}

        bool
CLevelsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
       ...
}

        void
CLevelsHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
       ...
}

        LxResult
CLevelsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
{
       ...
}

        void
CLevelsHSVColorModelCommand::atrui_UIHints (
        unsigned int		 index,
        CLxUser_UIHints		&hints)
{
       ...
}


/*
 * ---------------------------------------------------------------------------
 * CSaveAsPresetsHSVColorModelCommand
 */

enum
{
        ...
};

CSaveAsPresetsHSVColorModelCommand::CSaveAsPresetsHSVColorModelCommand ()
{
        ...
}

        int
CSaveAsPresetsHSVColorModelCommand::basic_CmdFlags ()
{
       ...
}

        bool
CSaveAsPresetsHSVColorModelCommand::basic_Notifier (
        int			 index,
        string			&name,
        string			&args)
{
       ...
}

        bool
CSaveAsPresetsHSVColorModelCommand::basic_Enable (CLxUser_Message &msg)
{
       ...
}

/*
 * Query a series of color.value commands, to retrieve the selected
 * base color's component values, from which the rule-based color
 * swatches will be built.
 */
        static bool
QueryColorValueCmd (
        HSVColor		&baseColor)
{
        ...
}

        static bool
QueryPBViewPathCmd (
        string		&path)
{
       ...
}

/*
 * Execute the color.presetSaveWithModel commmand,
 * to generate a preset for the given swatch.
 */
        static void
ExecuteHSVPresetSaveWithModelCmd (
        const HSVColor		&hsvColor,
        unsigned		 swatchIndex,
        string			&swatchPath)
{
       ...
}

        void
CSaveAsPresetsHSVColorModelCommand::cmd_Execute (unsigned int flags)
{
       ...
}

        LxResult
CSaveAsPresetsHSVColorModelCommand::cmd_Query (unsigned int index, ILxUnknownID vaQuery)
{
        ...
}

        void
CSaveAsPresetsHSVColorModelCommand::atrui_UIHints (
        unsigned int		 index,
        CLxUser_UIHints		&hints)
{
       ...
}

This code block implements all the functions for the CHSVColorModel model object class. The utility of each specific function I described above in documenting their declaration.

LXtTagInfoDesc	 CHSVColorModel::descInfo[] = {
        { LXsLOD_CLASSLIST,	LXa_COLORMODEL		},
        { LXsSRV_USERNAME,	"HSV"			},
        { LXsSRV_LOGSUBSYSTEM,	SERVER_HSV_COLOR_MODEL	},
        { 0 }
};

/*
 * The minimum margin in pixels on all sides.
 */
const float HUE_WHEEL_MARGIN		= 5.0f;

/*
 * The percentage of the major dimension to use for rule-based swatches. 
 */
const float MINIMUM_SWATCH_SIZE	= 0.15f;

/*
 * Aspect ratio.
 */
enum {
        WHEEL_ASPECT_HORIZONTAL,
        WHEEL_ASPECT_VERTICAL
};

struct Metrics
{
       ...
};

        static void
ResizeWheelAndRuleSwatches (
        unsigned	 sliceWidth,
        unsigned	 sliceHeight,
        Metrics		&metrics)
{
       ...
}

/*
 * Return whether or not the given image (X, Y) coordinates are
 * tracking within a swatch.
 */
        static bool
TrackSwatch (
        Metrics		&metrics,
        unsigned	 xAxis,
        unsigned	 yAxis,
        unsigned	 imageWidth,
        unsigned	 imageHeight,
        unsigned	 imageX,
        unsigned	 imageY,
        LXtFVector	 downVec,
        LXtFVector	 hsv)
{
       ...
}

CHSVColorModel::CHSVColorModel ()
        :
        rangeWorker(NULL)
{
       ...
}

CHSVColorModel::~CHSVColorModel ()
{
}

        int
CHSVColorModel::colm_NumComponents (void)
{
        return 3; // H, S, and V
}

        LxResult
CHSVColorModel::colm_ComponentType (
        unsigned	 componentIndex,
        const char	**type)
{
        ...
}

        LxResult
CHSVColorModel::colm_ComponentRange (
        unsigned	 componentIndex,
        float		*minValue,
        float		*maxValue)
{
       ...
}

        LxResult
CHSVColorModel::colm_ToRGB (
        const float	*hsv,
        float		*rgb)
{
       ...
}

        LxResult
CHSVColorModel::colm_FromRGB (
        const float	*rgb,
        float		*hsv)
{
        ...
}

#define LERP(a,l,h)  ((l) + (((h) - (l)) * (a)))
const float DEG2RADF = static_cast<float>(DEG2RAD);

/*
 * Remap an HSV hue such that red, yellow, and blue are triadic,
 * instead of red, green, and blue.
 */
        static inline float
HueRGBtoRYB (float hue)
{
       ...
}

/*
 * The inverse of HueRGBtoRYB.
 */
        static inline float
HueRYBtoRGB (float hue)
{
        ...
}

CHSVColorModelThreadRangeWorker::CHSVColorModelThreadRangeWorker ()
{
}

CHSVColorModelThreadRangeWorker::~CHSVColorModelThreadRangeWorker ()
{
}

typedef struct st_HSVColorModelDrawSlice_env
{
        ...
} HSVColorModelDrawSlice_env;

        LxResult
CHSVColorModelThreadRangeWorker::rngw_Execute (
        int		 index,
        void		*sharedData)
{
        ...
}

        LxResult
CHSVColorModel::colm_DrawSlice (
        ILxUnknownID	 image,
        unsigned	 xAxis,
        unsigned	 yAxis,
        const float	*vec)
{
        ...
}

class RGBColor
{
    ...
};

class Point2D
{
    ...
};

        LxResult
CHSVColorModel::colm_DrawSliceMarker (
        ILxUnknownID	 image,
        unsigned	 xAxis,
        unsigned	 yAxis,
        const float	*downVec,
        const float	*hsv)
{
        ...
}

        LxResult
CHSVColorModel::colm_CanSliceBeReused (
        unsigned	  xAxis,
        unsigned	  yAxis,
        const float	 *oldVec,
        const float	 *newVec)
{
        ...
}

/*
 * Calculate imgX and imgY in [0, imgW], [0, imgH], from hsv color
 * components on the plane specified by xAxis, yAxis.
 */
        LxResult
CHSVColorModel::colm_ToSlicePos (
        unsigned	 xAxis,
        unsigned	 yAxis,
        unsigned	 imgW,
        unsigned	 imgH,
        const float	*hsv,
        unsigned	*imgX,
        unsigned	*imgY)
{
        ...
}

/*
 * Calculate color model components hsv using imgX and imgY in [0, 1],
 * on the plane specified by xAxis, yAxis.
 *
 * NOTE: The other axis (the one that is neither x nor y) component value
 *       should already be set by the last bar selection or the initial
 *       color load.
 */
        LxResult
CHSVColorModel::colm_FromSlicePos (
        unsigned	 xAxis,
        unsigned	 yAxis,
        unsigned	 imgW,
        unsigned	 imgH,
        unsigned	 imgX,
        unsigned	 imgY,
        float		*downVec,
        float		*hsv)
{
        ...
}

/*
 * Return a clean vector so the color picker can drawn the horizontal
 * strip properly.  For hue, this is 0, 1, 1, for saturation we set the
 * value to 1 but leave the rest alone, and for value we set the hue to zero.
 */
        LxResult
CHSVColorModel::colm_StripBaseVector (
        unsigned	 axis,
        int		 dynamic,
        float		*hsv)
{
       ...
}

        bool
CHSVColorModel::HueAxisOnStrip ()
{
        ...
}

        bool
CHSVColorModel::HueAsWheel ()
{
        ...
}

        unsigned
CHSVColorModel::Wheel ()
{
        ...
}

        unsigned
CHSVColorModel::Rule ()
{
        ...
}

        float
CHSVColorModel::RuleAdjust ()
{
        ...
}

        float
CHSVColorModel::PresetRuleAdjust ()
{
        ...
}

        unsigned
CHSVColorModel::Levels ()
{
        ...
}

        unsigned
CHSVColorModel::SwatchCount ()
{
        ...
}

        void
CHSVColorModel::BuildSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
        ...
}

/*
 * Selected color and its opposite.
 */
        void
CHSVColorModel::BuildComplementarySwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
       ...
}

/*
 * Adjacent colors.
 */
        void
CHSVColorModel::BuildAnalogousSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
        ...
}

/*
 * Three colors at 120 degree stops.
 */
        void
CHSVColorModel::BuildTriadicSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
       ...
}

/*
 * Four colors at 45 degree stops.
 */
        void
CHSVColorModel::BuildTetradicSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
        ...
}

/*
 * Five colors at 30 and 45 degree stops.
 */
        void
CHSVColorModel::BuildCompoundSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
        ...
}

/*
 * Variations by tint.
 */
        void
CHSVColorModel::BuildTintsSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
     ...
}

/*
 * Variations by shade.
 */
        void
CHSVColorModel::BuildShadesSwatches (
        const HSVColor		&baseColor,
        vector<HSVColor>	&swatchColors,
        unsigned		&baseColorIndex)
{
     ...
}

This code block implements the functions of the CHSVColorModelThreadRangeWorker class

CHSVColorModelThreadRangeWorker::~CHSVColorModelThreadRangeWorker ()
{
}

typedef struct st_HSVColorModelDrawSlice_env
{
        ...
} HSVColorModelDrawSlice_env;

        LxResult
CHSVColorModelThreadRangeWorker::rngw_Execute (
        int		 index,
        void		*sharedData)
{ 
      ...
}