mise en forme du code (5a1dd408) · Commits · Emeric Verschuur / lray

LrColor.cpp

+115 −61

Original line number	Diff line number	Diff line
		/**
		* @brief OBJET : une couleur
		* @file IMG_LrColor.cpp
		* @brief Classe pour la gestion des couleurs
		* @file LrColor.cpp
		* @date Vendredi 7 mars 2008
		* @note
		* @author Josselin Francois
		* @author Michael Nauge
		* @author Axel Richard
		* @author Hervé Souchaud
		* @author Emeric Verschuur
		*
		* Ce fichier contient la classe qui gère la creation d'une couleur
		*/
		@@ -14,10 +17,11 @@
		#include "config.h"
		#endif

		#include "LrColor.h"
		#include <stdint.h>
		#include "LrColor.h"

		// ############################################################################

		/****************************************************************************/
		const LrColor LrColor::BLACK(0.0f,0.0f,0.0f);
		const LrColor LrColor::GREY(0.5f,0.5f,0.5f);
		const LrColor LrColor::WHITE(1.0f,1.0f,1.0f);
		@@ -27,34 +31,36 @@ const LrColor LrColor::BLUE(0.0f,0.0f,1.0f);
		const LrColor LrColor::CYAN(0.0f,1.0f,1.0f);
		const LrColor LrColor::MAGENTA(1.0f,0.0f,1.0f);
		const LrColor LrColor::YELLOW(1.0f,1.0f,0.0f);
		/****************************************************************************/
		/* CONSTRUCTEURS */
		/****************************************************************************/

		// ############################################################################

		LrColor::LrColor()
		: m_r(0.0),
		m_g(0.0),
		m_b(0.0)
		{

		}
		/****************************************************************************/

		// ############################################################################

		LrColor::LrColor(const LrColor & c)
		: m_r(c.m_r),
		m_g(c.m_g),
		m_b(c.m_b)
		{
		}

		// ############################################################################

		}
		/****************************************************************************/
		LrColor::LrColor(Real red, Real green, Real blue)
		: m_r(red),
		m_g(green),
		m_b(blue)
		{

		}
		/****************************************************************************/

		// ############################################################################

		LrColor::LrColor(uint8_t red, uint8_t green, uint8_t blue)
		: m_r(0.0),
		m_g(0.0),
		@@ -62,94 +68,120 @@ LrColor::LrColor(uint8_t red, uint8_t green, uint8_t blue)
		{
		fromRGB255 (red, green, blue);
		}
		/****************************************************************************/

		// ############################################################################

		LrColor::~LrColor()
		{

		}
		/****************************************************************************/
		/* ACCESSEURS */
		/****************************************************************************/

		// ############################################################################

		Real LrColor::getRed() const
		{
		return m_r;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setRed(Real red)
		{
		m_r = red;
		}
		/****************************************************************************/

		// ############################################################################

		Real LrColor::getGreen() const
		{
		return m_g;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setGreen(Real green)
		{
		m_g = green;
		}
		/****************************************************************************/

		// ############################################################################

		Real LrColor::getBlue() const
		{
		return m_b;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setBlue(Real blue)
		{
		m_b = blue;
		}
		/****************************************************************************/
		void LrColor::toRGB255 (uint8_t & red, uint8_t & green, uint8_t & blue) const
		{
		red = (uint8_t)(m_r * 255);
		green = (uint8_t)(m_g * 255);
		blue = (uint8_t)(m_b * 255);
		}
		/****************************************************************************/

		// ############################################################################

		uint8_t LrColor::getRed255()
		{
		if(m_r >1.0) m_r = 1.0;
		uint8_t red = (uint8_t)(m_r * 255);
		return red;
		}
		/****************************************************************************/

		// ############################################################################

		uint8_t LrColor::getGreen255()
		{
		if(m_g >1.0) m_g = 1.0;
		uint8_t green = (uint8_t)(m_g * 255);
		return green;
		}
		/****************************************************************************/

		// ############################################################################

		uint8_t LrColor::getBlue255()
		{
		if(m_b >1.0) m_b = 1.0;
		uint8_t blue = (uint8_t)(m_b * 255);
		return blue;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setRed255(uint8_t red)
		{
		m_r = (Real)red / 255;
		//if(m_r > 1.0) m_r = 1.0;
		if(m_r < 0.0) m_r = 0.0;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setGreen255(uint8_t green)
		{
		m_g = (Real)green / 255;
		//if(m_g > 1.0) m_g = 1.0;
		if(m_g < 0.0) m_g = 0.0;
		}
		/****************************************************************************/

		// ############################################################################

		void LrColor::setBlue255(uint8_t blue)
		{
		m_b = (Real)blue / 255;
		//if(m_b > 1.0) m_b = 1.0;
		if(m_b < 0.0) m_b = 0.0;
		}
		/****************************************************************************/
		void LrColor::fromRGB255 (const uint8_t red, const uint8_t green, const uint8_t blue)

		// ############################################################################

		void LrColor::toRGB255 (uint8_t & red, uint8_t & green, uint8_t & blue) const
		{
		red = (uint8_t)(m_r * 255);
		green = (uint8_t)(m_g * 255);
		blue = (uint8_t)(m_b * 255);
		}

		// ############################################################################

		void LrColor::fromRGB255 (const uint8_t red,
		const uint8_t green,
		const uint8_t blue)
		{
		m_r = ((Real)red) / 255;
		if(m_r < 0.0) m_r = 0.0;
		@@ -160,9 +192,9 @@ void LrColor::fromRGB255 (const uint8_t red, const uint8_t green, const uint8_t
		m_b = ((Real)blue) / 255;
		if(m_b < 0.0) m_b = 0.0;
		}
		/****************************************************************************/
		/* OPERATEURS */
		/****************************************************************************/

		// ############################################################################

		LrColor & LrColor::operator = (const LrColor & c)
		{
		if(this == &c)return (*this);
		@@ -173,47 +205,59 @@ LrColor & LrColor::operator = (const LrColor & c)

		return (*this);
		}
		/****************************************************************************/

		// ############################################################################

		LrColor & LrColor::operator += (const LrColor & c)
		{
		return (this = (this + c));
		}
		/****************************************************************************/

		// ############################################################################

		LrColor & LrColor::operator -= (const LrColor & c)
		{
		return (this = (this - c));
		}
		/****************************************************************************/

		// ############################################################################

		LrColor & LrColor::operator *= (const LrColor &c)
		{
		return (this = (this * c));
		}
		/****************************************************************************/

		// ############################################################################

		bool operator == (const LrColor & c_lhs, const LrColor & c_rhs)
		{
		return ((c_lhs.m_r == c_rhs.m_r) && (c_lhs.m_g == c_rhs.m_g) && (c_lhs.m_b == c_rhs.m_b));
		return ((c_lhs.m_r == c_rhs.m_r) &&
		(c_lhs.m_g == c_rhs.m_g) &&
		(c_lhs.m_b == c_rhs.m_b));
		}
		/****************************************************************************/

		// ############################################################################

		bool operator != (const LrColor & c_lhs, const LrColor & c_rhs)
		{
		return !(c_lhs == c_rhs);
		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator + (const LrColor &lhs, const LrColor &rhs)
		{
		LrColor color;

		color.m_r = lhs.m_r + rhs.m_r;
		//if(color.m_r > 1)color.m_r = 1;

		color.m_g = lhs.m_g + rhs.m_g;
		//if(color.m_g > 1)color.m_g = 1;
		color.m_b = lhs.m_b + rhs.m_b;
		//if(color.m_b > 1)color.m_b = 1;

		return color;
		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator - (const LrColor &lhs, const LrColor &rhs)
		{
		LrColor color;
		@@ -229,7 +273,9 @@ LrColor operator - (const LrColor &lhs, const LrColor &rhs)

		return color;
		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator * (const LrColor &lhs, const LrColor &rhs)
		{
		LrColor color;
		@@ -240,7 +286,9 @@ LrColor operator * (const LrColor &lhs, const LrColor &rhs)

		return color;
		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator * (const LrColor &lhs, const Real coef)
		{
		LrColor color;
		@@ -252,7 +300,9 @@ LrColor operator * (const LrColor &lhs, const Real coef)
		return color;

		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator * (const Real coef, const LrColor &rhs)
		{
		LrColor color;
		@@ -263,7 +313,9 @@ LrColor operator * (const Real coef, const LrColor &rhs)

		return color;
		}
		/****************************************************************************/

		// ############################################################################

		LrColor operator / (const LrColor &lhs, const Real coef)
		{
		LrColor color;
		@@ -274,4 +326,6 @@ LrColor operator / (const LrColor &lhs, const Real coef)

		return color;
		}
		/****************************************************************************/

		// ############################################################################

LrColor.h

+247 −93

Original line number	Diff line number	Diff line
		/**
		* @brief OBJET : une couleur
		* @brief Classe pour la gestion des couleurs
		* @file LrColor.h
		* @date Vendredi 7 mars 2008
		* @note
		* @author Josselin Francois
		* @author Michael Nauge
		* @author Axel Richard
		* @author Hervé Souchaud
		* @author Emeric Verschuur
		*
		* Ce fichier contient la classe qui gère la creation d'une couleur
		*/


		#ifndef LRCOLOR_h
		#define LRCOLOR_h

		#include <stdint.h>


		/**
		* @brief COLOR : gestion des couleurs
		*
		* Ce fichier contient la classe qui gère la creation d'une couleur
		*/
		class LrColor
		{

		private :
		/** composante rouge */
		Real m_r;
		/** composante vert */
		Real m_g;
		/** composante bleu */
		Real m_b;

		public :

		/** COULEUR NOIRE */
		///@brief COULEUR NOIRE
		static const LrColor BLACK;
		/** COULEUR GRIS */
		///@brief COULEUR GRISE
		static const LrColor GREY;
		/** COULEUR BLANC */
		///@brief COULEUR BLANCHE
		static const LrColor WHITE;
		/** COULEUR ROUGE */
		///@brief COULEUR ROUGE
		static const LrColor RED;
		/** COULEUR VERT */
		///@brief COULEUR VERTE
		static const LrColor GREEN;
		/** COULEUR BLEUE */
		///@brief COULEUR BLEUE
		static const LrColor BLUE;
		/** COULEUR CYAN */
		///@brief COULEUR CYAN
		static const LrColor CYAN;
		/** COULEUR MAGENTA */
		///@brief COULEUR MAGENTA
		static const LrColor MAGENTA;
		/** COULEUR JAUNE */
		///@brief COULEUR JAUNE
		static const LrColor YELLOW;

		//Constructeurs
		/** par defaut */
		/**
		* @brief LrColor constructor
		*/
		LrColor();
		/** par copie */

		/**
		* @brief LrColor copy constructor
		* @param source LrColor object reference
		*/
		LrColor(const LrColor & c);
		/** personnel

		/**
		* @brief LrColor personnal constructor
		* @param red : composante rouge
		* @param green : composante vert
		@param blue : composante bleue /
		* @param blue : composante bleue
		*/
		LrColor(Real red, Real green, Real blue);
		/** construction a partir de valeurs comprises entre 0 et 255

		/**
		* @brief LrColor personnal constructor : construction a partir de valeurs
		* @brief comprises entre 0 et 255
		* @param red : rouge en RGB
		* @param green : vert en RGB
		@param blue : bleu en RGB/
		* @param blue : bleu en RGB
		*/
		LrColor(uint8_t red, uint8_t green, uint8_t blue);
		/** destructeur */

		/**
		* @brief LrColor destructor
		*/
		~LrColor();

		//Accesseurs
		/*return la composante rouge/
		/**
		* @brief Accesseur sur la composante rouge
		* @return La composante rouge sous forme de Real
		*/
		Real getRed() const;
		/*modifie la composante rouge/

		/**
		* @brief Modifie la composante rouge
		* @param red Real pour modifier la composante rouge
		*/
		void setRed(Real red);
		/*return la composante vert/

		/**
		* @brief Accesseur sur la composante verte
		* @return La composante verte sous forme de Real
		*/
		Real getGreen() const;
		/*modifie la composante vert/

		/**
		* @brief Modifie la composante verte
		* @param green Real pour modifier la composante verte
		*/
		void setGreen(Real green);
		/*return la composante bleu/

		/**
		* @brief Accesseur sur la composante bleue
		* @return La composante bleue sous forme de Real
		*/
		Real getBlue() const;
		/*modifie la composante bleu/

		/**
		* @brief Modifie la composante bleue
		* @param blue Real pour modifier la composante bleue
		*/
		void setBlue(Real blue);

		/**met à jour les variables entrantes, en convertissant
		les valeurs Real de l'instance au format RGB 255*/
		void toRGB255 (uint8_t &red, uint8_t &green, uint8_t &blue) const;
		/*return la composante rouge convertie en RGB /
		/**
		* @brief Accesseur sur la composante rouge
		* @return la composante rouge convertie en RGB sous forme de uint8_t
		*/
		uint8_t getRed255();
		/*return la composante vert convertie en RGB/
		uint8_t getGreen255();
		/*return la composante bleu convertie en RGB/
		uint8_t getBlue255();

		/*Modifie les valeurs de l'instance � partir de valeurs RGB255/
		void fromRGB255 (const uint8_t red, const uint8_t green, const uint8_t blue);
		/modifie la composante rouge à partir d'une valeur RGB/
		/**
		* @brief Modifie la composante rouge à partir d'une valeur RGB
		* @param red uint8_t pour modifier la composante rouge
		*/
		void setRed255(uint8_t red);
		/*modifie la composante verte à partir d'une valeur RGB/

		/**
		* @brief Accesseur sur la composante verte
		* @return la composante verte convertie en RGB sous forme de uint8_t
		*/
		uint8_t getGreen255();

		/**
		* @brief Modifie la composante verte à partir d'une valeur RGB
		* @param green uint8_t pour modifier la composante verte
		*/
		void setGreen255(uint8_t green);
		/*modifie la composante bleue à partir d'une valeur RGB/

		/**
		* @brief Accesseur sur la composante bleue
		* @return la composante bleue convertie en RGB sous forme de uint8_t
		*/
		uint8_t getBlue255();

		/**
		* @brief Modifie la composante bleue à partir d'une valeur RGB
		* @param blue uint8_t pour modifier la composante bleue
		*/
		void setBlue255(uint8_t blue);

		//Opérateurs
		/**
		* @brief Methode qui met à jour les variables entrantes red, green et blue,
		* @brief en convertissant les valeurs Real de l'instance au format RGB 255
		* @param red reference uint8_t pour modifier la composante rouge
		* @param green reference uint8_t pour modifier la composante verte
		* @param blue reference uint8_t pour modifier la composante bleue
		*/
		void toRGB255 (uint8_t &red, uint8_t &green, uint8_t &blue) const;

		/**
		* @brief Methode qui modifie les valeurs de l'instance à partir de valeurs
		* @brief RGB255
		* @param red uint8_t pour modifier la composante rouge
		* @param green uint8_t pour modifier la composante verte
		* @param blue uint8_t pour modifier la composante bleue
		*/
		void fromRGB255 (const uint8_t red, const uint8_t green, const uint8_t blue);

		/**
		* @brief Opérateur d'affectation
		* @param c LrColor modèle
		* @return Retourne une nouvelle LrColor
		*/
		LrColor & operator = (const LrColor & c);

		/**
		* @brief Opérateur d'addition et d'affectation
		* @param c LrColor modèle
		* @return Retourne une nouvelle LrColor
		*/
		LrColor & operator += (const LrColor & c);

		/**
		* @brief Opérateur de soustraction et d'affectation
		* @param c LrColor modèle
		* @return Retourne une nouvelle LrColor
		*/
		LrColor & operator -= (const LrColor & c);

		/**
		* @brief Opérateur de multiplication et d'affectation
		* @param c LrColor modèle
		* @return Retourne une nouvelle LrColor
		*/
		LrColor & operator *= ( const LrColor &c);

		/**
		* @brief Opérateur d'égalité
		* @param lhs Opérande gauche de type LrColor
		* @param rhs Opérande droite de type LrColor
		* @return Retourne vrai si lhs et rhs sont égaux
		*/
		friend bool operator == (const LrColor & c_lhs, const LrColor & c_rhs);

		/**
		* @brief Opérateur d'égalité
		* @param lhs Opérande gauche de type LrColor
		* @param rhs Opérande droite de type LrColor
		* @return Retourne vrai si lhs et rhs sont diférents
		*/
		friend bool operator != (const LrColor & c_lhs, const LrColor & c_rhs);

		/**
		* @brief Opérateur d'addition
		* @param lhs Opérande gauche de type LrColor
		* @param rhs Opérande droite de type LrColor
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator + (const LrColor &lhs, const LrColor &rhs);

		/**
		* @brief Opérateur de soustraction
		* @param lhs Opérande gauche de type LrColor
		* @param rhs Opérande droite de type LrColor
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator - (const LrColor &lhs, const LrColor &rhs);

		/**
		* @brief Opérateur de multiplication
		* @param lhs Opérande gauche de type LrColor
		* @param rhs Opérande droite de type LrColor
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator * (const LrColor &lhs, const LrColor &rhs);

		/**
		* @brief Opérateur de multiplication
		* @param lhs Opérande gauche de type LrColor
		* @param coef Opérande droite de type Real
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator * (const LrColor &lhs, const Real coef);

		/**
		* @brief Opérateur de multiplication
		* @param coef Opérande gauche de type Real
		* @param lhs Opérande droite de type LrColor
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator * (const Real coef, const LrColor &rhs);

		/**
		* @brief Opérateur de division
		* @param lhs Opérande gauche de type LrColor
		* @param coef Opérande droite de type Real
		* @return Retourne une nouvelle LrColor
		*/
		friend LrColor operator / (const LrColor &lhs, const Real coef);


		private :
		/** composante rouge */
		Real m_r;
		/** composante verte */
		Real m_g;
		/** composante bleue */
		Real m_b;

		};

		#endif