Added simple QT-based grabber.

Moved ImageToLedsMap from include to libsrc.
Moved instantiation of objects to Hyperion (no JSON required outside this class).
This commit is contained in:
T. van der Zwan 2013-08-13 11:10:45 +02:00
parent 491d6ff608
commit 39b98386dd
32 changed files with 1065 additions and 508 deletions

View File

@ -1,7 +1,7 @@
# define the minimum cmake version (as required by cmake)
cmake_minimum_required(VERSION 2.8)
#set(CMAKE_TOOLCHAIN_FILE /opt/raspberrypi/Toolchain-RaspberryPi.cmake)
set(CMAKE_TOOLCHAIN_FILE /opt/raspberrypi/Toolchain-RaspberryPi.cmake)
# Define the main-project name
project(Hyperion)
@ -28,6 +28,15 @@ set(CMAKE_BUILD_TYPE "Release")
# enable C++11
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++0x -Wall")
# Configure the use of QT4
find_package(Qt4 COMPONENTS QtCore REQUIRED QUIET)
SET(QT_DONT_USE_QTGUI TRUE)
SET(QT_USE_QTCONSOLE TRUE)
include(${QT_USE_FILE})
add_definitions(${QT_DEFINITIONS})
link_directories(${CMAKE_FIND_ROOT_PATH}/lib/arm-linux-gnueabihf)
configure_file(bin/install_hyperion.sh ${LIBRARY_OUTPUT_PATH} @ONLY)
configure_file(config/hyperion.config.json ${LIBRARY_OUTPUT_PATH} @ONLY)
configure_file(config/hyperion.schema.json ${LIBRARY_OUTPUT_PATH} @ONLY)

View File

@ -0,0 +1,32 @@
#pragma once
// QT includes
#include <QObject>
#include <QTimer>
// Forward class declaration
class ImageProcessor;
class DispmanxFrameGrabber;
class DispmanxWrapper: public QObject
{
Q_OBJECT
public:
DispmanxWrapper();
virtual ~DispmanxWrapper();
public slots:
void start();
void action();
void stop();
private:
QTimer _timer;
DispmanxFrameGrabber* _frameGrabber;
ImageProcessor* _processor;
};

View File

@ -4,9 +4,14 @@
// hyperion-utils includes
#include <utils/RgbImage.h>
// Hyperion includes
#include <hyperion/LedString.h>
#include <hyperion/ImageToLedsMap.h>
#include <hyperion/LedDevice.h>
#include <hyperion/PriorityMuxer.h>
// Forward class declaration
namespace hyperion { class ColorTransform; }
class Hyperion
{
@ -15,27 +20,18 @@ public:
~Hyperion();
void setInputSize(const unsigned width, const unsigned height);
RgbImage& image()
{
return *mImage;
}
void commit();
void operator() (const RgbImage& inputImage);
void setColor(const RgbColor& color);
void setValue(int priority, std::vector<RgbColor> &ledColors);
private:
void applyTransform(std::vector<RgbColor>& colors) const;
LedString mLedString;
RgbImage* mImage;
PriorityMuxer mMuxer;
ImageToLedsMap mLedsMap;
hyperion::ColorTransform* mRedTransform;
hyperion::ColorTransform* mGreenTransform;
hyperion::ColorTransform* mBlueTransform;
LedDevice* mDevice;
};

View File

@ -0,0 +1,72 @@
#pragma once
// Utils includes
#include <utils/RgbImage.h>
#include <hyperion/LedString.h>
#include <hyperion/ImageProcessorFactory.h>
// Forward class declaration
namespace hyperion { class ImageToLedsMap;
class ColorTransform; }
/**
* The ImageProcessor translates an RGB-image to RGB-values for the leds. The processing is
* performed in two steps. First the average color per led-region is computed. Second a
* color-tranform is applied based on a gamma-correction.
*/
class ImageProcessor
{
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.
*
* @param[in] image The image to translate to led values
*
* @return The color value per led
*/
std::vector<RgbColor> process(const RgbImage& image);
// 'IN PLACE' processing functions
/**
* Specifies the width and height of 'incomming' images. This will resize the buffer-image to
* match the given size.
* NB All earlier obtained references will be invalid.
*
* @param[in] width The new width of the buffer-image
* @param[in] height The new height of the buffer-image
*/
void setSize(const unsigned width, const unsigned height);
/**
* Returns a reference of the underlying image-buffer. This can be used to write data directly
* into the buffer, avoiding a copy inside the process method.
*
* @return The reference of the underlying image-buffer.
*/
RgbImage& image();
/**
* Determines the led colors of the image in the buffer.
*
* @param[out] ledColors The color value per led
*/
void inplace_process(std::vector<RgbColor>& ledColors);
private:
friend class ImageProcessorFactory;
ImageProcessor(const LedString &ledString);
~ImageProcessor();
private:
const LedString mLedString;
RgbImage *mBuffer;
hyperion::ImageToLedsMap* mImageToLeds;
};

View File

@ -0,0 +1,26 @@
#pragma once
// STL includes
#include <memory>
// Jsoncpp includes
#include <json/json.h>
#include <hyperion/LedString.h>
// Forward class declaration
class ImageProcessor;
class ImageProcessorFactory
{
public:
static ImageProcessorFactory& getInstance();
public:
void init(const LedString& ledString);
ImageProcessor* newImageProcessor() const;
private:
LedString _ledString;
};

View File

@ -1,27 +0,0 @@
#pragma once
// hyperion-utils includes
#include <utils/RgbImage.h>
// hyperion includes
#include <hyperion/LedString.h>
class ImageToLedsMap
{
public:
ImageToLedsMap();
void createMapping(const RgbImage& image, const std::vector<Led>& leds);
std::vector<RgbColor> getMeanLedColor();
RgbColor findMeanColor(const std::vector<const RgbColor*>& colors);
std::vector<RgbColor> getMedianLedColor();
RgbColor findMedianColor(std::vector<const RgbColor*>& colors);
private:
std::vector<std::vector<const RgbColor*> > mColorsMap;
};

View File

@ -45,28 +45,16 @@ struct Led
class LedString
{
public:
static LedString construct(const Json::Value& ledConfig, const Json::Value& colorConfig);
static LedString construct(const Json::Value& ledConfig);
LedString();
~LedString();
std::vector<Led>& leds();
const std::vector<Led>& leds() const;
private:
std::vector<Led> mLeds;
public:
/**
* Color adjustements per color
*/
struct
{
/** The color gradient */
double gamma;
/** The color offset */
double adjust;
/** The minimum required level for the led to turn on */
double blacklevel;
} red, green, blue;
};

View File

@ -0,0 +1,55 @@
#pragma once
// STL includes
#include <vector>
#include <map>
#include <cstdint>
#include <limits>
// QT includes
#include <QMap>
// Utils includes
#include <utils/RgbColor.h>
// Hyperion includes
#include <hyperion/LedDevice.h>
class PriorityMuxer
{
public:
struct InputInfo
{
int priority;
int64_t timeoutTime_ms;
std::vector<RgbColor> ledColors;
};
PriorityMuxer();
~PriorityMuxer();
int getCurrentPriority() const;
bool hasPriority(const int priority) const;
QList<int> getPriorities() const;
const InputInfo& getInputInfo(const int priority) const;
void setInput(const int priority, const std::vector<RgbColor>& ledColors, const int64_t timeoutTime_ms=-1);
void clearInput(const int priority);
void clearAll();
void setCurrentTime(const int64_t& now);
private:
int mCurrentPriority;
QMap<int, InputInfo> mActiveInputs;
const static int MAX_PRIORITY = std::numeric_limits<int>::max();
};

View File

@ -5,7 +5,6 @@
#include <stdint.h>
#include <iostream>
// Forward class declaration
struct RgbColor;
@ -21,8 +20,12 @@ struct RgbColor
static RgbColor BLUE;
static RgbColor YELLOW;
static RgbColor WHITE;
};
static_assert(sizeof(RgbColor) == 3, "Incorrect size of RgbColor");
inline std::ostream& operator<<(std::ostream& os, const RgbColor& color)
{
os << "{" << unsigned(color.red) << "," << unsigned(color.green) << "," << unsigned(color.blue) << "}";

View File

@ -10,18 +10,22 @@ target_link_libraries(bob2hyperion
hyperion
hyperion-utils)
add_subdirectory(hyperion)
add_subdirectory(utils)
# Find the libPNG
find_package(PNG REQUIRED QUIET)
# Add additional includes dirs
include_directories(${PNG_INCLUDE_DIR})
if (PNG_FOUND)
# Add additional includes dirs
include_directories(${PNG_INCLUDE_DIR})
add_library(bob2hyperion-png SHARED
hyperion-png.cpp)
add_library(bob2hyperion-png SHARED
hyperion-png.cpp)
target_link_libraries(bob2hyperion-png
hyperion-png)
target_link_libraries(bob2hyperion-png
hyperion-png)
add_subdirectory(hyperionpng)
endif(PNG_FOUND)
add_subdirectory(hyperion)
add_subdirectory(hyperionpng)
add_subdirectory(utils)

View File

@ -51,7 +51,7 @@ void boblight_destroy(void* hyperion_ptr)
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
// Switch all leds to black (off)
raspiLight->setColor(RgbColor::BLACK);
// raspiLight->setColor(RgbColor::BLACK);
delete raspiLight;
@ -64,20 +64,20 @@ void boblight_setscanrange(void* hyperion_ptr, int width, int height)
syslog(LOG_INFO, "Configuring scan range [%dx%d]", width, height);
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
raspiLight->setInputSize(width, height);
// raspiLight->setInputSize(width, height);
}
void boblight_addpixelxy(void* hyperion_ptr, int x, int y, int* rgb)
{
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
const RgbColor color = {uint8_t(rgb[0]), uint8_t(rgb[1]), uint8_t(rgb[2])};
raspiLight->image().setPixel(x, y, color);
// raspiLight->image().setPixel(x, y, color);
}
int boblight_sendrgb(void* hyperion_ptr, int sync, int* outputused)
{
Hyperion* raspiLight = rasp_cast(hyperion_ptr);
raspiLight->commit();
// raspiLight->commit();
return 1;
}

View File

@ -1,22 +1,52 @@
# Find the BCM-package (VC control)
find_package(BCM REQUIRED)
include_directories(${BCM_INCLUDE_DIRS})
# Define the current source locations
SET(CURRENT_HEADER_DIR ${CMAKE_SOURCE_DIR}/include/hyperion)
SET(CURRENT_SOURCE_DIR ${CMAKE_SOURCE_DIR}/libsrc/hyperion)
add_library(hyperion
SET(Hyperion_HEADERS
${CURRENT_HEADER_DIR}/Hyperion.h
${CURRENT_HEADER_DIR}/LedDevice.h
${CURRENT_HEADER_DIR}/LedString.h
${CURRENT_HEADER_DIR}/ImageToLedsMap.h
${CURRENT_HEADER_DIR}/ImageProcessor.h
${CURRENT_HEADER_DIR}/ImageProcessorFactory.h
${CURRENT_HEADER_DIR}/PriorityMuxer.h
${CURRENT_HEADER_DIR}/DispmanxWrapper.h
${CURRENT_SOURCE_DIR}/DispmanxFrameGrabber.h
${CURRENT_SOURCE_DIR}/LedDeviceWs2801.h
${CURRENT_SOURCE_DIR}/LedDeviceWs2801.cpp
${CURRENT_SOURCE_DIR}/ImageToLedsMap.h
${CURRENT_SOURCE_DIR}/ColorTransform.h
)
SET(Hyperion_SOURCES
${CURRENT_SOURCE_DIR}/LedString.cpp
${CURRENT_SOURCE_DIR}/Hyperion.cpp
${CURRENT_SOURCE_DIR}/ImageToLedsMap.cpp
${CURRENT_SOURCE_DIR}/ColorTransform.h
${CURRENT_SOURCE_DIR}/ColorTransform.cpp
${CURRENT_SOURCE_DIR}/ImageProcessor.cpp
${CURRENT_SOURCE_DIR}/ImageProcessorFactory.cpp
${CURRENT_SOURCE_DIR}/PriorityMuxer.cpp
${CURRENT_SOURCE_DIR}/DispmanxWrapper.cpp
${CURRENT_SOURCE_DIR}/DispmanxFrameGrabber.cpp
${CURRENT_SOURCE_DIR}/LedDeviceWs2801.cpp
${CURRENT_SOURCE_DIR}/ImageToLedsMap.cpp
${CURRENT_SOURCE_DIR}/ColorTransform.cpp
)
QT4_WRAP_CPP(Hyperion_HEADERS_MOC ${Hyperion_HEADERS})
add_library(hyperion
${Hyperion_HEADERS}
${Hyperion_HEADERS_MOC}
${Hyperion_SOURCES}
)
target_link_libraries(hyperion
hyperion-utils)
hyperion-utils
${QT_LIBRARIES}
${BCM_LIBRARIES})

View File

@ -1,23 +1,26 @@
// STL includes
#include <cmath>
#include "ColorTransform.h"
using namespace hyperion;
ColorTransform::ColorTransform() :
_threshold(0),
_gamma(1.0),
_blacklevel(0.0),
_whitelevel(1.0)
_threshold(0),
_gamma(1.0),
_blacklevel(0.0),
_whitelevel(1.0)
{
initializeMapping();
initializeMapping();
}
ColorTransform::ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel) :
_threshold(threshold),
_gamma(gamma),
_blacklevel(blacklevel),
_whitelevel(whitelevel)
_threshold(threshold),
_gamma(gamma),
_blacklevel(blacklevel),
_whitelevel(whitelevel)
{
initializeMapping();
initializeMapping();
}
ColorTransform::~ColorTransform()
@ -26,77 +29,77 @@ ColorTransform::~ColorTransform()
double ColorTransform::getThreshold() const
{
return _threshold;
return _threshold;
}
void ColorTransform::setThreshold(double threshold)
{
_threshold = threshold;
initializeMapping();
_threshold = threshold;
initializeMapping();
}
double ColorTransform::getGamma() const
{
return _gamma;
return _gamma;
}
void ColorTransform::setGamma(double gamma)
{
_gamma = gamma;
initializeMapping();
_gamma = gamma;
initializeMapping();
}
double ColorTransform::getBlacklevel() const
{
return _blacklevel;
return _blacklevel;
}
void ColorTransform::setBlacklevel(double blacklevel)
{
_blacklevel = blacklevel;
initializeMapping();
_blacklevel = blacklevel;
initializeMapping();
}
double ColorTransform::getWhitelevel() const
{
return _whitelevel;
return _whitelevel;
}
void ColorTransform::setWhitelevel(double whitelevel)
{
_whitelevel = whitelevel;
initializeMapping();
_whitelevel = whitelevel;
initializeMapping();
}
void ColorTransform::initializeMapping()
{
// initialize the mapping as a linear array
for (int i = 0; i < 256; ++i)
{
double output = i / 255.0;
// initialize the mapping as a linear array
for (int i = 0; i < 256; ++i)
{
double output = i / 255.0;
// apply linear transform
if (output < _threshold)
{
output = 0.0;
}
// apply linear transform
if (output < _threshold)
{
output = 0.0;
}
// apply gamma correction
output = std::pow(output, _gamma);
// apply gamma correction
output = std::pow(output, _gamma);
// apply blacklevel and whitelevel
output = _blacklevel + (_whitelevel - _blacklevel) * output;
// apply blacklevel and whitelevel
output = _blacklevel + (_whitelevel - _blacklevel) * output;
// calc mapping
int mappingValue = output * 255;
if (mappingValue < 0)
{
mappingValue = 0;
}
else if (mappingValue > 255)
{
mappingValue = 255;
}
_mapping[i] = mappingValue;
}
// calc mapping
int mappingValue = output * 255;
if (mappingValue < 0)
{
mappingValue = 0;
}
else if (mappingValue > 255)
{
mappingValue = 255;
}
_mapping[i] = mappingValue;
}
}

View File

@ -1,6 +1,10 @@
#pragma once
#include "stdint.h"
// STL includes
#include <cstdint>
namespace hyperion
{
/// Transform for a single color byte value
///
@ -14,36 +18,38 @@
class ColorTransform
{
public:
ColorTransform();
ColorTransform(double threshold, double gamma, double whitelevel, double blacklevel);
~ColorTransform();
ColorTransform();
ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel);
~ColorTransform();
double getThreshold() const;
void setThreshold(double threshold);
double getThreshold() const;
void setThreshold(double threshold);
double getGamma() const;
void setGamma(double gamma);
double getGamma() const;
void setGamma(double gamma);
double getBlacklevel() const;
void setBlacklevel(double blacklevel);
double getBlacklevel() const;
void setBlacklevel(double blacklevel);
double getWhitelevel() const;
void setWhitelevel(double whitelevel);
double getWhitelevel() const;
void setWhitelevel(double whitelevel);
/// get the transformed value for the given byte value
uint8_t transform(uint8_t input) const
{
return _mapping[input];
}
/// get the transformed value for the given byte value
uint8_t transform(uint8_t input) const
{
return _mapping[input];
}
private:
void initializeMapping();
void initializeMapping();
private:
double _threshold;
double _gamma;
double _blacklevel;
double _whitelevel;
double _threshold;
double _gamma;
double _blacklevel;
double _whitelevel;
uint8_t _mapping[256];
uint8_t _mapping[256];
};
} // end namespace hyperion

View File

@ -0,0 +1,54 @@
#include "DispmanxFrameGrabber.h"
DispmanxFrameGrabber::DispmanxFrameGrabber(const unsigned width, const unsigned height) :
_display(0),
_resource(0),
_width(width),
_height(height)
{
// Initiase BCM
bcm_host_init();
// Open the connection to the displaydisplay
_display = vc_dispmanx_display_open(0);
int ret = vc_dispmanx_display_get_info(_display, &_info);
assert(ret == 0);
// Create the resources for capturing image
_resource = vc_dispmanx_resource_create(
VC_IMAGE_RGB888,
width,
height,
&_vc_image_ptr);
assert(_resource);
// Define the capture rectangle with the same size
vc_dispmanx_rect_set(&_rectangle, 0, 0, width, height);
_pitch = width * 3;
}
DispmanxFrameGrabber::~DispmanxFrameGrabber()
{
// Clean up resources
vc_dispmanx_resource_delete(_resource);
// Close the displaye
vc_dispmanx_display_close(_display);
// De-init BCM
bcm_host_deinit();
}
void DispmanxFrameGrabber::grabFrame(RgbImage& image)
{
// Sanity check of the given image size
assert(image.width() == _width && image.height() == _height);
void* image_ptr = image.memptr();
// Create the snapshot
vc_dispmanx_snapshot(_display, _resource, VC_IMAGE_ROT0);
// Read the snapshot into the memory (incl down-scaling)
vc_dispmanx_resource_read_data(_resource, &_rectangle, image_ptr, _pitch);
}

View File

@ -0,0 +1,35 @@
#pragma once
// BCM includes
#include <bcm_host.h>
// STL includes
#include <cstdint>
// Utils includes
#include <utils/RgbImage.h>
///
/// The DispmanxFrameGrabber grabs
///
class DispmanxFrameGrabber
{
public:
DispmanxFrameGrabber(const unsigned width, const unsigned height);
~DispmanxFrameGrabber();
void grabFrame(RgbImage& image);
private:
DISPMANX_DISPLAY_HANDLE_T _display;
DISPMANX_MODEINFO_T _info;
DISPMANX_RESOURCE_HANDLE_T _resource;
uint32_t _vc_image_ptr;
VC_RECT_T _rectangle;
unsigned _width;
unsigned _height;
uint32_t _pitch;
};

View File

@ -0,0 +1,46 @@
// QT includes
#include <QDebug>
#include <QDateTime>
// Hyperion includes
#include <hyperion/DispmanxWrapper.h>
#include <hyperion/ImageProcessorFactory.h>
// Local-Hyperion includes
#include "DispmanxFrameGrabber.h"
DispmanxWrapper::DispmanxWrapper() :
_timer(),
_processor(ImageProcessorFactory::getInstance().newImageProcessor()),
_frameGrabber(new DispmanxFrameGrabber(64, 64))
{
_timer.setInterval(100);
_timer.setSingleShot(false);
QObject::connect(&_timer, SIGNAL(timeout()), this, SLOT(action()));
}
DispmanxWrapper::~DispmanxWrapper()
{
delete _frameGrabber;
delete _processor;
}
void DispmanxWrapper::start()
{
_timer.start();
}
void DispmanxWrapper::action()
{
qDebug() << "[" << QDateTime::currentDateTimeUtc() << "] Grabbing frame";
RgbImage image(64, 64);
_frameGrabber->grabFrame(image);
//_processor->
}
void DispmanxWrapper::stop()
{
_timer.stop();
}

View File

@ -10,6 +10,9 @@
#include <hyperion/LedDevice.h>
#include "LedDeviceWs2801.h"
#include "ColorTransform.h"
using namespace hyperion;
LedDevice* constructDevice(const Json::Value& deviceConfig)
{
@ -34,9 +37,41 @@ LedDevice* constructDevice(const Json::Value& deviceConfig)
return device;
}
ColorTransform* createColorTransform(const Json::Value& colorConfig)
{
const double threshold = colorConfig["threshold"].asDouble();
const double gamma = colorConfig["gamma"].asDouble();
const double blacklevel = colorConfig["blacklevel"].asDouble();
const double whitelevel = colorConfig["whitelevel"].asDouble();
ColorTransform* transform = new ColorTransform(threshold, gamma, blacklevel, whitelevel);
return transform;
}
LedString createLedString(const Json::Value& ledsConfig)
{
LedString ledString;
for (const Json::Value& ledConfig : ledsConfig)
{
Led led;
led.index = ledConfig["index"].asInt();
const Json::Value& hscanConfig = ledConfig["hscan"];
const Json::Value& vscanConfig = ledConfig["vscan"];
led.minX_frac = std::max(0.0, std::min(100.0, hscanConfig["minimum"].asDouble()))/100.0;
led.maxX_frac = std::max(0.0, std::min(100.0, hscanConfig["maximum"].asDouble()))/100.0;
led.minY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["maximum"].asDouble()))/100.0;
led.maxY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["minimum"].asDouble()))/100.0;
ledString.leds().push_back(led);
}
return ledString;
}
Hyperion::Hyperion(const Json::Value &jsonConfig) :
mLedString(LedString::construct(jsonConfig["leds"], jsonConfig["color"])),
mImage(nullptr),
mLedString(createLedString(jsonConfig["leds"])),
mRedTransform( createColorTransform(jsonConfig["color"]["red"])),
mGreenTransform(createColorTransform(jsonConfig["color"]["green"])),
mBlueTransform( createColorTransform(jsonConfig["color"]["blue"])),
mDevice(constructDevice(jsonConfig["device"]))
{
// empty
@ -45,58 +80,29 @@ Hyperion::Hyperion(const Json::Value &jsonConfig) :
Hyperion::~Hyperion()
{
// Delete the existing image (or delete nullptr)
delete mImage;
// Delete the Led-String
delete mDevice;
// Delete the color-transform
delete mBlueTransform;
delete mGreenTransform;
delete mRedTransform;
}
void Hyperion::setInputSize(const unsigned width, const unsigned height)
void Hyperion::setValue(int priority, std::vector<RgbColor>& ledColors)
{
// Delete the existing image (or delete nullptr)
delete mImage;
// Create the new image with the mapping to the leds
mImage = new RgbImage(width, height);
mLedsMap.createMapping(*mImage, mLedString.leds());
}
void Hyperion::commit()
{
// Derive the color per led
std::vector<RgbColor> ledColors = mLedsMap.getMeanLedColor();
// const std::vector<RgbColor> ledColors = mLedsMap.getMedianLedColor();
// Write the Led colors to the led-string
mDevice->write(ledColors);
}
void Hyperion::operator() (const RgbImage& inputImage)
{
// Copy the input-image into the buffer
mImage->copy(inputImage);
// Derive the color per led
std::vector<RgbColor> ledColors = mLedsMap.getMeanLedColor();
// std::vector<RgbColor> ledColors = mLedsMap.getMedianLedColor();
applyTransform(ledColors);
// Write the Led colors to the led-string
mDevice->write(ledColors);
}
void Hyperion::setColor(const RgbColor& color)
{
mDevice->write(std::vector<RgbColor>(mLedString.leds().size(), color));
}
void Hyperion::applyTransform(std::vector<RgbColor>& colors) const
{
for (RgbColor& color : colors)
// Apply the transform to each led and color-channel
for (RgbColor& color : ledColors)
{
color.red = (color.red < mLedString.red.blacklevel)? 0 : mLedString.red.adjust + mLedString.red.gamma * color.red;
color.green = (color.green < mLedString.green.blacklevel)? 0 : mLedString.green.adjust + mLedString.green.gamma * color.green;
color.blue = (color.blue < mLedString.blue.blacklevel)? 0 : mLedString.blue.adjust + mLedString.blue.gamma * color.blue;
color.red = mRedTransform->transform(color.red);
color.green = mGreenTransform->transform(color.green);
color.blue = mBlueTransform->transform(color.blue);
}
mMuxer.setInput(priority, ledColors);
if (priority == mMuxer.getCurrentPriority())
{
mDevice->write(ledColors);
}
}

View File

@ -0,0 +1,65 @@
#include <hyperion/ImageProcessor.h>
#include "ImageToLedsMap.h"
#include "ColorTransform.h"
using namespace hyperion;
ImageProcessor::ImageProcessor(const LedString& ledString) :
mLedString(ledString),
mBuffer(nullptr),
mImageToLeds(nullptr)
{
// empty
}
ImageProcessor::~ImageProcessor()
{
delete mImageToLeds;
delete mBuffer;
}
std::vector<RgbColor> ImageProcessor::process(const RgbImage& image)
{
// Ensure that the buffer-image is the proper size
setSize(image.width(), image.height());
// Copy the data of the given image into the mapped-image
mBuffer->copy(image);
// Create a result vector and call the 'in place' functionl
std::vector<RgbColor> colors(mLedString.leds().size(), RgbColor::BLACK);
inplace_process(colors);
// return the computed colors
return colors;
}
void ImageProcessor::setSize(const unsigned width, const unsigned height)
{
// Check if the existing buffer-image is already the correct dimensions
if (mBuffer && mBuffer->width() == width && mBuffer->height() == height)
{
return;
}
// Clean up the old buffer and mapping
delete mImageToLeds;
delete mBuffer;
// Construct a new buffer and mapping
mBuffer = new RgbImage(width, height);
mImageToLeds = new ImageToLedsMap(*mBuffer, mLedString.leds());
}
RgbImage& ImageProcessor::image()
{
return *mBuffer;
}
void ImageProcessor::inplace_process(std::vector<RgbColor>& ledColors)
{
// Determine the mean-colors of each led (using the existing mapping)
mImageToLeds->getMeanLedColor(ledColors);
}

View File

@ -0,0 +1,21 @@
// Hyperion includes
#include <hyperion/ImageProcessorFactory.h>
#include <hyperion/ImageProcessor.h>
ImageProcessorFactory& ImageProcessorFactory::getInstance()
{
static ImageProcessorFactory instance;
// Return the singleton instance
return instance;
}
void ImageProcessorFactory::init(const LedString& ledString)
{
_ledString = ledString;
}
ImageProcessor* ImageProcessorFactory::newImageProcessor() const
{
return new ImageProcessor(_ledString);
}

View File

@ -3,14 +3,11 @@
#include <algorithm>
// hyperion includes
#include <hyperion/ImageToLedsMap.h>
#include "ImageToLedsMap.h"
ImageToLedsMap::ImageToLedsMap()
{
// empty
}
using namespace hyperion;
void ImageToLedsMap::createMapping(const RgbImage& image, const std::vector<Led>& leds)
ImageToLedsMap::ImageToLedsMap(const RgbImage& image, const std::vector<Led>& leds)
{
mColorsMap.resize(leds.size(), std::vector<const RgbColor*>());
@ -46,6 +43,19 @@ std::vector<RgbColor> ImageToLedsMap::getMeanLedColor()
return colors;
}
void ImageToLedsMap::getMeanLedColor(std::vector<RgbColor>& ledColors)
{
// Sanity check for the number of leds
assert(mColorsMap.size() == ledColors.size());
auto led = ledColors.begin();
for (auto ledColors = mColorsMap.begin(); ledColors != mColorsMap.end(); ++ledColors, ++led)
{
const RgbColor color = findMeanColor(*ledColors);
*led = color;
}
}
RgbColor ImageToLedsMap::findMeanColor(const std::vector<const RgbColor*>& colors)
{
uint_fast16_t cummRed = 0;
@ -64,27 +74,3 @@ RgbColor ImageToLedsMap::findMeanColor(const std::vector<const RgbColor*>& color
return {avgRed, avgGreen, avgBlue};
}
std::vector<RgbColor> ImageToLedsMap::getMedianLedColor()
{
std::vector<RgbColor> ledColors;
for (std::vector<const RgbColor*>& colors : mColorsMap)
{
const RgbColor color = findMedianColor(colors);
ledColors.push_back(color);
}
return ledColors;
}
RgbColor ImageToLedsMap::findMedianColor(std::vector<const RgbColor*>& colors)
{
std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->red < rhs->red; });
const uint8_t red = colors.at(colors.size()/2)->red;
std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->green < rhs->green; });
const uint8_t green = colors.at(colors.size()/2)->green;
std::sort(colors.begin(), colors.end(), [](const RgbColor* lhs, const RgbColor* rhs){ return lhs->blue < rhs->blue; });
const uint8_t blue = colors.at(colors.size()/2)->blue;
return {red, green, blue};
}

View File

@ -0,0 +1,57 @@
#pragma once
// hyperion-utils includes
#include <utils/RgbImage.h>
// hyperion includes
#include <hyperion/LedString.h>
namespace hyperion
{
class ImageToLedsMap
{
public:
/**
* Constructs an mapping from the colors in the image to each led based on the border
* definition given in the list of leds. The map holds pointers to the given image and its
* lifetime should never exceed that of the given image
*
* @param[in] image The RGB image
* @param[in] leds The list with led specifications
*/
ImageToLedsMap(const RgbImage& image, const std::vector<Led>& leds);
/**
* Determines the mean-color for each led using the mapping the image given
* at construction.
*
* @return ledColors The vector containing the output
*/
std::vector<RgbColor> getMeanLedColor();
/**
* Determines the mean-color for each led using the mapping the image given
* at construction.
*
* @param[out] ledColors The vector containing the output
*/
void getMeanLedColor(std::vector<RgbColor>& ledColors);
private:
std::vector<std::vector<const RgbColor*> > mColorsMap;
/**
* Finds the 'mean color' of the given list. This is the mean over each color-channel (red,
* green, blue)
*
* @param colors The list with colors
*
* @return The mean of the given list of colors (or black when empty)
*/
RgbColor findMeanColor(const std::vector<const RgbColor*>& colors);
};
} // end namespace hyperion

View File

@ -9,41 +9,6 @@
// hyperion includes
#include <hyperion/LedString.h>
LedString LedString::construct(const Json::Value& ledsConfig, const Json::Value& colorConfig)
{
LedString ledString;
const Json::Value& redConfig = colorConfig["red"];
const Json::Value& greenConfig = colorConfig["greem"];
const Json::Value& blueConfig = colorConfig["blue"];
ledString.red.gamma = redConfig["gamma"].asDouble();
ledString.red.adjust = redConfig["adjust"].asDouble();
ledString.red.blacklevel = redConfig["blacklevel"].asDouble();
ledString.green.gamma = greenConfig["gamma"].asDouble();
ledString.green.adjust = colorConfig["adjust"].asDouble();
ledString.green.blacklevel = colorConfig["blacklevel"].asDouble();
ledString.blue.gamma = blueConfig["gamma"].asDouble();
ledString.blue.adjust = blueConfig["adjust"].asDouble();
ledString.blue.blacklevel = blueConfig["blacklevel"].asDouble();
for (const Json::Value& ledConfig : ledsConfig)
{
Led led;
led.index = ledConfig["index"].asInt();
const Json::Value& hscanConfig = ledConfig["hscan"];
const Json::Value& vscanConfig = ledConfig["vscan"];
led.minX_frac = std::max(0.0, std::min(100.0, hscanConfig["minimum"].asDouble()))/100.0;
led.maxX_frac = std::max(0.0, std::min(100.0, hscanConfig["maximum"].asDouble()))/100.0;
led.minY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["maximum"].asDouble()))/100.0;
led.maxY_frac = 1.0 - std::max(0.0, std::min(100.0, vscanConfig["minimum"].asDouble()))/100.0;
ledString.mLeds.push_back(led);
}
return ledString;
}
LedString::LedString()
{
@ -54,6 +19,11 @@ LedString::~LedString()
{
}
std::vector<Led>& LedString::leds()
{
return mLeds;
}
const std::vector<Led>& LedString::leds() const
{
return mLeds;

View File

@ -0,0 +1,94 @@
// STL includes
#include <algorithm>
#include <stdexcept>
// Hyperion includes
#include <hyperion/PriorityMuxer.h>
PriorityMuxer::PriorityMuxer() :
mCurrentPriority(MAX_PRIORITY)
{
// empty
}
PriorityMuxer::~PriorityMuxer()
{
// empty
}
int PriorityMuxer::getCurrentPriority() const
{
return mCurrentPriority;
}
QList<int> PriorityMuxer::getPriorities() const
{
return mActiveInputs.keys();
}
bool PriorityMuxer::hasPriority(const int priority) const
{
return mActiveInputs.contains(priority);
}
const PriorityMuxer::InputInfo& PriorityMuxer::getInputInfo(const int priority) const
{
auto elemIt = mActiveInputs.find(priority);
if (elemIt == mActiveInputs.end())
{
throw std::runtime_error("no such priority");
}
return elemIt.value();
}
void PriorityMuxer::setInput(const int priority, const std::vector<RgbColor>& ledColors, const int64_t timeoutTime_ms)
{
InputInfo& input = mActiveInputs[priority];
input.priority = priority;
input.timeoutTime_ms = timeoutTime_ms;
input.ledColors = ledColors;
mCurrentPriority = std::min(mCurrentPriority, priority);
}
void PriorityMuxer::clearInput(const int priority)
{
mActiveInputs.remove(priority);
if (mCurrentPriority == priority)
{
if (mActiveInputs.empty())
{
mCurrentPriority = MAX_PRIORITY;
}
else
{
QList<int> keys = mActiveInputs.keys();
mCurrentPriority = *std::min_element(keys.begin(), keys.end());
}
}
}
void PriorityMuxer::clearAll()
{
mActiveInputs.clear();
mCurrentPriority = MAX_PRIORITY;
}
void PriorityMuxer::setCurrentTime(const int64_t& now)
{
mCurrentPriority = MAX_PRIORITY;
for (auto infoIt = mActiveInputs.begin(); infoIt != mActiveInputs.end();)
{
if (infoIt->timeoutTime_ms != -1 && infoIt->timeoutTime_ms <= now)
{
infoIt = mActiveInputs.erase(infoIt);
}
else
{
mCurrentPriority = std::min(mCurrentPriority, infoIt->priority);
++infoIt;
}
}
}

View File

@ -2,6 +2,12 @@
add_executable(WriteConfig
WriteConfig.cpp)
add_executable(HyperionDispmanx
HyperionMain.cpp)
target_link_libraries(HyperionDispmanx
hyperion)
add_executable(boblight-dispmanx
boblight-dispmanx.cpp
flagmanager.h
@ -27,12 +33,12 @@ target_link_libraries(boblight-dispmanx
bob2hyperion
${BCM_LIBRARIES})
add_executable(HyperionDispmanX
HyperionDispmanX.cpp)
#add_executable(HyperionDispmanX
# HyperionDispmanX.cpp)
target_link_libraries(HyperionDispmanX
hyperion
${BCM_LIBRARIES})
#target_link_libraries(HyperionDispmanX
# hyperion
# ${BCM_LIBRARIES})
# Find the libPNG

View File

@ -43,7 +43,7 @@ int main(int /*argc*/, char** /*argv*/)
}
Hyperion hyperion(raspiConfig);
dispmanx_process(hyperion, sRunning);
// dispmanx_process(hyperion, sRunning);
return 0;
}

17
src/HyperionMain.cpp Normal file
View File

@ -0,0 +1,17 @@
// QT includes
#include <QCoreApplication>
// Hyperion includes
#include <hyperion/DispmanxWrapper.h>
int main(int argc, char** argv)
{
QCoreApplication app(argc, argv);
DispmanxWrapper dispmanx;
dispmanx.start();
app.exec();
}

View File

@ -144,10 +144,10 @@ int main(int argc, char** argv)
FbWriter fbWriter;
Hyperion raspiLight(raspiConfig);
raspiLight.setInputSize(image->width(), image->height());
// raspiLight.setInputSize(image->width(), image->height());
fbWriter.writeImage(*image);
raspiLight(*image);
// raspiLight(*image);
sleep(5);

View File

@ -1,17 +1,17 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
@ -35,16 +35,16 @@ CArguments::CArguments(int argc, char** argv)
if (m_argc == 0)
{
m_argv = NULL;
m_argv = NULL;
}
else
{
m_argv = new char*[m_argc];
for (int i = 0; i < m_argc; i++)
{
m_argv[i] = new char[strlen(argv[i]) + 1];
strcpy(m_argv[i], argv[i]);
}
m_argv = new char*[m_argc];
for (int i = 0; i < m_argc; i++)
{
m_argv[i] = new char[strlen(argv[i]) + 1];
strcpy(m_argv[i], argv[i]);
}
}
}
@ -53,11 +53,11 @@ CArguments::~CArguments()
{
if (m_argv)
{
for (int i = 0; i < m_argc; i++)
{
delete[] m_argv[i];
}
delete[] m_argv;
for (int i = 0; i < m_argc; i++)
{
delete[] m_argv[i];
}
delete[] m_argv;
}
}
@ -87,75 +87,75 @@ void CFlagManager::ParseFlags(int tempargc, char** tempargv)
int c;
opterr = 0; //we don't want to print error messages
while ((c = getopt(argc, argv, m_flags.c_str())) != -1)
{
if (c == 'p') //priority
{
option = optarg;
if (!StrToInt(option, m_priority) || m_priority < 0 || m_priority > 255)
{
throw string("Wrong option " + string(optarg) + " for argument -p");
}
}
else if (c == 's') //address[:port]
{
option = optarg;
//store address in string and set the char* to it
m_straddress = option.substr(0, option.find(':'));
m_address = m_straddress.c_str();
if (c == 'p') //priority
{
option = optarg;
if (!StrToInt(option, m_priority) || m_priority < 0 || m_priority > 255)
{
throw string("Wrong option " + string(optarg) + " for argument -p");
}
}
else if (c == 's') //address[:port]
{
option = optarg;
//store address in string and set the char* to it
m_straddress = option.substr(0, option.find(':'));
m_address = m_straddress.c_str();
if (option.find(':') != string::npos) //check if we have a port
{
option = option.substr(option.find(':') + 1);
string word;
if (!StrToInt(option, m_port) || m_port < 0 || m_port > 65535)
{
throw string("Wrong option " + string(optarg) + " for argument -s");
}
}
}
else if (c == 'o') //option for libboblight
{
m_options.push_back(optarg);
}
else if (c == 'l') //list libboblight options
{
m_printboblightoptions = true;
return;
}
else if (c == 'h') //print help message
{
m_printhelp = true;
return;
}
else if (c == 'f')
{
m_fork = true;
}
else if (c == 'y')
{
if (!StrToBool(optarg, m_sync))
{
throw string("Wrong value " + string(optarg) + " for sync mode");
}
}
else if (c == '?') //unknown option
{
//check if we know this option, but expected an argument
if (m_flags.find(ToString((char)optopt) + ":") != string::npos)
{
throw string("Option " + ToString((char)optopt) + "requires an argument");
}
else
{
throw string("Unkown option " + ToString((char)optopt));
}
}
else
{
ParseFlagsExtended(argc, argv, c, optarg); //pass our argument to a derived class
}
if (option.find(':') != string::npos) //check if we have a port
{
option = option.substr(option.find(':') + 1);
string word;
if (!StrToInt(option, m_port) || m_port < 0 || m_port > 65535)
{
throw string("Wrong option " + string(optarg) + " for argument -s");
}
}
}
else if (c == 'o') //option for libboblight
{
m_options.push_back(optarg);
}
else if (c == 'l') //list libboblight options
{
m_printboblightoptions = true;
return;
}
else if (c == 'h') //print help message
{
m_printhelp = true;
return;
}
else if (c == 'f')
{
m_fork = true;
}
else if (c == 'y')
{
if (!StrToBool(optarg, m_sync))
{
throw string("Wrong value " + string(optarg) + " for sync mode");
}
}
else if (c == '?') //unknown option
{
//check if we know this option, but expected an argument
if (m_flags.find(ToString((char)optopt) + ":") != string::npos)
{
throw string("Option " + ToString((char)optopt) + "requires an argument");
}
else
{
throw string("Unkown option " + ToString((char)optopt));
}
}
else
{
ParseFlagsExtended(argc, argv, c, optarg); //pass our argument to a derived class
}
}
PostGetopt(optind, argc, argv); //some postprocessing
@ -169,7 +169,7 @@ void CFlagManager::PrintBoblightOptions()
for (int i = 0; i < nroptions; i++)
{
cout << boblight_getoptiondescript(boblight, i) << "\n";
cout << boblight_getoptiondescript(boblight, i) << "\n";
}
boblight_destroy(boblight);
@ -178,74 +178,74 @@ void CFlagManager::PrintBoblightOptions()
void CFlagManager::ParseBoblightOptions(void* boblight)
{
int nrlights = boblight_getnrlights(boblight);
for (int i = 0; i < m_options.size(); i++)
for (size_t i = 0; i < m_options.size(); i++)
{
string option = m_options[i];
string lightname;
string optionname;
string optionvalue;
int lightnr = -1;
string option = m_options[i];
string lightname;
string optionname;
string optionvalue;
int lightnr = -1;
//check if we have a lightname, otherwise we use all lights
if (option.find(':') != string::npos)
{
lightname = option.substr(0, option.find(':'));
if (option.find(':') == option.size() - 1) //check if : isn't the last char in the string
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
option = option.substr(option.find(':') + 1); //shave off the lightname
//check if we have a lightname, otherwise we use all lights
if (option.find(':') != string::npos)
{
lightname = option.substr(0, option.find(':'));
if (option.find(':') == option.size() - 1) //check if : isn't the last char in the string
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
option = option.substr(option.find(':') + 1); //shave off the lightname
//check which light this is
bool lightfound = false;
for (int j = 0; j < nrlights; j++)
{
if (lightname == boblight_getlightname(boblight, j))
{
lightfound = true;
lightnr = j;
break;
}
}
if (!lightfound)
{
throw string("light \"" + lightname + "\" used in option \"" + m_options[i] + "\" doesn't exist");
}
}
//check which light this is
bool lightfound = false;
for (int j = 0; j < nrlights; j++)
{
if (lightname == boblight_getlightname(boblight, j))
{
lightfound = true;
lightnr = j;
break;
}
}
if (!lightfound)
{
throw string("light \"" + lightname + "\" used in option \"" + m_options[i] + "\" doesn't exist");
}
}
//check if '=' exists and it's not at the end of the string
if (option.find('=') == string::npos || option.find('=') == option.size() - 1)
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
//check if '=' exists and it's not at the end of the string
if (option.find('=') == string::npos || option.find('=') == option.size() - 1)
{
throw string("wrong option \"" + option + "\", syntax is [light:]option=value");
}
optionname = option.substr(0, option.find('=')); //option name is everything before = (already shaved off the lightname here)
optionvalue = option.substr(option.find('=') + 1); //value is everything after =
optionname = option.substr(0, option.find('=')); //option name is everything before = (already shaved off the lightname here)
optionvalue = option.substr(option.find('=') + 1); //value is everything after =
option = optionname + " " + optionvalue; //libboblight wants syntax without =
option = optionname + " " + optionvalue; //libboblight wants syntax without =
//bitch if we can't set this option
if (!boblight_setoption(boblight, lightnr, option.c_str()))
{
throw string(boblight_geterror(boblight));
}
//bitch if we can't set this option
if (!boblight_setoption(boblight, lightnr, option.c_str()))
{
throw string(boblight_geterror(boblight));
}
}
}
bool CFlagManager::SetVideoGamma()
{
for (int i = 0; i < m_options.size(); i++)
for (size_t i = 0; i < m_options.size(); i++)
{
string option = m_options[i];
if (option.find(':') != string::npos)
option = option.substr(option.find(':') + 1); //shave off the lightname
string option = m_options[i];
if (option.find(':') != string::npos)
option = option.substr(option.find(':') + 1); //shave off the lightname
if (option.find('=') != string::npos)
{
if (option.substr(0, option.find('=')) == "gamma")
return false; //gamma set by user, don't override
}
if (option.find('=') != string::npos)
{
if (option.substr(0, option.find('=')) == "gamma")
return false; //gamma set by user, don't override
}
}
m_options.push_back("gamma=" + ToString(VIDEOGAMMA));

View File

@ -1,17 +1,17 @@
/*
* boblight
* Copyright (C) Bob 2009
*
* Copyright (C) Bob 2009
*
* boblight is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* boblight is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
@ -96,15 +96,15 @@ inline A Round(B value)
{
if (value == 0.0)
{
return 0;
return 0;
}
else if (value > 0.0)
{
return (A)(value + 0.5);
return (A)(value + 0.5);
}
else
{
return (A)(value - 0.5);
return (A)(value - 0.5);
}
}
@ -135,7 +135,7 @@ inline bool StrToInt(const std::string& data, int& value)
inline bool StrToInt(const std::string& data, int64_t& value)
{
return sscanf(data.c_str(), "%ld", &value) == 1;
return sscanf(data.c_str(), "%lld", &value) == 1;
}
inline bool HexStrToInt(const std::string& data, int& value)
@ -145,7 +145,7 @@ inline bool HexStrToInt(const std::string& data, int& value)
inline bool HexStrToInt(const std::string& data, int64_t& value)
{
return sscanf(data.c_str(), "%x", &value) == 1;
return sscanf(data.c_str(), "%llx", &value) == 1;
}
inline bool StrToFloat(const std::string& data, float& value)
@ -163,26 +163,26 @@ inline bool StrToBool(const std::string& data, bool& value)
std::string data2 = data;
std::string word;
if (!GetWord(data2, word))
return false;
return false;
if (word == "1" || word == "true" || word == "on" || word == "yes")
{
value = true;
return true;
value = true;
return true;
}
else if (word == "0" || word == "false" || word == "off" || word == "no")
{
value = false;
return true;
value = false;
return true;
}
else
{
int ivalue;
if (StrToInt(word, ivalue))
{
value = ivalue != 0;
return true;
}
int ivalue;
if (StrToInt(word, ivalue))
{
value = ivalue != 0;
return true;
}
}
return false;

View File

@ -1,93 +1,96 @@
// STL includes
#include <iostream>
#include <cmath>
#include <hyperion/ColorTransform.h>
#include <../../libsrc/hyperion/ColorTransform.h>
using namespace hyperion;
int main()
{
{
std::cout << "Testing linear transform" << std::endl;
ColorTransform t;
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = input;
{
std::cout << "Testing linear transform" << std::endl;
ColorTransform t;
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = input;
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing threshold" << std::endl;
ColorTransform t(.10, 1.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = ((i/255.0) < t.getThreshold() ? 0 : output);
{
std::cout << "Testing threshold" << std::endl;
ColorTransform t(.10, 1.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = ((i/255.0) < t.getThreshold() ? 0 : output);
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing blacklevel and whitelevel" << std::endl;
ColorTransform t(0, 1.0, 0.2, 0.8);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(input * (t.getWhitelevel()-t.getBlacklevel()) + 255 * t.getBlacklevel());
{
std::cout << "Testing blacklevel and whitelevel" << std::endl;
ColorTransform t(0, 1.0, 0.2, 0.8);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(input * (t.getWhitelevel()-t.getBlacklevel()) + 255 * t.getBlacklevel());
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
{
std::cout << "Testing gamma" << std::endl;
ColorTransform t(0, 2.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(255 * std::pow(i / 255.0, 2));
{
std::cout << "Testing gamma" << std::endl;
ColorTransform t(0, 2.0, 0.0, 1.0);
for (int i = 0; i < 256; ++i)
{
uint8_t input = i;
uint8_t output = t.transform(input);
uint8_t expected = (uint8_t)(255 * std::pow(i / 255.0, 2));
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
if (output != expected)
{
std::cerr << "ERROR: input (" << (int)input << ") => output (" << (int)output << ") : expected (" << (int) expected << ")" << std::endl;
return 1;
}
else
{
std::cerr << "OK: input (" << (int)input << ") => output (" << (int)output << ")" << std::endl;
}
}
}
return 0;
return 0;
}

View File

@ -32,7 +32,7 @@ int main()
double redGamma = redConfig["gamma"].asDouble();
std::cout << "RED GAMMA = " << redGamma << std::endl;
std::cout << "RED GAMMA = " << colorConfig["red.gamma"].asDouble() << std::endl;
LedString ledString = LedString::construct(ledConfig, colorConfig);
// LedString ledString = LedString::construct(ledConfig, colorConfig);
return 0;
}