diff --git a/assets/webconfig/i18n/en.json b/assets/webconfig/i18n/en.json index bb3453b8..8cca4c5d 100644 --- a/assets/webconfig/i18n/en.json +++ b/assets/webconfig/i18n/en.json @@ -279,7 +279,7 @@ "edt_conf_color_heading_title": "Color Calibration", "edt_conf_color_id_expl": "User given name", "edt_conf_color_id_title": "ID", - "edt_conf_color_imageToLedMappingType_expl": "Overwrites the LED area assignment of your LED layout if it's not \"multicolor\"", + "edt_conf_color_imageToLedMappingType_expl": "Overwrites the LED area assignment of your LED layout if it's not \"Mean Color Simple\"", "edt_conf_color_imageToLedMappingType_title": "LED area assignment", "edt_conf_color_leds_expl": "Assign this adjustment to all LEDs (*) or just some (0-24).", "edt_conf_color_leds_title": "LED index", @@ -320,6 +320,7 @@ "edt_conf_enum_color": "Color", "edt_conf_enum_custom": "Custom", "edt_conf_enum_decay": "Decay", + "edt_conf_enum_delay": "Delay only", "edt_conf_enum_dl_error": "Error", "edt_conf_enum_dl_informational": "Informational", "edt_conf_enum_dl_nodebug": "No Debug output", @@ -328,6 +329,7 @@ "edt_conf_enum_dl_verbose1": "Verbosity level 1", "edt_conf_enum_dl_verbose2": "Verbosity level 2", "edt_conf_enum_dl_verbose3": "Verbosity level 3", + "edt_conf_enum_dominant_color": "Dominant Color - per LED", "edt_conf_enum_effect": "Effect", "edt_conf_enum_gbr": "GBR", "edt_conf_enum_grb": "GRB", @@ -338,7 +340,8 @@ "edt_conf_enum_logsilent": "Silent", "edt_conf_enum_logverbose": "Verbose", "edt_conf_enum_logwarn": "Warning", - "edt_conf_enum_multicolor_mean": "Multicolor", + "edt_conf_enum_multicolor_mean": "Mean Color Simple - per LED", + "edt_conf_enum_multicolor_mean_squared": "Mean Color Squared - per LED", "edt_conf_enum_please_select": "Please Select", "edt_conf_enum_rbg": "RBG", "edt_conf_enum_rgb": "RGB", @@ -348,7 +351,7 @@ "edt_conf_enum_transeffect_sudden": "Sudden", "edt_conf_enum_udp_ddp": "DDP", "edt_conf_enum_udp_raw": "RAW", - "edt_conf_enum_unicolor_mean": "Unicolor", + "edt_conf_enum_unicolor_mean": "Mean Color Image - applied to all LEDs", "edt_conf_fbs_heading_title": "Flatbuffers Server", "edt_conf_fbs_timeout_expl": "If no data is received for the given period, the component will be (soft) disabled.", "edt_conf_fbs_timeout_title": "Timeout", diff --git a/include/hyperion/ImageProcessor.h b/include/hyperion/ImageProcessor.h index bc192668..c96e888c 100644 --- a/include/hyperion/ImageProcessor.h +++ b/include/hyperion/ImageProcessor.h @@ -98,12 +98,12 @@ public: } /// - /// Processes the image to a list of led colors. This will update the size of the buffer-image - /// if required and call the image-to-leds mapping to determine the mean color per led. + /// Processes the image to a list of LED colors. This will update the size of the buffer-image + /// if required and call the image-to-LEDs mapping to determine the color per LED. /// - /// @param[in] image The image to translate to led values + /// @param[in] image The image to translate to LED values /// - /// @return The color value per led + /// @return The color value per LED /// template std::vector process(const Image& image) @@ -120,8 +120,17 @@ public: // Create a result vector and call the 'in place' function switch (_mappingType) { - case 1: colors = _imageToLeds->getUniLedColor(image); break; - default: colors = _imageToLeds->getMeanLedColor(image); + case 1: + colors = _imageToLeds->getUniLedColor(image); + break; + case 2: + colors = _imageToLeds->getMeanLedColorSqrt(image); + break; + case 3: + colors = _imageToLeds->getDominantLedColor(image); + break; + default: + colors = _imageToLeds->getMeanLedColor(image); } } else @@ -136,8 +145,8 @@ public: /// /// Determines the led colors of the image in the buffer. /// - /// @param[in] image The image to translate to led values - /// @param[out] ledColors The color value per led + /// @param[in] image The image to translate to LED values + /// @param[out] ledColors The color value per LED /// template void process(const Image& image, std::vector& ledColors) @@ -153,8 +162,17 @@ public: // Determine the mean or uni colors of each led (using the existing mapping) switch (_mappingType) { - case 1: _imageToLeds->getUniLedColor(image, ledColors); break; - default: _imageToLeds->getMeanLedColor(image, ledColors); + case 1: + _imageToLeds->getUniLedColor(image, ledColors); + break; + case 2: + _imageToLeds->getMeanLedColorSqrt(image, ledColors); + break; + case 3: + _imageToLeds->getDominantLedColor(image, ledColors); + break; + default: + _imageToLeds->getMeanLedColor(image, ledColors); } } else @@ -164,9 +182,9 @@ public: } /// - /// Get the hscan and vscan parameters for a single led + /// Get the hscan and vscan parameters for a single LED /// - /// @param[in] led Index of the led + /// @param[in] led Index of the LED /// @param[out] hscanBegin begin of the hscan /// @param[out] hscanEnd end of the hscan /// @param[out] vscanBegin begin of the hscan @@ -208,9 +226,6 @@ private: // Construct a new buffer and mapping _imageToLeds = new hyperion::ImageToLedsMap(image.width(), image.height(), border.horizontalSize, border.verticalSize, _ledString.leds()); } - - //Debug(Logger::getInstance("BLACKBORDER"), "CURRENT BORDER TYPE: unknown=%d hor.size=%d vert.size=%d", - // border.unknown, border.horizontalSize, border.verticalSize ); } } @@ -228,7 +243,7 @@ private: /// The mapping of image-pixels to LEDs hyperion::ImageToLedsMap* _imageToLeds; - /// Type of image 2 led mapping + /// Type of image to LED mapping int _mappingType; /// Type of last requested user type int _userMappingType; diff --git a/include/hyperion/ImageToLedsMap.h b/include/hyperion/ImageToLedsMap.h index 779082ab..9607d5a6 100644 --- a/include/hyperion/ImageToLedsMap.h +++ b/include/hyperion/ImageToLedsMap.h @@ -1,9 +1,10 @@ - -#pragma once +#ifndef IMAGETOLEDSMAP_H +#define IMAGETOLEDSMAP_H // STL includes #include #include +#include // hyperion-utils includes #include @@ -14,18 +15,17 @@ namespace hyperion { - /// - /// The ImageToLedsMap holds a mapping of indices into an image to leds. It can be used to - /// calculate the average (or mean) color per led for a specific region. + /// The ImageToLedsMap holds a mapping of indices into an image to LEDs. It can be used to + /// calculate the average (aka mean) or dominant color per LED for a given region. /// class ImageToLedsMap { public: /// - /// Constructs an mapping from the absolute indices in an image to each led based on the border - /// definition given in the list of leds. The map holds absolute indices to any given image, + /// Constructs an mapping from the absolute indices in an image to each LED based on the border + /// definition given in the list of LEDs. The map holds absolute indices to any given image, /// provided that it is row-oriented. /// The mapping is created purely on size (width and height). The given borders are excluded /// from indexing. @@ -37,10 +37,10 @@ namespace hyperion /// @param[in] leds The list with led specifications /// ImageToLedsMap( - const unsigned width, - const unsigned height, - const unsigned horizontalBorder, - const unsigned verticalBorder, + const int width, + const int height, + const int horizontalBorder, + const int verticalBorder, const std::vector & leds); /// @@ -48,25 +48,25 @@ namespace hyperion /// /// @return The width of the indexed image [pixels] /// - unsigned width() const; + int width() const; /// /// Returns the height of the indexed image /// /// @return The height of the indexed image [pixels] /// - unsigned height() const; + int height() const; - unsigned horizontalBorder() const { return _horizontalBorder; } - unsigned verticalBorder() const { return _verticalBorder; } + int horizontalBorder() const { return _horizontalBorder; } + int verticalBorder() const { return _verticalBorder; } /// - /// Determines the mean color for each led using the mapping the image given + /// Determines the mean color for each LED using the LED area mapping given /// at construction. /// /// @param[in] image The image from which to extract the led colors /// - /// @return ledColors The vector containing the output + /// @return The vector containing the output /// template std::vector getMeanLedColor(const Image & image) const @@ -77,17 +77,15 @@ namespace hyperion } /// - /// Determines the mean color for each led using the mapping the image given + /// Determines the mean color for each LED using the LED area mapping given /// at construction. /// - /// @param[in] image The image from which to extract the led colors + /// @param[in] image The image from which to extract the LED colors /// @param[out] ledColors The vector containing the output /// template void getMeanLedColor(const Image & image, std::vector & ledColors) const { - // Sanity check for the number of leds - //assert(_colorsMap.size() == ledColors.size()); if(_colorsMap.size() != ledColors.size()) { Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size()); @@ -104,12 +102,52 @@ namespace hyperion } /// - /// Determines the uni color for each led using the mapping the image given + /// Determines the mean color squared for each LED using the LED area mapping given /// at construction. /// /// @param[in] image The image from which to extract the led colors /// - /// @return ledColors The vector containing the output + /// @return The vector containing the output + /// + template + std::vector getMeanLedColorSqrt(const Image & image) const + { + std::vector colors(_colorsMap.size(), ColorRgb{0,0,0}); + getMeanLedColorSqrt(image, colors); + return colors; + } + + /// + /// Determines the mean color squared for each LED using the LED area mapping given + /// at construction. + /// + /// @param[in] image The image from which to extract the LED colors + /// @param[out] ledColors The vector containing the output + /// + template + void getMeanLedColorSqrt(const Image & image, std::vector & ledColors) const + { + if(_colorsMap.size() != ledColors.size()) + { + Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size()); + return; + } + + // Iterate each led and compute the mean + auto led = ledColors.begin(); + for (auto colors = _colorsMap.begin(); colors != _colorsMap.end(); ++colors, ++led) + { + const ColorRgb color = calcMeanColorSqrt(image, *colors); + *led = color; + } + } + + /// + /// Determines the mean color of the image and assigns it to all LEDs + /// + /// @param[in] image The image from which to extract the led color + /// + /// @return The vector containing the output /// template std::vector getUniLedColor(const Image & image) const @@ -120,57 +158,95 @@ namespace hyperion } /// - /// Determines the uni color for each led using the mapping the image given - /// at construction. + /// Determines the mean color of the image and assigns it to all LEDs /// - /// @param[in] image The image from which to extract the led colors + /// @param[in] image The image from which to extract the LED colors /// @param[out] ledColors The vector containing the output /// template void getUniLedColor(const Image & image, std::vector & ledColors) const { - // Sanity check for the number of leds - // assert(_colorsMap.size() == ledColors.size()); if(_colorsMap.size() != ledColors.size()) { Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size()); return; } - // calculate uni color const ColorRgb color = calcMeanColor(image); + //Update all LEDs with same color std::fill(ledColors.begin(),ledColors.end(), color); } + /// + /// Determines the dominant color for each LED using the LED area mapping given + /// at construction. + /// + /// @param[in] image The image from which to extract the LED color + /// + /// @return The vector containing the output + /// + template + std::vector getDominantLedColor(const Image & image) const + { + std::vector colors(_colorsMap.size(), ColorRgb{0,0,0}); + getDominantLedColor(image, colors); + return colors; + } + + /// + /// Determines the dominant color for each LED using the LED area mapping given + /// at construction. + /// + /// @param[in] image The image from which to extract the LED colors + /// @param[out] ledColors The vector containing the output + /// + template + void getDominantLedColor(const Image & image, std::vector & ledColors) const + { + // Sanity check for the number of LEDs + if(_colorsMap.size() != ledColors.size()) + { + Debug(Logger::getInstance("HYPERION"), "ImageToLedsMap: colorsMap.size != ledColors.size -> %d != %d", _colorsMap.size(), ledColors.size()); + return; + } + + // Iterate each led and compute the dominant color + auto led = ledColors.begin(); + for (auto colors = _colorsMap.begin(); colors != _colorsMap.end(); ++colors, ++led) + { + const ColorRgb color = calculateDominantColor(image, *colors); + *led = color; + } + } + private: /// The width of the indexed image - const unsigned _width; + const int _width; /// The height of the indexed image - const unsigned _height; + const int _height; - const unsigned _horizontalBorder; + const int _horizontalBorder; - const unsigned _verticalBorder; + const int _verticalBorder; /// The absolute indices into the image for each led - std::vector> _colorsMap; + std::vector> _colorsMap; /// - /// Calculates the 'mean color' of the given list. This is the mean over each color-channel + /// Calculates the 'mean color' over the given image. This is the mean over each color-channel /// (red, green, blue) /// /// @param[in] image The image a section from which an average color must be computed - /// @param[in] colors The list with colors + /// @param[in] pixels The list of pixel indices for the given image to be evaluated/// /// /// @return The mean of the given list of colors (or black when empty) /// template - ColorRgb calcMeanColor(const Image & image, const std::vector & colors) const + ColorRgb calcMeanColor(const Image & image, const std::vector & pixels) const { - const auto colorVecSize = colors.size(); - - if (colorVecSize == 0) + const auto pixelNum = pixels.size(); + if (pixelNum == 0) { return ColorRgb::BLACK; } @@ -179,20 +255,20 @@ namespace hyperion uint_fast32_t cummRed = 0; uint_fast32_t cummGreen = 0; uint_fast32_t cummBlue = 0; - const auto& imgData = image.memptr(); - for (const unsigned colorOffset : colors) + const auto& imgData = image.memptr(); + for (const int pixelOffset : pixels) { - const auto& pixel = imgData[colorOffset]; + const auto& pixel = imgData[pixelOffset]; cummRed += pixel.red; cummGreen += pixel.green; cummBlue += pixel.blue; } // Compute the average of each color channel - const uint8_t avgRed = uint8_t(cummRed/colorVecSize); - const uint8_t avgGreen = uint8_t(cummGreen/colorVecSize); - const uint8_t avgBlue = uint8_t(cummBlue/colorVecSize); + const uint8_t avgRed = uint8_t(cummRed/pixelNum); + const uint8_t avgGreen = uint8_t(cummGreen/pixelNum); + const uint8_t avgBlue = uint8_t(cummBlue/pixelNum); // Return the computed color return {avgRed, avgGreen, avgBlue}; @@ -213,11 +289,11 @@ namespace hyperion uint_fast32_t cummRed = 0; uint_fast32_t cummGreen = 0; uint_fast32_t cummBlue = 0; - const unsigned imageSize = image.width() * image.height(); + const unsigned pixelNum = image.width() * image.height(); const auto& imgData = image.memptr(); - for (unsigned idx=0; idx + ColorRgb calcMeanColorSqrt(const Image & image, const std::vector & pixels) const + { + const auto pixelNum = pixels.size(); + if (pixelNum == 0) + { + return ColorRgb::BLACK; + } + + // Accumulate the squared sum of each separate color channel + uint_fast32_t cummRed = 0; + uint_fast32_t cummGreen = 0; + uint_fast32_t cummBlue = 0; + + const auto& imgData = image.memptr(); + + for (const int colorOffset : pixels) + { + const auto& pixel = imgData[colorOffset]; + + cummRed += pixel.red * pixel.red; + cummGreen += pixel.green * pixel.green; + cummBlue += pixel.blue * pixel.blue; + } + + // Compute the average of each color channel + const uint8_t avgRed = uint8_t(std::min(std::lround(sqrt(static_cast(cummRed/pixelNum))), 255L)); + const uint8_t avgGreen = uint8_t(std::min(std::lround(sqrt(static_cast(cummGreen/pixelNum))), 255L)); + const uint8_t avgBlue = uint8_t(std::min(std::lround(sqrt(static_cast(cummBlue/pixelNum))), 255L)); + + // Return the computed color + return {avgRed, avgGreen, avgBlue}; + } + + /// + /// Calculates the 'mean color' squared over the given image. This is the mean over each color-channel + /// (red, green, blue) + /// + /// @param[in] image The image a section from which an average color must be computed + /// + /// @return The mean of the given list of colors (or black when empty) + /// + template + ColorRgb calcMeanColorSqrt(const Image & image) const + { + // Accumulate the squared sum of each separate color channel + uint_fast32_t cummRed = 0; + uint_fast32_t cummGreen = 0; + uint_fast32_t cummBlue = 0; + + const unsigned pixelNum = image.width() * image.height(); + const auto& imgData = image.memptr(); + + for (int idx=0; idx(cummRed/pixelNum)))); + const uint8_t avgGreen = uint8_t(std::lround(sqrt(static_cast(cummGreen/pixelNum)))); + const uint8_t avgBlue = uint8_t(std::lround(sqrt(static_cast(cummBlue/pixelNum)))); + + // Return the computed color + return {avgRed, avgGreen, avgBlue}; + } + + /// + /// Calculates the 'dominant color' of an image area defined by a list of pixel indices + /// + /// @param[in] image The image for which a dominant color is to be computed + /// @param[in] pixels The list of pixel indices for the given image to be evaluated + /// + /// @return The image area's dominant color or black, if no pixel indices provided + /// + template + ColorRgb calculateDominantColor(const Image & image, const std::vector & pixels) const + { + ColorRgb dominantColor {ColorRgb::BLACK}; + + const auto pixelNum = pixels.size(); + if (pixelNum > 0) + { + const auto& imgData = image.memptr(); + + QMap colorDistributionMap; + int count = 0; + for (const int pixelOffset : pixels) + { + QRgb color = imgData[pixelOffset].rgb(); + if (colorDistributionMap.contains(color)) { + colorDistributionMap[color] = colorDistributionMap[color] + 1; + } + else { + colorDistributionMap[color] = 1; + } + + int colorsFound = colorDistributionMap[color]; + if (colorsFound > count) { + dominantColor.setRgb(color); + count = colorsFound; + } + } + } + return dominantColor; + } + + /// + /// Calculates the 'dominant color' of an image + /// + /// @param[in] image The image for which a dominant color is to be computed + /// + /// @return The image's dominant color + /// + template + ColorRgb calculateDominantColor(const Image & image) const + { + const unsigned pixelNum = image.width() * image.height(); + + std::vector pixels(pixelNum); + std::iota(pixels.begin(), pixels.end(), 0); + + return calculateDominantColor(image, pixels); + } }; } // end namespace hyperion + +#endif // IMAGETOLEDSMAP_H diff --git a/include/utils/ColorRgb.h b/include/utils/ColorRgb.h index 901b000c..b9a91038 100644 --- a/include/utils/ColorRgb.h +++ b/include/utils/ColorRgb.h @@ -6,6 +6,7 @@ #include #include +#include /// /// Plain-Old-Data structure containing the red-green-blue color specification. Size of the @@ -52,6 +53,18 @@ struct ColorRgb return a; } + QRgb rgb() const + { + return qRgb(red,green,blue); + } + + void setRgb(QRgb rgb) + { + red = static_cast(qRed(rgb)); + green = static_cast(qGreen(rgb)); + blue = static_cast(qBlue(rgb)); + } + QString toQString() const { return QString("(%1,%2,%3)").arg(red).arg(green).arg(blue); diff --git a/libsrc/hyperion/ImageProcessor.cpp b/libsrc/hyperion/ImageProcessor.cpp index f527a3a9..ad0a902a 100644 --- a/libsrc/hyperion/ImageProcessor.cpp +++ b/libsrc/hyperion/ImageProcessor.cpp @@ -7,23 +7,47 @@ // Blacborder includes #include +#include + using namespace hyperion; // global transform method int ImageProcessor::mappingTypeToInt(const QString& mappingType) { if (mappingType == "unicolor_mean" ) + { return 1; - + } + else if (mappingType == "multicolor_mean_squared" ) + { + return 2; + } + else if (mappingType == "dominant_color" ) + { + return 3; + } return 0; } // global transform method QString ImageProcessor::mappingTypeToStr(int mappingType) { - if (mappingType == 1 ) - return "unicolor_mean"; + QString typeText; + switch (mappingType) { + case 1: + typeText = "unicolor_mean"; + break; + case 2: + typeText = "multicolor_mean_squared"; + break; + case 3: + typeText = "dominant_color"; + break; + default: + typeText = "multicolor_mean"; + break; + } - return "multicolor_mean"; + return typeText; } ImageProcessor::ImageProcessor(const LedString& ledString, Hyperion* hyperion) diff --git a/libsrc/hyperion/ImageToLedsMap.cpp b/libsrc/hyperion/ImageToLedsMap.cpp index 783fdedd..a87e7e20 100644 --- a/libsrc/hyperion/ImageToLedsMap.cpp +++ b/libsrc/hyperion/ImageToLedsMap.cpp @@ -3,10 +3,10 @@ using namespace hyperion; ImageToLedsMap::ImageToLedsMap( - unsigned width, - unsigned height, - unsigned horizontalBorder, - unsigned verticalBorder, + int width, + int height, + int horizontalBorder, + int verticalBorder, const std::vector& leds) : _width(width) , _height(height) @@ -23,10 +23,13 @@ ImageToLedsMap::ImageToLedsMap( // Reserve enough space in the map for the leds _colorsMap.reserve(leds.size()); - const unsigned xOffset = _verticalBorder; - const unsigned actualWidth = _width - 2 * _verticalBorder; - const unsigned yOffset = _horizontalBorder; - const unsigned actualHeight = _height - 2 * _horizontalBorder; + const int xOffset = _verticalBorder; + const int actualWidth = _width - 2 * _verticalBorder; + const int yOffset = _horizontalBorder; + const int actualHeight = _height - 2 * _horizontalBorder; + + size_t totalCount = 0; + size_t totalCapacity = 0; for (const Led& led : leds) { @@ -38,10 +41,10 @@ ImageToLedsMap::ImageToLedsMap( } // Compute the index boundaries for this led - unsigned minX_idx = xOffset + unsigned(qRound(actualWidth * led.minX_frac)); - unsigned maxX_idx = xOffset + unsigned(qRound(actualWidth * led.maxX_frac)); - unsigned minY_idx = yOffset + unsigned(qRound(actualHeight * led.minY_frac)); - unsigned maxY_idx = yOffset + unsigned(qRound(actualHeight * led.maxY_frac)); + int minX_idx = xOffset + int32_t(qRound(actualWidth * led.minX_frac)); + int maxX_idx = xOffset + int32_t(qRound(actualWidth * led.maxX_frac)); + int minY_idx = yOffset + int32_t(qRound(actualHeight * led.minY_frac)); + int maxY_idx = yOffset + int32_t(qRound(actualHeight * led.maxY_frac)); // make sure that the area is at least a single led large minX_idx = qMin(minX_idx, xOffset + actualWidth - 1); @@ -56,31 +59,43 @@ ImageToLedsMap::ImageToLedsMap( } // Add all the indices in the above defined rectangle to the indices for this led - const auto maxYLedCount = qMin(maxY_idx, yOffset+actualHeight); - const auto maxXLedCount = qMin(maxX_idx, xOffset+actualWidth); + const int maxYLedCount = qMin(maxY_idx, yOffset+actualHeight); + const int maxXLedCount = qMin(maxX_idx, xOffset+actualWidth); - std::vector ledColors; - ledColors.reserve((size_t) maxXLedCount*maxYLedCount); + const int realYLedCount = qAbs(maxYLedCount - minY_idx); + const int realXLedCount = qAbs(maxXLedCount - minX_idx); - for (unsigned y = minY_idx; y < maxYLedCount; ++y) + size_t totalSize = realYLedCount* realXLedCount; + + std::vector ledColors; + ledColors.reserve(totalSize); + + for (int y = minY_idx; y < maxYLedCount; ++y) { - for (unsigned x = minX_idx; x < maxXLedCount; ++x) + for (int x = minX_idx; x < maxXLedCount; ++x) { - ledColors.push_back(y*width + x); + ledColors.push_back( y * width + x); } } // Add the constructed vector to the map _colorsMap.push_back(ledColors); + + totalCount += ledColors.size(); + totalCapacity += ledColors.capacity(); + } + Debug(Logger::getInstance("HYPERION"), "Total index number is: %d (memory: %d). image size: %d x %d, LED areas: %d", + totalCount, totalCapacity, width, height, leds.size()); + } -unsigned ImageToLedsMap::width() const +int ImageToLedsMap::width() const { return _width; } -unsigned ImageToLedsMap::height() const +int ImageToLedsMap::height() const { return _height; } diff --git a/libsrc/hyperion/schema/schema-color.json b/libsrc/hyperion/schema/schema-color.json index abe39560..739a47ee 100644 --- a/libsrc/hyperion/schema/schema-color.json +++ b/libsrc/hyperion/schema/schema-color.json @@ -9,10 +9,10 @@ "type" : "string", "required" : true, "title" : "edt_conf_color_imageToLedMappingType_title", - "enum" : ["multicolor_mean", "unicolor_mean"], + "enum" : ["multicolor_mean", "unicolor_mean", "multicolor_mean_squared", "dominant_color"], "default" : "multicolor_mean", "options" : { - "enum_titles" : ["edt_conf_enum_multicolor_mean", "edt_conf_enum_unicolor_mean"] + "enum_titles" : ["edt_conf_enum_multicolor_mean", "edt_conf_enum_unicolor_mean", "edt_conf_enum_multicolor_mean_squared", "edt_conf_enum_dominant_color"] }, "propertyOrder" : 1 },