Merge branch 'HEAD' of https://github.com/tvdzwan/hyperion.git

libsrc/hyperion/Hyperion.cpp

@@ -14,6 +14,7 @@
 #include "LedDeviceWs2801.h"
 #include "LedDeviceTest.h"
 #include "ColorTransform.h"
+#include "HsvTransform.h"
 
 using namespace hyperion;
 
@@ -44,6 +45,11 @@ LedDevice* constructDevice(const Json::Value& deviceConfig)
 	return device;
 }
 
+HsvTransform * createHsvTransform(const Json::Value & hsvConfig)
+{
+	return new HsvTransform(hsvConfig["saturationGain"].asDouble(), hsvConfig["valueGain"].asDouble());
+}
+
 ColorTransform* createColorTransform(const Json::Value& colorConfig)
 {
 	const double threshold  = colorConfig["threshold"].asDouble();
@@ -102,74 +108,221 @@ Hyperion::Hyperion(const std::string& configFile) :
 }
 
 Hyperion::Hyperion(const Json::Value &jsonConfig) :
-	mLedString(createLedString(jsonConfig["leds"])),
-	mRedTransform(  createColorTransform(jsonConfig["color"]["red"])),
-	mGreenTransform(createColorTransform(jsonConfig["color"]["green"])),
-	mBlueTransform( createColorTransform(jsonConfig["color"]["blue"])),
-	mDevice(constructDevice(jsonConfig["device"])),
+	_ledString(createLedString(jsonConfig["leds"])),
+	_muxer(_ledString.leds().size()),
+	_hsvTransform(createHsvTransform(jsonConfig["color"]["hsv"])),
+	_redTransform(createColorTransform(jsonConfig["color"]["red"])),
+	_greenTransform(createColorTransform(jsonConfig["color"]["green"])),
+	_blueTransform(createColorTransform(jsonConfig["color"]["blue"])),
+	_device(constructDevice(jsonConfig["device"])),
 	_timer()
 {
-	ImageProcessorFactory::getInstance().init(mLedString);
+	ImageProcessorFactory::getInstance().init(_ledString);
 
 	_timer.setSingleShot(true);
 	QObject::connect(&_timer, SIGNAL(timeout()), this, SLOT(update()));
 
+	// initialize the leds
+	update();
 }
 
 
 Hyperion::~Hyperion()
 {
 	// Delete the Led-String
-	delete mDevice;
+	delete _device;
+
+	// delete he hsv transform
+	delete _hsvTransform;
 
 	// Delete the color-transform
-	delete mBlueTransform;
-	delete mGreenTransform;
-	delete mRedTransform;
+	delete _blueTransform;
+	delete _greenTransform;
+	delete _redTransform;
 }
 
 unsigned Hyperion::getLedCount() const
 {
-	return mLedString.leds().size();
+	return _ledString.leds().size();
 }
 
-void Hyperion::setValue(int priority, std::vector<RgbColor>& ledColors, const int timeout_ms)
+void Hyperion::setColor(int priority, RgbColor & color, const int timeout_ms)
 {
-	// Apply the transform to each led and color-channel
-	for (RgbColor& color : ledColors)
-	{
-		color.red   = mRedTransform->transform(color.red);
-		color.green = mGreenTransform->transform(color.green);
-		color.blue  = mBlueTransform->transform(color.blue);
-	}
+	// create led output
+	std::vector<RgbColor> ledColors(_ledString.leds().size(), color);
 
+	// set colors
+	setColors(priority, ledColors, timeout_ms);
+}
+
+void Hyperion::setColors(int priority, std::vector<RgbColor>& ledColors, const int timeout_ms)
+{
 	if (timeout_ms > 0)
 	{
 		const uint64_t timeoutTime = QDateTime::currentMSecsSinceEpoch() + timeout_ms;
-		mMuxer.setInput(priority, ledColors, timeoutTime);
+		_muxer.setInput(priority, ledColors, timeoutTime);
 	}
 	else
 	{
-		mMuxer.setInput(priority, ledColors);
+		_muxer.setInput(priority, ledColors);
 	}
 
-	if (priority == mMuxer.getCurrentPriority())
+	if (priority == _muxer.getCurrentPriority())
 	{
 		update();
 	}
 }
 
+void Hyperion::setTransform(Hyperion::Transform transform, Hyperion::Color color, double value)
+{
+	// select the transform of the requested color
+	ColorTransform * t = nullptr;
+	switch (color)
+	{
+	case RED:
+		t = _redTransform;
+		break;
+	case GREEN:
+		t = _greenTransform;
+		break;
+	case BLUE:
+		t = _blueTransform;
+		break;
+	default:
+		break;
+	}
+
+	// set transform value
+	switch (transform)
+	{
+	case SATURATION_GAIN:
+		_hsvTransform->setSaturationGain(value);
+		break;
+	case VALUE_GAIN:
+		_hsvTransform->setValueGain(value);
+		break;
+	case THRESHOLD:
+		assert (t != nullptr);
+		t->setThreshold(value);
+		break;
+	case GAMMA:
+		assert (t != nullptr);
+		t->setGamma(value);
+		break;
+	case BLACKLEVEL:
+		assert (t != nullptr);
+		t->setBlacklevel(value);
+		break;
+	case WHITELEVEL:
+		assert (t != nullptr);
+		t->setWhitelevel(value);
+		break;
+	default:
+		assert(false);
+	}
+
+	// update the led output
+	update();
+}
+
+void Hyperion::clear(int priority)
+{
+	if (_muxer.hasPriority(priority))
+	{
+		_muxer.clearInput(priority);
+
+		// update leds if necessary
+		if (priority < _muxer.getCurrentPriority());
+		{
+			update();
+		}
+	}
+}
+
+void Hyperion::clearall()
+{
+	_muxer.clearAll();
+
+	// update leds
+	update();
+}
+
+double Hyperion::getTransform(Hyperion::Transform transform, Hyperion::Color color) const
+{
+	// select the transform of the requested color
+	ColorTransform * t = nullptr;
+	switch (color)
+	{
+	case RED:
+		t = _redTransform;
+		break;
+	case GREEN:
+		t = _greenTransform;
+		break;
+	case BLUE:
+		t = _blueTransform;
+		break;
+	default:
+		break;
+	}
+
+	// set transform value
+	switch (transform)
+	{
+	case SATURATION_GAIN:
+		return _hsvTransform->getSaturationGain();
+	case VALUE_GAIN:
+		return _hsvTransform->getValueGain();
+	case THRESHOLD:
+		assert (t != nullptr);
+		return t->getThreshold();
+	case GAMMA:
+		assert (t != nullptr);
+		return t->getGamma();
+	case BLACKLEVEL:
+		assert (t != nullptr);
+		return t->getBlacklevel();
+	case WHITELEVEL:
+		assert (t != nullptr);
+		return t->getWhitelevel();
+	default:
+		assert(false);
+	}
+
+	return 999.0;
+}
+
+QList<int> Hyperion::getActivePriorities() const
+{
+	return _muxer.getPriorities();
+}
+
+const Hyperion::InputInfo &Hyperion::getPriorityInfo(const int priority) const
+{
+	return _muxer.getInputInfo(priority);
+}
+
 void Hyperion::update()
 {
 	// Update the muxer, cleaning obsolete priorities
-	mMuxer.setCurrentTime(QDateTime::currentMSecsSinceEpoch());
+	_muxer.setCurrentTime(QDateTime::currentMSecsSinceEpoch());
 
 	// Obtain the current priority channel
-	int priority = mMuxer.getCurrentPriority();
-	const PriorityMuxer::InputInfo & priorityInfo  = mMuxer.getInputInfo(priority);
+	int priority = _muxer.getCurrentPriority();
+	const PriorityMuxer::InputInfo & priorityInfo  = _muxer.getInputInfo(priority);
+
+	// Apply the transform to each led and color-channel
+	std::vector<RgbColor> ledColors(priorityInfo.ledColors);
+	for (RgbColor& color : ledColors)
+	{
+		_hsvTransform->transform(color.red, color.green, color.blue);
+		color.red   = _redTransform->transform(color.red);
+		color.green = _greenTransform->transform(color.green);
+		color.blue  = _blueTransform->transform(color.blue);
+	}
 
 	// Write the data to the device
-	mDevice->write(priorityInfo.ledColors);
+	_device->write(ledColors);
 
 	// Start the timeout-timer
 	if (priorityInfo.timeoutTime_ms == -1)