A lot of code cleanups

Author: castarco

CHANGELOG.md

@@ -1,6 +1,26 @@
 ColorSharp's Changelog
 ======================
 
+## 2014-11-05 : 0.7.0 Release
+
+### Contributors
+ * Andrés Correa Casablanca <[email protected] , [email protected]>
+
+### Changes
+ * Improved XML documentation.
+ * Removed many build warnings (related with XML documentation).
+ * Sealed many classes.
+ * Big refactor:
+   * Removed the colors conversion path search mechanism.
+   * Now is less flexible, but more efficient and simple.
+   * Now it's better to use the non type-parametric conversion methods.
+   * **WARNING:** Now we assume that Y=1 in CIE's xyY or XYZ color spaces is the luminance of the white point.
+   * **WARNING:** Breaks API.
+
+### Bugfixes
+ * Bugfix in sRGB->CIE's 1931 XYZ conversion (the gamma correction was done after the lineal transformation)
+
+
 ## 2014-11-05 : 0.6.0 Release
 
 ### Contributors

ColorSharp.sln

@@ -34,6 +34,6 @@ Global
 		$0.VersionControlPolicy = $2
 		$2.inheritsSet = Mono
 		description = A .Net/Mono library to handle color spaces (and light spectrums!)
-		version = 0.6.0
+		version = 0.7.0
 	EndGlobalSection
 EndGlobal

ColorSharp/ColorSharp.csproj

@@ -11,7 +11,7 @@
     <SignAssembly>true</SignAssembly>
     <DelaySign>false</DelaySign>
     <AssemblyOriginatorKeyFile>colorsharp.snk</AssemblyOriginatorKeyFile>
-    <ReleaseVersion>0.6.0</ReleaseVersion>
+    <ReleaseVersion>0.7.0</ReleaseVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

ColorSharp/ColorSharp.nuspec

@@ -11,9 +11,10 @@
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>$description$</description>
     <releaseNotes>
-      - Improved documentation
-      - Minor cleanups
-      - Bugfix in sRGB -> CIE's 1931 XYZ conversion
+ - Improved documentation
+ - Minor cleanups
+ - Big refactor
+ - Removed NUnit dependency
     </releaseNotes>
     <copyright>Copyright 2014</copyright>
     <tags>Light Color Colour CIEXYZ CIExyY sRGB</tags>

ColorSharp/Properties/AssemblyInfo.cs

@@ -46,7 +46,7 @@
 // The form "{Major}.{Minor}.*" will automatically update the build and revision,
 // and "{Major}.{Minor}.{Build}.*" will update just the revision.
 
-[assembly: AssemblyVersion ("0.6.0.*")]
+[assembly: AssemblyVersion ("0.7.0.*")]
 
 // The following attributes are used to specify the signing key for the assembly,
 // if desired. See the Mono documentation for more information about signing.

ColorSharp/src/ColorSpaces/AConvertibleColor.cs

@@ -35,19 +35,26 @@ namespace Litipk.ColorSharp
 {
 	namespace ColorSpaces
 	{
+		/**
+		 *
+		 */
 		public abstract class AConvertibleColor
 		{
 			#region properties
 
-			// If this "color" comes from another data source, then we keep the original data.
-			protected AConvertibleColor DataSource = null;
+			/**
+			 * <value>Original color sample</value>
+			 */
+			public readonly AConvertibleColor DataSource = null;
 
 			#endregion
 
 
 			#region constructors
 
-			// TODO: Check if this should be public in order to work as expected with reflection.
+			/**
+			 * Boilerplate constructor
+			 */
 			protected AConvertibleColor(AConvertibleColor dataSource = null)
 			{
 				DataSource = dataSource;
@@ -58,37 +65,49 @@ protected AConvertibleColor(AConvertibleColor dataSource = null)
 
 			#region conversion skeleton
 
+			/**
+			 * <see cref="ConvertTo"/>
+			 */
 			public T ConvertTo<T> (ConversionStrategy strategy=ConversionStrategy.Default) where T : AConvertibleColor
 			{
-				Type t = typeof(T);
+				return (T)ConvertTo (typeof(T), strategy);
+			}
+
+			/**
+			 * <summary>Method that allows conversions passing the type as a parameter.</summary>
+			 * <remarks>DON'T USE it to implement conversion methods, use the non type-parametric variants.</remarks>
+			 */
+			public AConvertibleColor ConvertTo (Type t, ConversionStrategy strategy=ConversionStrategy.Default)
+			{
 				Type tt = GetType ();
 
 				if (t == tt) {
 					// Dumb conversion
-					return (T)(AConvertibleColor)this;
+					return this;
 				}
 
 				if (DataSource != null) {
 					if (DataSource.GetType () == t) {
-						return (T)DataSource;
+						return DataSource;
 					}
 
-					return DataSource.ConvertTo<T> (strategy);
+					return DataSource.ConvertTo(t, strategy);
 				}
 
-				return InnerConvertTo<T> (strategy);
+				return InnerConvertTo(t, strategy);
 			}
 
-			protected T InnerConvertTo<T> (ConversionStrategy strategy = ConversionStrategy.Default) where T : AConvertibleColor
+			/**
+			 * Helper method used by ConvertTo.
+			 */
+			private AConvertibleColor InnerConvertTo (Type t, ConversionStrategy strategy = ConversionStrategy.Default)
 			{
-				Type t = typeof(T);
-
 				if (t == typeof(CIEXYZ))
-					return (T)(AConvertibleColor)ToCIEXYZ (strategy);
+					return ToCIEXYZ (strategy);
 				if (t == typeof(CIExyY))
-					return (T)(AConvertibleColor)ToCIExyY(strategy);
+					return ToCIExyY(strategy);
 				if (t == typeof(SRGB))
-					return (T)(AConvertibleColor)ToSRGB (strategy);
+					return ToSRGB (strategy);
 
 				throw new NotImplementedException ("This conversion isn't implemented.");
 			}
@@ -114,7 +133,7 @@ protected T InnerConvertTo<T> (ConversionStrategy strategy = ConversionStrategy.
 			public abstract CIExyY ToCIExyY (ConversionStrategy strategy = ConversionStrategy.Default);
 
 			/**
-			 * <summary>Converts the color sample to an HP's & Microsoft's 1996 sRGB sample.</summary>
+			 * <summary>Converts the color sample to an HP's and Microsoft's 1996 sRGB sample.</summary>
 			 */
 			public abstract SRGB ToSRGB(ConversionStrategy strategy = ConversionStrategy.Default);
 

ColorSharp/src/ColorSpaces/SRGB.cs

@@ -36,19 +36,39 @@ namespace Litipk.ColorSharp
 	namespace ColorSpaces
 	{
 		/**
-		 * <summary>HP's & Microsoft's 1996 sRGB Color Space.</summary>
+		 * <summary>HP's and Microsoft's 1996 sRGB Color Space.</summary>
 		 */
 		public sealed class SRGB : AConvertibleColor
 		{
 			#region private properties
 
-			public readonly double R, G, B;
+			/**
+			 * <value>Red component</value>
+			 */
+			public readonly double R;
+
+			/**
+			 * <value>Green component</value>
+			 */
+			public readonly double G;
+
+			/**
+			 * <value>Blue component</value>
+			 */
+			public readonly double B;
 
 			#endregion
 
 
 			#region constructors
 
+			/**
+			 * <summary>Creates a new color sample in the sRGB color space</summary>
+			 * <param name="R">Red component (between 0 and 1)</param>
+			 * <param name="G">Green component (between 0 and 1)</param>
+			 * <param name="B">Blue component (between 0 and 1)</param>
+			 * <param name="dataSource">If you aren't working with ColorSharp internals, don't use this parameter</param>
+			 */
 			public SRGB (double R, double G, double B, AConvertibleColor dataSource=null) : base(dataSource)
 			{
 				this.R = R;
@@ -61,6 +81,9 @@ public SRGB (double R, double G, double B, AConvertibleColor dataSource=null) :
 
 			#region AConvertibleColor methods
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override bool IsInsideColorSpace()
 			{
 				return (
@@ -71,8 +94,8 @@ public override bool IsInsideColorSpace()
 			}
 
 			/**
-		 * Converts the HP's & Microsoft's 1996 sRGB sample to a CIE 1931 XYZ sample
-		 */
+			 * <inheritdoc />
+			 */
 			public override CIEXYZ ToCIEXYZ (ConversionStrategy strategy=ConversionStrategy.Default)
 			{
 				// Gamma correction
@@ -89,11 +112,17 @@ public override CIEXYZ ToCIEXYZ (ConversionStrategy strategy=ConversionStrategy.
 				);
 			}
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override CIExyY ToCIExyY (ConversionStrategy strategy = ConversionStrategy.Default)
 			{
 				return ToCIEXYZ ().ToCIExyY ();
 			}
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override SRGB ToSRGB (ConversionStrategy strategy = ConversionStrategy.WaveLength5NmStep)
 			{
 				return this;
@@ -104,6 +133,9 @@ public override SRGB ToSRGB (ConversionStrategy strategy = ConversionStrategy.Wa
 
 			#region Object methods
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override bool Equals(Object obj)
 			{
 				SRGB srgbObj = obj as SRGB; 
@@ -117,6 +149,10 @@ public override bool Equals(Object obj)
 					Math.Abs (B - srgbObj.B) <= double.Epsilon
 				);
 			}
+
+			/**
+			 * <inheritdoc />
+			 */
 			public override int GetHashCode ()
 			{
 				int hash = 17;

ColorSharp/src/InternalUtils/Comparers.cs

@@ -35,17 +35,14 @@ namespace Litipk.ColorSharp
 {
 	namespace InternalUtils
 	{
-		/**
-		 * Internal Class 
-		 */
-		class KeyValuePairComparer : IComparer<KeyValuePair<double, double>> {
+		sealed class KeyValuePairComparer : IComparer<KeyValuePair<double, double>> {
 			public int Compare(KeyValuePair<double, double> a, KeyValuePair<double, double> b)
 			{
 				return Math.Abs (a.Key - b.Key) <= double.Epsilon ? 0 : a.Key.CompareTo (b.Key);
 			}
 		}
 
-		class xyYPointComparer : IComparer<xyYPoint> {
+		sealed class xyYPointComparer : IComparer<xyYPoint> {
 			public int Compare(xyYPoint a, xyYPoint b)
 			{
 				return (a.x == b.x) ? 

ColorSharp/src/LightSpectrums/ALightSpectrum.cs

@@ -39,29 +39,43 @@ namespace Litipk.ColorSharp
 
 	namespace LightSpectrums
 	{
+		/**
+		 * <summary>Abstract class that provides basic methods to manipulate light spectrums.</summary>
+		 */
 		public abstract class ALightSpectrum : AConvertibleColor, IRealFunctionWithFiniteSupport
 		{
+			/**
+			 * Boilerplate constructor
+			 */
 			protected ALightSpectrum(AConvertibleColor dataSource=null) : base(dataSource) { }
 
-			#region inheritable methods
+			#region abstract methods
 
 			#region IRealFunctionWithFiniteSupport methods
 
 			/**
-			 * This gives us the wave amplitude at a given wave length, if it's necessary the method will do interpolation.
+			 * <inheritdoc />
 			 */
 			public abstract double EvaluateAt(double waveLength);
 
-			// Analytic aproximations also have their confidence intervals, so
-			// there aren't exceptional cases here.
+			/**
+			 * <inheritdoc />
+			 */
 			public abstract double GetSupportMinValue ();
+
+			/**
+			 * <inheritdoc />
+			 */
 			public abstract double GetSupportMaxValue ();
 
-			// 
+			/**
+			 * <inheritdoc />
+			 */
 			public abstract double GetMaxValueOnSupport ();
 
-			// We need to know how many data points we have to make computations using all the information we have.
-			// If the concrete implementation is "analytical", then must return -1.
+			/**
+			 * <inheritdoc />
+			 */
 			public abstract int GetNumberOfDataPoints();
 
 			#endregion
@@ -77,6 +91,9 @@ protected ALightSpectrum(AConvertibleColor dataSource=null) : base(dataSource) {
 
 			#region AConvertibleColor methods
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override CIEXYZ ToCIEXYZ (ConversionStrategy strategy=ConversionStrategy.Default)
 			{
 				// TODO : Check ConversionStrategy
@@ -92,11 +109,17 @@ MFs [0].DoConvolution (this), MFs [1].DoConvolution (this), MFs [2].DoConvolutio
 				);
 			}
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override CIExyY ToCIExyY (ConversionStrategy strategy = ConversionStrategy.Default)
 			{
 				return ToCIEXYZ ().ToCIExyY (strategy);
 			}
 
+			/**
+			 * <inheritdoc />
+			 */
 			public override SRGB ToSRGB(ConversionStrategy strategy = ConversionStrategy.Default)
 			{
 				return ToCIEXYZ ().ToSRGB (strategy);

ColorSharp/src/LightSpectrums/RegularLightSpectrum.cs

@@ -36,7 +36,10 @@ namespace Litipk.ColorSharp
 
 	namespace LightSpectrums
 	{
-		public class RegularLightSpectrum : ALightSpectrum
+		/**
+		 * Class to handle light spectrum samples with equidistant data points
+		 */
+		public sealed class RegularLightSpectrum : ALightSpectrum
 		{
 			#region properties