Added/Updated/Fixed doxygen comments

libsrc/hyperion/BlackBorderProcessor.h

@@ -6,32 +6,65 @@
 
 namespace hyperion
 {
+	///
+	/// The BlackBorder processor is a wrapper around the black-border detector for keeping track of
+	/// detected borders and count of the type and size of detected borders.
+	///
 	class BlackBorderProcessor
 	{
 	public:
+		///
+		/// Constructor for the BlackBorderProcessor
+		/// @param unknownFrameCnt The number of frames(images) that need to contain an unknown
+		///                        border before the current border is set to unknown
+		/// @param borderFrameCnt The number of frames(images) that need to contain a vertical or
+		///                       horizontal border becomes the current border
+		/// @param blurRemoveCnt The size to add to a horizontal or vertical border (because the
+		///                      outer pixels is blurred (black and color combined))
+		///
 		BlackBorderProcessor(
 				const unsigned unknownFrameCnt,
 				const unsigned borderFrameCnt,
 				const unsigned blurRemoveCnt);
 
+		///
+		/// Return the current (detected) border
+		/// @return The current border
+		///
 		BlackBorder getCurrentBorder() const;
 
+		///
+		/// Processes the image. This performs detecion of black-border on the given image and
+		/// updates the current border accordingly. If the current border is updated the method call
+		/// will return true else false
+		///
+		/// @param image The image to process
+		///
+		/// @return True if a different border was detected than the current else false
+		///
 		bool process(const RgbImage& image);
 
 	private:
 
+		/// The number of unknown-borders detected before it becomes the current border
 		const unsigned _unknownSwitchCnt;
 
+		/// The number of horizontal/vertical borders detected before it becomes the current border
 		const unsigned _borderSwitchCnt;
 
+		/// The number of pixels to increase a detected border for removing blury pixels
 		unsigned _blurRemoveCnt;
 
+		/// The blackborder detector
 		BlackBorderDetector _detector;
 
+		/// The current detected border
 		BlackBorder _currentBorder;
 
+		/// The border detected in the previous frame
 		BlackBorder _previousDetectedBorder;
 
+		/// The number of frame the previous detected border matched the incomming border
 		unsigned _consistentCnt;
 	};
 } // end namespace hyperion

libsrc/hyperion/LedDeviceTest.h

@@ -6,14 +6,33 @@
 // Hyperion includes
 #include <hyperion/LedDevice.h>
 
+///
+/// Implementation of the LedDevice that write the led-colors to an
+/// ASCII-textfile('/home/pi/LedDevice.out')
+///
 class LedDeviceTest : public LedDevice
 {
 public:
+	///
+	/// Constructs the test-device, which opens an output stream to the file
+	///
 	LedDeviceTest();
+
+	///
+	/// Destructor of this test-device
+	///
 	virtual ~LedDeviceTest();
 
+	///
+	/// Writes the given led-color values to the output stream
+	///
+	/// @param ledValues The color-value per led
+	///
+	/// @return Zero on success else negative
+	///
 	virtual int write(const std::vector<RgbColor> & ledValues);
 
 private:
+	/// The outputstream
 	std::ofstream _ofs;
 };

libsrc/hyperion/LedDeviceWs2801.cpp

@@ -11,9 +11,7 @@
 // hyperion local includes
 #include "LedDeviceWs2801.h"
 
-LedDeviceWs2801::LedDeviceWs2801(const std::string& name,
-								 const std::string& outputDevice,
-								 const unsigned interval,
+LedDeviceWs2801::LedDeviceWs2801(const std::string& outputDevice,
 								 const unsigned baudrate) :
 	mDeviceName(outputDevice),
 	mBaudRate_Hz(baudrate),

libsrc/hyperion/LedDeviceWs2801.h

@@ -9,25 +9,51 @@
 // hyperion incluse
 #include <hyperion/LedDevice.h>
 
+///
+/// Implementation of the LedDevice interface for writing to Ws2801 led device.
+///
 class LedDeviceWs2801 : public LedDevice
 {
 public:
-	LedDeviceWs2801(const std::string& name,
-					const std::string& outputDevice,
-					const unsigned interval,
+	///
+	/// Constructs the LedDevice for a string containing leds of the type Ws2801
+	///
+	/// @param outputDevice The name of the output device (eg '/etc/SpiDev.0.0')
+	/// @param baudrate The used baudrate for writing to the output device
+	///
+	LedDeviceWs2801(const std::string& outputDevice,
 					const unsigned baudrate);
 
+	///
+	/// Destructor of the LedDevice; closes the output device if it is open
+	///
 	virtual ~LedDeviceWs2801();
 
+	///
+	/// Opens and configures the output device
+	///
+	/// @return Zero on succes else negative
+	///
 	int open();
 
+	///
+	/// Writes the led color values to the led-device
+	///
+	/// @param ledValues The color-value per led
+	/// @return Zero on succes else negative
+	///
 	virtual int write(const std::vector<RgbColor> &ledValues);
 
 private:
+	/// The name of the output device
 	const std::string mDeviceName;
+	/// The used baudrate of the output device
 	const int mBaudRate_Hz;
 
+	/// The File Identifier of the opened output device (or -1 if not opened)
 	int mFid;
+	/// The transfer structure for writing to the spi-device
 	spi_ioc_transfer spi;
+	/// The 'latch' time for latching the shifted-value into the leds
 	timespec latchTime;
 };

libsrc/jsonserver/JsonClientConnection.h

@@ -18,91 +18,142 @@
 
 class ImageProcessor;
 
-/// @brief The Connection object created by \a JsonServer when a new connection is establshed
+///
+/// The Connection object created by \a JsonServer when a new connection is establshed
 ///
 class JsonClientConnection : public QObject
 {
 	Q_OBJECT
 
 public:
-	/// @brief Constructor
+	///
+	/// Constructor
 	/// @param socket The Socket object for this connection
 	/// @param hyperion The Hyperion server
+	///
 	JsonClientConnection(QTcpSocket * socket, Hyperion * hyperion);
 
-	/// @brief Destructor
+	///
+	/// Destructor
+	///
 	~JsonClientConnection();
 
 signals:
-	/// @brief Signal which is emitted when the connection is being closed
+	///
+	/// Signal which is emitted when the connection is being closed
 	/// @param connection This connection object
+	///
 	void connectionClosed(JsonClientConnection * connection);
 
 private slots:
-	/// @brief Slot called when new data has arrived
+	///
+	/// Slot called when new data has arrived
+	///
 	void readData();
 
-	/// @brief Slot called when this connection is being closed
+	///
+	/// Slot called when this connection is being closed
+	///
 	void socketClosed();
 
 private:
-	/// @brief Handle an incoming JSON message
+	///
+	/// Handle an incoming JSON message
+	///
 	/// @param message the incoming message as string
+	///
 	void handleMessage(const std::string & message);
 
-	/// @brief Handle an incoming JSON Color message
+	///
+	/// Handle an incoming JSON Color message
+	///
 	/// @param message the incoming message
+	///
 	void handleColorCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON Image message
+	///
+	/// Handle an incoming JSON Image message
+	///
 	/// @param message the incoming message
+	///
 	void handleImageCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON Server info message
+	///
+	/// Handle an incoming JSON Server info message
+	///
 	/// @param message the incoming message
+	///
 	void handleServerInfoCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON Clear message
+	///
+	/// Handle an incoming JSON Clear message
+	///
 	/// @param message the incoming message
+	///
 	void handleClearCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON Clearall message
+	///
+	/// Handle an incoming JSON Clearall message
+	///
 	/// @param message the incoming message
+	///
 	void handleClearallCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON Transform message
+	///
+	/// Handle an incoming JSON Transform message
+	///
 	/// @param message the incoming message
+	///
 	void handleTransformCommand(const Json::Value & message);
 
-	/// @brief Handle an incoming JSON message of unknown type
+	///
+	/// Handle an incoming JSON message of unknown type
+	///
 	/// @param message the incoming message
+	///
 	void handleNotImplemented();
 
-	/// @brief Send a message to the connected client
+	///
+	/// Send a message to the connected client
+	///
 	/// @param message The JSON message to send
+	///
 	void sendMessage(const Json::Value & message);
 
-	/// @brief Send a standard reply indicating success
+	///
+	/// Send a standard reply indicating success
+	///
 	void sendSuccessReply();
 
-	/// @brief Send an error message back to the client
+	///
+	/// Send an error message back to the client
+	///
 	/// @param error String describing the error
+	///
 	void sendErrorReply(const std::string & error);
 
 private:
-	/// @brief Check if a JSON messag is valid according to a given JSON schema
+	///
+	/// Check if a JSON messag is valid according to a given JSON schema
+	///
 	/// @param message JSON message which need to be checked
 	/// @param schemaResource Qt esource identifier with the JSON schema
 	/// @param errors Output error message
+	///
 	/// @return true if message conforms the given JSON schema
+	///
 	bool checkJson(const Json::Value & message, const QString &schemaResource, std::string & errors);
 
 private:
+	/// The TCP-Socket that is connected tot the Json-client
 	QTcpSocket * _socket;
 
+	/// The processor for translating images to led-values
 	ImageProcessor * _imageProcessor;
 
+	/// Link to Hyperion for writing led-values to a priority channel
 	Hyperion * _hyperion;
 
+	/// The buffer used for reading data from the socket
 	QByteArray _receiveBuffer;
 };

libsrc/utils/RgbImage.cpp

@@ -8,8 +8,8 @@
 
 
 RgbImage::RgbImage(const unsigned width, const unsigned height, const RgbColor background) :
-	mWidth(width),
-	mHeight(height),
+	_width(width),
+	_height(height),
 	mColors(new RgbColor[width*height])
 {
 	for (unsigned i=0; i<width*height; ++i)
@@ -32,8 +32,8 @@ void RgbImage::setPixel(const unsigned x, const unsigned y, const RgbColor color
 const RgbColor& RgbImage::operator()(const unsigned x, const unsigned y) const
 {
 	// Debug-mode sanity check on given index
-	assert(x < mWidth);
-	assert(y < mHeight);
+	assert(x < _width);
+	assert(y < _height);
 
 	const unsigned index = toIndex(x, y);
 	return mColors[index];
@@ -42,8 +42,8 @@ const RgbColor& RgbImage::operator()(const unsigned x, const unsigned y) const
 RgbColor& RgbImage::operator()(const unsigned x, const unsigned y)
 {
 	// Debug-mode sanity check on given index
-	assert(x < mWidth);
-	assert(y < mHeight);
+	assert(x < _width);
+	assert(y < _height);
 
 	const unsigned index = toIndex(x, y);
 	return mColors[index];