Color Adjustment 2.0 (#351)

* Rename test to test123

* Delete test123

* New color Ajustment

Trilinear interpolation between the 8 corners of the color cube (black, red, green, blue, cyan, magenta, yellow, white)

* Renaming

* overloading getadjustmentX()

* Renaming

* Additional renaming

* Added more RgbChannel

* Added more colors to channelAdjustment

* Added additional colors

* Added additional colors

* Added additional colors

* Added additional color adjustments

* Update MultiColorAdjustment.cpp

* Fixed black adjustment

* Color config in array form

config/hyperion.config.json.commented

@@ -45,8 +45,11 @@
 	///      * 'id'     : The unique identifier of the channel adjustments (eg 'device_1')
 	///      * 'leds'   : The indices (or index ranges) of the leds to which this channel adjustment applies
 	///            (eg '0-5, 9, 11, 12-17'). The indices are zero based.
-	///  * 'pureRed'/'pureGreen'/'pureBlue' : The manipulation in the Red-Green-Blue color domain with the 
+	///      * 'black'/'white'/'pureRed'/'pureGreen'/'pureBlue'/'cyan'/'magenta'/'yellow' : 
-	///                           following tuning parameters for each channel:
+	///            The manipulation in the Red-Green-Blue color domain with the following parameters for each color:
+	///            - 'redChannel'     
+	///            - 'greenChannel'
+	///            - 'blueChannel'
 	///  * 'transform_enable'   : true/false enables/disables this transform section
 	///  * 'transform_v4l_only' : if enabled and set to true, then transform is only for v4l devices
 	///  * 'transform'
@@ -73,24 +76,14 @@
 			{
 				"id"   : "default",
 				"leds" : "*",
-				"pureRed" :
+				"black"   : [0,0,0],
-				{
+				"white"   : [255,255,255],
-					"redChannel"   : 255,
+				"red"     : [255,0,0],
-					"greenChannel" : 0,
+				"green"   : [0,255,0],
-					"blueChannel"  : 0
+				"blue"    : [0,0,255],
-				},
+				"cyan"    : [0,255,255],
-				"pureGreen" :
+				"magenta" : [255,0,255],
-				{
+				"yellow"  : [255,255,0]
-					"redChannel"   : 0,
-					"greenChannel" : 255,
-					"blueChannel"  : 0
-				},
-				"pureBlue" :
-				{
-					"redChannel"   : 0,
-					"greenChannel" : 0,
-					"blueChannel"  : 255
-				}
 			}
 		],
 		"transform_enable" : true,

config/hyperion.config.json.default

@@ -28,24 +28,14 @@
 			{
 				"id"   : "default",
 				"leds" : "*",
-				"pureRed" :
+				"black"   : [0,0,0],
-				{
+				"white"   : [255,255,255],
-					"redChannel"   : 255,
+				"red"     : [255,0,0],
-					"greenChannel" : 0,
+				"green"   : [0,255,0],
-					"blueChannel"  : 0
+				"blue"    : [0,0,255],
-				},
+				"cyan"    : [0,255,255],
-				"pureGreen" :
+				"magenta" : [255,0,255],
-				{
+				"yellow"  : [255,255,0]
-					"redChannel"   : 0,
-					"greenChannel" : 255,
-					"blueChannel"  : 0
-				},
-				"pureBlue" :
-				{
-					"redChannel"   : 0,
-					"greenChannel" : 0,
-					"blueChannel"  : 255
-				}
 			}
 		],
 		"transform_enable" : true,

include/hyperion/ColorAdjustment.h

@@ -13,10 +13,20 @@ public:
 	/// Unique identifier for this color transform
 	std::string _id;
 	
-	/// The RED-Channel (RGB) adjustment
+	/// The BLACK (RGB-Channel) adjustment
+	RgbChannelAdjustment _rgbBlackAdjustment;
+	/// The WHITE (RGB-Channel) adjustment
+	RgbChannelAdjustment _rgbWhiteAdjustment;
+	/// The RED (RGB-Channel) adjustment
 	RgbChannelAdjustment _rgbRedAdjustment;
-	/// The GREEN-Channel (RGB) transform
+	/// The GREEN (RGB-Channel) adjustment
 	RgbChannelAdjustment _rgbGreenAdjustment;
-	/// The BLUE-Channel (RGB) transform
+	/// The BLUE (RGB-Channel) adjustment
 	RgbChannelAdjustment _rgbBlueAdjustment;
+	/// The CYAN (RGB-Channel) adjustment
+	RgbChannelAdjustment _rgbCyanAdjustment;
+	/// The MAGENTA (RGB-Channel) adjustment
+	RgbChannelAdjustment _rgbMagentaAdjustment;
+	/// The YELLOW (RGB-Channel) adjustment
+	RgbChannelAdjustment _rgbYellowAdjustment;
 };

include/hyperion/Hyperion.h

@@ -64,7 +64,7 @@ public:
 	///
 	enum RgbChannel
 	{
-		RED, GREEN, BLUE, INVALID
+		BLACK, WHITE, RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, INVALID
 	};
 
 	///
@@ -303,7 +303,7 @@ public:
 	static HslTransform * createHslTransform(const QJsonObject & hslConfig);
 	static RgbChannelTransform * createRgbChannelTransform(const QJsonObject& colorConfig);
 	static RgbChannelAdjustment * createRgbChannelCorrection(const QJsonObject& colorConfig);
-	static RgbChannelAdjustment * createRgbChannelAdjustment(const QJsonObject& colorConfig, const RgbChannel color);
+	static RgbChannelAdjustment * createRgbChannelAdjustment(const QJsonArray& colorConfig, const RgbChannel color);
 
 	static LinearColorSmoothing * createColorSmoothing(const QJsonObject & smoothingConfig, LedDevice* leddevice);
 	static MessageForwarder * createMessageForwarder(const QJsonObject & forwarderConfig);

include/utils/RgbChannelAdjustment.h

@@ -47,9 +47,9 @@ public:
 	/// Transform the given array value
 	/// @param input The input color bytes
 	/// @return The corrected byte value
-	uint8_t adjustmentR(uint8_t inputR) const;
+	uint8_t getAdjustmentR(uint8_t inputR) const;
-	uint8_t adjustmentG(uint8_t inputG) const;
+	uint8_t getAdjustmentG(uint8_t inputG) const;
-	uint8_t adjustmentB(uint8_t inputB) const;
+	uint8_t getAdjustmentB(uint8_t inputB) const;
 
 
 private:

libsrc/hyperion/Hyperion.cpp

@@ -91,20 +91,45 @@ ColorAdjustment * Hyperion::createColorAdjustment(const QJsonObject & adjustment
 {
 	const std::string id = adjustmentConfig["id"].toString("default").toStdString();
 	
-	RgbChannelAdjustment * redAdjustment   = createRgbChannelAdjustment(adjustmentConfig["pureRed"].toObject(),RED);
+	// QT5.4 needed
-	RgbChannelAdjustment * greenAdjustment = createRgbChannelAdjustment(adjustmentConfig["pureGreen"].toObject(),GREEN);
+	//~ RgbChannelAdjustment * blackAdjustment   = createRgbChannelAdjustment(adjustmentConfig["black"].  toArray(QJsonArray({"0","0","0"      })));
-	RgbChannelAdjustment * blueAdjustment  = createRgbChannelAdjustment(adjustmentConfig["pureBlue"].toObject(),BLUE);
+	//~ RgbChannelAdjustment * whiteAdjustment   = createRgbChannelAdjustment(adjustmentConfig["white"].  toArray(QJsonArray({"255","255","255"})));
+	//~ RgbChannelAdjustment * redAdjustment     = createRgbChannelAdjustment(adjustmentConfig["red"].    toArray(QJsonArray({"255","0","0"    })));
+	//~ RgbChannelAdjustment * greenAdjustment   = createRgbChannelAdjustment(adjustmentConfig["green"].  toArray(QJsonArray({"0","255","0"    })));
+	//~ RgbChannelAdjustment * blueAdjustment    = createRgbChannelAdjustment(adjustmentConfig["blue"].   toArray(QJsonArray({"0","0","255"    })));
+	//~ RgbChannelAdjustment * cyanAdjustment    = createRgbChannelAdjustment(adjustmentConfig["cyan"].   toArray(QJsonArray({"0","255","255"  })));
+	//~ RgbChannelAdjustment * magentaAdjustment = createRgbChannelAdjustment(adjustmentConfig["magenta"].toArray(QJsonArray({"255","0","255"  })));
+	//~ RgbChannelAdjustment * yellowAdjustment  = createRgbChannelAdjustment(adjustmentConfig["yellow"]. toArray(QJsonArray({"255","255","0"  })));
+	
+	RgbChannelAdjustment * blackAdjustment   = createRgbChannelAdjustment(adjustmentConfig["black"].toArray(),BLACK);
+	RgbChannelAdjustment * whiteAdjustment   = createRgbChannelAdjustment(adjustmentConfig["white"].toArray(),WHITE);
+	RgbChannelAdjustment * redAdjustment     = createRgbChannelAdjustment(adjustmentConfig["pureRed"].toArray(),RED);
+	RgbChannelAdjustment * greenAdjustment   = createRgbChannelAdjustment(adjustmentConfig["pureGreen"].toArray(),GREEN);
+	RgbChannelAdjustment * blueAdjustment    = createRgbChannelAdjustment(adjustmentConfig["pureBlue"].toArray(),BLUE);
+	RgbChannelAdjustment * cyanAdjustment    = createRgbChannelAdjustment(adjustmentConfig["cyan"].toArray(),CYAN);
+	RgbChannelAdjustment * magentaAdjustment = createRgbChannelAdjustment(adjustmentConfig["magenta"].toArray(),MAGENTA);
+	RgbChannelAdjustment * yellowAdjustment  = createRgbChannelAdjustment(adjustmentConfig["yellow"].toArray(),YELLOW);
 	
 	ColorAdjustment * adjustment = new ColorAdjustment();
 	adjustment->_id = id;
+	adjustment->_rgbBlackAdjustment   = *blackAdjustment;
+	adjustment->_rgbWhiteAdjustment   = *whiteAdjustment;
 	adjustment->_rgbRedAdjustment     = *redAdjustment;
 	adjustment->_rgbGreenAdjustment   = *greenAdjustment;
 	adjustment->_rgbBlueAdjustment    = *blueAdjustment;
+	adjustment->_rgbCyanAdjustment    = *cyanAdjustment;
+	adjustment->_rgbMagentaAdjustment = *magentaAdjustment;
+	adjustment->_rgbYellowAdjustment  = *yellowAdjustment;
 
 	// Cleanup the allocated individual adjustments
+	delete blackAdjustment;
+	delete whiteAdjustment;
 	delete redAdjustment;
 	delete greenAdjustment;
 	delete blueAdjustment;
+	delete cyanAdjustment;
+	delete magentaAdjustment;
+	delete yellowAdjustment;
 	
 	return adjustment;
 }
@@ -288,26 +313,56 @@ RgbChannelTransform* Hyperion::createRgbChannelTransform(const QJsonObject& colo
 	return transform;
 }
 
-RgbChannelAdjustment* Hyperion::createRgbChannelAdjustment(const QJsonObject& colorConfig, const RgbChannel color)
+RgbChannelAdjustment* Hyperion::createRgbChannelAdjustment(const QJsonArray& colorConfig, const RgbChannel color)
 {
 	int varR=0, varG=0, varB=0;
-	if (color == RED) 
+	if (color == BLACK) 
 	{
-		varR = colorConfig["redChannel"].toInt(255);
+		varR = colorConfig[0].toInt(0);
-		varG = colorConfig["greenChannel"].toInt(0);
+		varG = colorConfig[1].toInt(0);
-		varB = colorConfig["blueChannel"].toInt(0);
+		varB = colorConfig[2].toInt(0);
+	}
+	else if (color == WHITE)
+	{
+		varR = colorConfig[0].toInt(255);
+		varG = colorConfig[1].toInt(255);
+		varB = colorConfig[2].toInt(255);
+	}		
+	else if (color == RED) 
+	{
+		varR = colorConfig[0].toInt(255);
+		varG = colorConfig[1].toInt(0);
+		varB = colorConfig[2].toInt(0);
 	}
 	else if (color == GREEN)
 	{
-		varR = colorConfig["redChannel"].toInt(0);
+		varR = colorConfig[0].toInt(0);
-		varG = colorConfig["greenChannel"].toInt(255);
+		varG = colorConfig[1].toInt(255);
-		varB = colorConfig["blueChannel"].toInt(0);
+		varB = colorConfig[2].toInt(0);
 	}		
 	else if (color == BLUE)
 	{
-		varR = colorConfig["redChannel"].toInt(0);
+		varR = colorConfig[0].toInt(0);
-		varG = colorConfig["greenChannel"].toInt(0);
+		varG = colorConfig[1].toInt(0);
-		varB = colorConfig["blueChannel"].toInt(255);
+		varB = colorConfig[2].toInt(255);
+	}
+	else if (color == CYAN) 
+	{
+		varR = colorConfig[0].toInt(0);
+		varG = colorConfig[1].toInt(255);
+		varB = colorConfig[2].toInt(255);
+	}
+	else if (color == MAGENTA)
+	{
+		varR = colorConfig[0].toInt(255);
+		varG = colorConfig[1].toInt(0);
+		varB = colorConfig[2].toInt(255);
+	}		
+	else if (color == YELLOW)
+	{
+		varR = colorConfig[0].toInt(255);
+		varG = colorConfig[1].toInt(255);
+		varB = colorConfig[2].toInt(0);
 	}
 	
 	RgbChannelAdjustment* adjustment = new RgbChannelAdjustment(varR, varG, varB);

libsrc/hyperion/MultiColorAdjustment.cpp

@@ -85,38 +85,54 @@ void MultiColorAdjustment::applyAdjustment(std::vector<ColorRgb>& ledColors)
 		}
 		ColorRgb& color = ledColors[i];
 		
-		int RR = adjustment->_rgbRedAdjustment.adjustmentR(color.red);
+		uint32_t nrng = (uint32_t) (255-color.red)*(255-color.green);
-		int RG = color.red > color.green ? adjustment->_rgbRedAdjustment.adjustmentG(color.red-color.green) : 0;
+		uint32_t rng  = (uint32_t) (color.red)    *(255-color.green);
-		int RB = color.red > color.blue ? adjustment->_rgbRedAdjustment.adjustmentB(color.red-color.blue) : 0;
+		uint32_t nrg  = (uint32_t) (255-color.red)*(color.green);
+		uint32_t rg   = (uint32_t) (color.red)    *(color.green);
 		
-		int GR = color.green > color.red ? adjustment->_rgbGreenAdjustment.adjustmentR(color.green-color.red) : 0;
+		uint8_t black   = nrng*(255-color.blue)/65025;
-		int GG = adjustment->_rgbGreenAdjustment.adjustmentG(color.green);
+		uint8_t red     = rng *(255-color.blue)/65025;
-		int GB = color.green > color.blue ? adjustment->_rgbGreenAdjustment.adjustmentB(color.green-color.blue) : 0;
+		uint8_t green   = nrg *(255-color.blue)/65025;
+		uint8_t blue    = nrng*(color.blue)    /65025;
+		uint8_t cyan    = nrg *(color.blue)    /65025;
+		uint8_t magenta = rng *(color.blue)    /65025;
+		uint8_t yellow  = rg  *(255-color.blue)/65025;
+		uint8_t white   = rg  *(color.blue)    /65025;
 		
-		int BR = color.blue > color.red ? adjustment->_rgbBlueAdjustment.adjustmentR(color.blue-color.red) : 0;
+		uint8_t OR = adjustment->_rgbBlackAdjustment.getAdjustmentR(black);
-		int BG = color.blue > color.green ? adjustment->_rgbBlueAdjustment.adjustmentG(color.blue-color.green) : 0;
+		uint8_t OG = adjustment->_rgbBlackAdjustment.getAdjustmentG(black);
-		int BB = adjustment->_rgbBlueAdjustment.adjustmentB(color.blue);
+		uint8_t OB = adjustment->_rgbBlackAdjustment.getAdjustmentB(black);
 		
-		int ledR = RR + GR + BR;
+		uint8_t RR = adjustment->_rgbRedAdjustment.getAdjustmentR(red);
-		int maxR = (int)adjustment->_rgbRedAdjustment.getAdjustmentR();
+		uint8_t	RG = adjustment->_rgbRedAdjustment.getAdjustmentG(red);
-		int ledG = RG + GG + BG;
+		uint8_t	RB = adjustment->_rgbRedAdjustment.getAdjustmentB(red);
-		int maxG = (int)adjustment->_rgbGreenAdjustment.getAdjustmentG();
-		int ledB = RB + GB + BB;
-		int maxB = (int)adjustment->_rgbBlueAdjustment.getAdjustmentB();
 		
-		if (ledR > maxR)
+		uint8_t GR = adjustment->_rgbGreenAdjustment.getAdjustmentR(green);
-		  color.red = (uint8_t)maxR;
+		uint8_t	GG = adjustment->_rgbGreenAdjustment.getAdjustmentG(green);
-		else
+		uint8_t	GB = adjustment->_rgbGreenAdjustment.getAdjustmentB(green);
-		  color.red = (uint8_t)ledR;
 		
-		if (ledG > maxG)
+		uint8_t BR = adjustment->_rgbBlueAdjustment.getAdjustmentR(blue);
-		  color.green = (uint8_t)maxG;
+		uint8_t	BG = adjustment->_rgbBlueAdjustment.getAdjustmentG(blue);
-		else
+		uint8_t	BB = adjustment->_rgbBlueAdjustment.getAdjustmentB(blue);
-		  color.green = (uint8_t)ledG;
 		
-		if (ledB > maxB)
+		uint8_t CR = adjustment->_rgbCyanAdjustment.getAdjustmentR(cyan);
-		  color.blue = (uint8_t)maxB;
+		uint8_t CG = adjustment->_rgbCyanAdjustment.getAdjustmentG(cyan);
-		else
+		uint8_t CB = adjustment->_rgbCyanAdjustment.getAdjustmentB(cyan);
-		  color.blue = (uint8_t)ledB;
+		
+		uint8_t MR = adjustment->_rgbMagentaAdjustment.getAdjustmentR(magenta);
+		uint8_t MG = adjustment->_rgbMagentaAdjustment.getAdjustmentG(magenta);
+		uint8_t MB = adjustment->_rgbMagentaAdjustment.getAdjustmentB(magenta);
+		
+		uint8_t YR = adjustment->_rgbYellowAdjustment.getAdjustmentR(yellow);
+		uint8_t YG = adjustment->_rgbYellowAdjustment.getAdjustmentG(yellow);
+		uint8_t YB = adjustment->_rgbYellowAdjustment.getAdjustmentB(yellow);
+		
+		uint8_t WR = adjustment->_rgbWhiteAdjustment.getAdjustmentR(white);
+		uint8_t WG = adjustment->_rgbWhiteAdjustment.getAdjustmentG(white);
+		uint8_t WB = adjustment->_rgbWhiteAdjustment.getAdjustmentB(white);
+		
+		color.red   = OR + RR + GR + BR + CR + MR + YR + WR;
+		color.green = OG + RG + GG + BG + CG + MG + YG + WG;
+		color.blue  = OB + RB + GB + BB + CB + MB + YB + WB;
 	}
 }

libsrc/hyperion/schemas/hyperion.schema-2.json

@@ -131,95 +131,109 @@
 								"type" : "string",
 								"required" : true
 							},
-							"pureRed" :
+							"black" :
 							{
-								"type":"object",
+								"type" : "array",
 								"required" : true,
-								"properties":
+								"default": [0,0,0],
-								{
+								"items" : {
-									"redChannel" :
-									{
 									"type" : "integer",
-										"required" : true,
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"greenChannel" :
+								"minItems" : 3,
+								"maxItems" : 3
+							},
+							"white" :
 							{
-										"type": "integer",
+								"type" : "array",
 								"required" : true,
+								"default": [255,255,255],
+								"items" : {
+									"type" : "integer",
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"blueChannel" :
+								"minItems" : 3,
-									{
+								"maxItems" : 3
-										"type": "integer",
-										"required" : true,
-										"minimum": 0,
-										"maximum": 255
-									}
 							},
-								"additionalProperties" : false
+							"red" :
-							},
-							"pureGreen" :
 							{
-								"type":"object",
+								"type" : "array",
 								"required" : true,
-								"properties":
+								"default": [255,0,0],
-								{
+								"items" : {
-									"redChannel" :
-									{
 									"type" : "integer",
-										"required" : true,
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"greenChannel" :
+								"minItems" : 3,
+								"maxItems" : 3
+							},
+							"green" :
 							{
-										"type": "integer",
+								"type" : "array",
 								"required" : true,
+								"default": [0,255,0],
+								"items" : {
+									"type" : "integer",
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"blueChannel" :
+								"minItems" : 3,
-									{
+								"maxItems" : 3
-										"type": "integer",
-										"required" : true,
-										"minimum": 0,
-										"maximum": 255
-									}
 							},
-								"additionalProperties" : false
+							"blue" :
-							},
-							"pureBlue" :
 							{
-								"type":"object",
+								"type" : "array",
 								"required" : true,
-								"properties":
+								"default": [0,0,255],
-								{
+								"items" : {
-									"redChannel" :
-									{
 									"type" : "integer",
-										"required" : true,
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"greenChannel" :
+								"minItems" : 3,
+								"maxItems" : 3
+							},
+							"cyan" :
 							{
-										"type": "integer",
+								"type" : "array",
 								"required" : true,
+								"default": [0,255,255],
+								"items" : {
+									"type" : "integer",
 									"minimum" : 0,
 									"maximum" : 255
 								},
-									"blueChannel" :
+								"minItems" : 3,
+								"maxItems" : 3
+							},
+							"magenta" :
 							{
-										"type": "integer",
+								"type" : "array",
 								"required" : true,
+								"default": [255,0,255],
+								"items" : {
+									"type" : "integer",
 									"minimum" : 0,
 									"maximum" : 255
-									}
 								},
-								"additionalProperties" : false
+								"minItems" : 3,
+								"maxItems" : 3
+							},
+							"yellow" :
+							{
+								"type" : "array",
+								"required" : true,
+								"default": [255,255,0],
+								"items" : {
+									"type" : "integer",
+									"minimum" : 0,
+									"maximum" : 255
+								},
+								"minItems" : 3,
+								"maxItems" : 3
 							}
 						},
 						"additionalProperties" : false

libsrc/utils/RgbChannelAdjustment.cpp

@@ -58,17 +58,17 @@ void RgbChannelAdjustment::setAdjustmentB(uint8_t adjustB)
 	setAdjustment(_adjust[RED], _adjust[GREEN], adjustB);
 }
 
-uint8_t RgbChannelAdjustment::adjustmentR(uint8_t inputR) const
+uint8_t RgbChannelAdjustment::getAdjustmentR(uint8_t inputR) const
 {
 	return _mapping[RED][inputR];
 }
 
-uint8_t RgbChannelAdjustment::adjustmentG(uint8_t inputG) const
+uint8_t RgbChannelAdjustment::getAdjustmentG(uint8_t inputG) const
 {
 	return _mapping[GREEN][inputG];
 }
 
-uint8_t RgbChannelAdjustment::adjustmentB(uint8_t inputB) const
+uint8_t RgbChannelAdjustment::getAdjustmentB(uint8_t inputB) const
 {
 	return _mapping[BLUE][inputB];
 }