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
parent
491d6ff608
commit
39b98386dd
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
@ -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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
};
|
||||
|
||||
|
|
@ -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;
|
||||
};
|
||||
|
|
@ -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;
|
||||
};
|
||||
|
|
@ -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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
};
|
||||
|
|
@ -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) << "}";
|
||||
|
|
|
|||
|
|
@ -10,9 +10,13 @@ target_link_libraries(bob2hyperion
|
|||
hyperion
|
||||
hyperion-utils)
|
||||
|
||||
add_subdirectory(hyperion)
|
||||
add_subdirectory(utils)
|
||||
|
||||
# Find the libPNG
|
||||
find_package(PNG REQUIRED QUIET)
|
||||
|
||||
if (PNG_FOUND)
|
||||
# Add additional includes dirs
|
||||
include_directories(${PNG_INCLUDE_DIR})
|
||||
|
||||
|
|
@ -22,6 +26,6 @@ add_library(bob2hyperion-png SHARED
|
|||
target_link_libraries(bob2hyperion-png
|
||||
hyperion-png)
|
||||
|
||||
add_subdirectory(hyperion)
|
||||
add_subdirectory(hyperionpng)
|
||||
add_subdirectory(utils)
|
||||
endif(PNG_FOUND)
|
||||
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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}/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.h
|
||||
${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})
|
||||
|
|
|
|||
|
|
@ -1,7 +1,10 @@
|
|||
// STL includes
|
||||
#include <cmath>
|
||||
|
||||
#include "ColorTransform.h"
|
||||
|
||||
using namespace hyperion;
|
||||
|
||||
ColorTransform::ColorTransform() :
|
||||
_threshold(0),
|
||||
_gamma(1.0),
|
||||
|
|
|
|||
|
|
@ -1,6 +1,10 @@
|
|||
#pragma once
|
||||
|
||||
#include "stdint.h"
|
||||
// STL includes
|
||||
#include <cstdint>
|
||||
|
||||
namespace hyperion
|
||||
{
|
||||
|
||||
/// Transform for a single color byte value
|
||||
///
|
||||
|
|
@ -15,7 +19,7 @@ class ColorTransform
|
|||
{
|
||||
public:
|
||||
ColorTransform();
|
||||
ColorTransform(double threshold, double gamma, double whitelevel, double blacklevel);
|
||||
ColorTransform(double threshold, double gamma, double blacklevel, double whitelevel);
|
||||
~ColorTransform();
|
||||
|
||||
double getThreshold() const;
|
||||
|
|
@ -47,3 +51,5 @@ private:
|
|||
|
||||
uint8_t _mapping[256];
|
||||
};
|
||||
|
||||
} // end namespace hyperion
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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;
|
||||
};
|
||||
|
|
@ -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();
|
||||
}
|
||||
|
|
@ -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());
|
||||
// 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);
|
||||
}
|
||||
|
||||
void Hyperion::commit()
|
||||
{
|
||||
// Derive the color per led
|
||||
std::vector<RgbColor> ledColors = mLedsMap.getMeanLedColor();
|
||||
// const std::vector<RgbColor> ledColors = mLedsMap.getMedianLedColor();
|
||||
mMuxer.setInput(priority, ledColors);
|
||||
|
||||
// Write the Led colors to the led-string
|
||||
if (priority == mMuxer.getCurrentPriority())
|
||||
{
|
||||
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)
|
||||
{
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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);
|
||||
}
|
||||
|
|
@ -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};
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ int main(int /*argc*/, char** /*argv*/)
|
|||
}
|
||||
Hyperion hyperion(raspiConfig);
|
||||
|
||||
dispmanx_process(hyperion, sRunning);
|
||||
// dispmanx_process(hyperion, sRunning);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
}
|
||||
|
|
@ -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);
|
||||
|
||||
|
|
|
|||
|
|
@ -179,7 +179,7 @@ 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;
|
||||
|
|
@ -235,7 +235,7 @@ void CFlagManager::ParseBoblightOptions(void* 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)
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -1,7 +1,10 @@
|
|||
// STL includes
|
||||
#include <iostream>
|
||||
#include <cmath>
|
||||
|
||||
#include <hyperion/ColorTransform.h>
|
||||
#include <../../libsrc/hyperion/ColorTransform.h>
|
||||
|
||||
using namespace hyperion;
|
||||
|
||||
int main()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue