/// <param name="r">Red (from 0 to 1)</param> /// <param name="g">Green (from 0 to 1)</param> /// <param name="b">Blue (from 0 to 1)</param> /// <param name="workingSpace"> /// <see cref="RGBWorkingSpaces" /> /// </param> public LinearRGBColor(double r, double g, double b, IRGBWorkingSpace workingSpace) { R = r.CheckRange(0, 1); G = g.CheckRange(0, 1); B = b.CheckRange(0, 1); _workingSpace = workingSpace; }
protected bool Equals(IRGBWorkingSpace other) { if (other == null) { throw new ArgumentNullException("other"); } return(Equals(WhitePoint, other.WhitePoint) && ChromaticityCoordinates.Equals(other.ChromaticityCoordinates) && Equals(Companding, other.Companding)); }
private XYZToLinearRGBConverter GetXYZToLinearRGBConverter(IRGBWorkingSpace workingSpace) { if (_lastXYZToLinearRGBConverter != null && _lastXYZToLinearRGBConverter.TargetRGBWorkingSpace.Equals(workingSpace)) { return(_lastXYZToLinearRGBConverter); } return(_lastXYZToLinearRGBConverter = new XYZToLinearRGBConverter(workingSpace)); }
public ColourfulConverter() { WhitePoint = DefaultWhitePoint; LMSTransformationMatrix = XYZAndLMSConverter.DefaultTransformationMatrix; ChromaticAdaptation = new VonKriesChromaticAdaptation(_cachedXYZAndLMSConverter, _cachedXYZAndLMSConverter); TargetLabWhitePoint = LabColor.DefaultWhitePoint; TargetHunterLabWhitePoint = HunterLabColor.DefaultWhitePoint; TargetLuvWhitePoint = LuvColor.DefaultWhitePoint; TargetRGBWorkingSpace = RGBColor.DefaultWorkingSpace; }
private LinearRGBToXYZConverter GetLinearRGBToXYZConverter(IRGBWorkingSpace workingSpace) { if (_lastLinearRGBToXYZConverter != null && _lastLinearRGBToXYZConverter.SourceRGBWorkingSpace.Equals(workingSpace)) { return(_lastLinearRGBToXYZConverter); } return(_lastLinearRGBToXYZConverter = new LinearRGBToXYZConverter(workingSpace)); }
public void DifferentWorkingSpace_IsNotEqual() { // arrange IRGBWorkingSpace x = RGBWorkingSpaces.sRGB; IRGBWorkingSpace y = RGBWorkingSpaces.AdobeRGB1998; // act bool equals = x.Equals(y); // assert Assert.IsFalse(equals); }
public void DifferentWorkingSpace_SameSpecifiers_IsEqual() { // arrange IRGBWorkingSpace x = new AdobeRGB1998Duplicate(); IRGBWorkingSpace y = RGBWorkingSpaces.AdobeRGB1998; // act bool equals = y.Equals(x); // assert Assert.IsTrue(equals); }
public void SameWorkingSpace_IsEqual() { // arrange IRGBWorkingSpace x = RGBWorkingSpaces.sRGB; IRGBWorkingSpace y = RGBWorkingSpaces.sRGB; // act bool equals = x.Equals(y); // assert Assert.IsTrue(equals); }
/// <summary> /// Computes RGB/XYZ matrix /// </summary> protected static Matrix GetRGBToXYZMatrix(IRGBWorkingSpace workingSpace) { if (workingSpace == null) { throw new ArgumentNullException(nameof(workingSpace)); } // for more info, see: http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html var chromaticity = workingSpace.ChromaticityCoordinates; double xr = chromaticity.R.x, xg = chromaticity.G.x, xb = chromaticity.B.x, yr = chromaticity.R.y, yg = chromaticity.G.y, yb = chromaticity.B.y; var Xr = xr / yr; const double Yr = 1; var Zr = (1 - xr - yr) / yr; var Xg = xg / yg; const double Yg = 1; var Zg = (1 - xg - yg) / yg; var Xb = xb / yb; const double Yb = 1; var Zb = (1 - xb - yb) / yb; var S = new Matrix(new Vector[] { new[] { Xr, Xg, Xb }, new[] { Yr, Yg, Yb }, new[] { Zr, Zg, Zb }, }).Inverse(); var W = workingSpace.WhitePoint.Vector; var SW = S.MultiplyBy(W); var Sr = SW[0]; var Sg = SW[1]; var Sb = SW[2]; Matrix M = new Vector[] { new[] { Sr *Xr, Sg *Xg, Sb *Xb }, new[] { Sr *Yr, Sg *Yg, Sb *Yb }, new[] { Sr *Zr, Sg *Zg, Sb *Zb }, }; return(M); }
/// <inheritdoc cref="object" /> public bool Equals(IRGBWorkingSpace other) { if (other == null) { return(false); } if (ReferenceEquals(this, other)) { return(true); } return(Equals(WhitePoint, other.WhitePoint) && ChromaticityCoordinates.Equals(other.ChromaticityCoordinates) && Companding.Equals(other.Companding)); }
/// <summary> /// Applying the working space companding function (<see cref="IRGBWorkingSpace.Companding"/>) to uncompanded vector. /// </summary> private static RGBColor CompandVector(Vector uncompandedVector, IRGBWorkingSpace workingSpace) { ICompanding companding = workingSpace.Companding; Vector compandedVector = uncompandedVector.Select(companding.Companding).ToList(); double R, G, B; compandedVector.AssignVariables(out R, out G, out B); R = R.CropRange(0, 1); G = G.CropRange(0, 1); B = B.CropRange(0, 1); var result = new RGBColor(R, G, B, workingSpace); return(result); }
protected static Matrix GetRGBToXYZMatrix(IRGBWorkingSpace workingSpace) { if (workingSpace == null) { throw new ArgumentNullException("workingSpace"); } // for more info, see: http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html RGBPrimariesChromaticityCoordinates chromaticity = workingSpace.ChromaticityCoordinates; double xr = chromaticity.R.x, xg = chromaticity.G.x, xb = chromaticity.B.x, yr = chromaticity.R.y, yg = chromaticity.G.y, yb = chromaticity.B.y; double Sr, Sg, Sb; double Xr = xr / yr; const double Yr = 1; double Zr = (1 - xr - yr) / yr; double Xg = xg / yg; const double Yg = 1; double Zg = (1 - xg - yg) / yg; double Xb = xb / yb; const double Yb = 1; double Zb = (1 - xb - yb) / yb; var S = new [] { new[] { Xr, Xg, Xb }, new[] { Yr, Yg, Yb }, new[] { Zr, Zg, Zb }, }.Inverse(); Vector W = workingSpace.WhitePoint.Vector; (S.MultiplyBy(W)).AssignVariables(out Sr, out Sg, out Sb); var M = new [] { new[] { Sr *Xr, Sg *Xg, Sb *Xb }, new[] { Sr *Yr, Sg *Yg, Sb *Yb }, new[] { Sr *Zr, Sg *Zg, Sb *Zb }, }; return(M); }
protected static Matrix GetRGBToXYZMatrix(IRGBWorkingSpace workingSpace) { if (workingSpace == null) throw new ArgumentNullException("workingSpace"); // for more info, see: http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html RGBPrimariesChromaticityCoordinates chromaticity = workingSpace.ChromaticityCoordinates; double xr = chromaticity.R.x, xg = chromaticity.G.x, xb = chromaticity.B.x, yr = chromaticity.R.y, yg = chromaticity.G.y, yb = chromaticity.B.y; double Sr, Sg, Sb; double Xr = xr / yr; const double Yr = 1; double Zr = (1 - xr - yr) / yr; double Xg = xg / yg; const double Yg = 1; double Zg = (1 - xg - yg) / yg; double Xb = xb / yb; const double Yb = 1; double Zb = (1 - xb - yb) / yb; var S = new [] { new[] { Xr, Xg, Xb }, new[] { Yr, Yg, Yb }, new[] { Zr, Zg, Zb }, }.Inverse(); Vector W = workingSpace.WhitePoint.Vector; (S.MultiplyBy(W)).AssignVariables(out Sr, out Sg, out Sb); var M = new [] { new[] { Sr * Xr, Sg * Xg, Sb * Xb }, new[] { Sr * Yr, Sg * Yg, Sb * Yb }, new[] { Sr * Zr, Sg * Zg, Sb * Zb }, }; return M; }
/// <summary> /// Creates RGB color with all channels equal /// </summary> /// <param name="value">Grey value (from 0 to 1)</param> /// <param name="workingSpace"><see cref="RGBWorkingSpaces"/></param> public static RGBColor FromGrey(double value, IRGBWorkingSpace workingSpace) { return(new RGBColor(value, value, value, workingSpace)); }
public RGBColor(double r, double g, double b, IRGBWorkingSpace workingSpace) : base(r, g, b) { WorkingSpace = workingSpace; }
/// <param name="vector"><see cref="Vector"/>, expected 3 dimensions (range from 0 to 1)</param> /// <param name="workingSpace"><see cref="RGBWorkingSpaces"/></param> public RGBColor(Vector vector, IRGBWorkingSpace workingSpace) : base(vector) { WorkingSpace = workingSpace; }
public RGBColor(double r, double g, double b, IRGBWorkingSpace workingSpace) : base(r, g, b) { WorkingSpace = workingSpace; }
public static RGBColor FromRGB8bit(byte red, byte green, byte blue, IRGBWorkingSpace workingSpace) { return new RGBColor(red / 255d, green / 255d, blue / 255d, workingSpace); }
/// <param name="sourceRGBWorkingSpace">Source RGB working space</param> public LinearRGBToXYZConverter(IRGBWorkingSpace sourceRGBWorkingSpace) { SourceRGBWorkingSpace = sourceRGBWorkingSpace; _conversionMatrix = GetRGBToXYZMatrix(SourceRGBWorkingSpace); }
/// <summary> /// Computes XYZ/RGB matrix /// </summary> protected static Matrix GetXYZToRGBMatrix(IRGBWorkingSpace workingSpace) => GetRGBToXYZMatrix(workingSpace).Inverse();
public static RGBColor ToRGBColor(this Color c, IRGBWorkingSpace space) { return(new RGBColor(c.r, c.g, c.b, space)); }
protected static Matrix GetXYZToRGBMatrix(IRGBWorkingSpace workingSpace) { return GetRGBToXYZMatrix(workingSpace).Inverse(); }
/// <param name="vector"><see cref="Vector"/>, expected 3 dimensions (range from 0 to 1)</param> /// <param name="workingSpace"><see cref="RGBWorkingSpaces"/></param> public RGBColor(Vector vector, IRGBWorkingSpace workingSpace) : base(vector) { WorkingSpace = workingSpace; }
protected bool Equals(IRGBWorkingSpace other) { if (other == null) throw new ArgumentNullException("other"); return Equals(WhitePoint, other.WhitePoint) && ChromaticityCoordinates.Equals(other.ChromaticityCoordinates) && Equals(Companding, other.Companding); }
/// <summary> /// Creates RGB color from 8-bit channels /// </summary> /// <param name="red"></param> /// <param name="green"></param> /// <param name="blue"></param> /// <param name="workingSpace"> /// <see cref="RGBWorkingSpaces" /> /// </param> public static RGBColor FromRGB8bit(byte red, byte green, byte blue, IRGBWorkingSpace workingSpace) => new RGBColor(red / 255d, green / 255d, blue / 255d, workingSpace);
/// <summary> /// Creates RGB color with all channels equal /// </summary> /// <param name="value">Grey value (from 0 to 1)</param> /// <param name="workingSpace"> /// <see cref="RGBWorkingSpaces" /> /// </param> public static LinearRGBColor FromGrey(double value, IRGBWorkingSpace workingSpace) => new LinearRGBColor(value, value, value, workingSpace);
public XYZToLinearRGBConverter(IRGBWorkingSpace targetRGBWorkingSpace) { TargetRGBWorkingSpace = targetRGBWorkingSpace ?? RGBColor.DefaultWorkingSpace; _conversionMatrix = GetXYZToRGBMatrix(TargetRGBWorkingSpace); }
/// <param name="workingSpace"><see cref="RGBWorkingSpaces"/></param> public RGBColor(Color color, IRGBWorkingSpace workingSpace) : base(((double)color.R) / 255, ((double)color.G) / 255, ((double)color.B) / 255) { WorkingSpace = workingSpace; }
public static RGBColor AsRGBColor(Color color, IRGBWorkingSpace workingSpace) { return(new RGBColor(((double)color.R) / 255, ((double)color.G) / 255, ((double)color.B) / 255, workingSpace)); }
/// <summary> /// Creates RGB color with all channels equal /// </summary> /// <param name="value">Grey value (from 0 to 1)</param> /// <param name="workingSpace"><see cref="RGBWorkingSpaces"/></param> public static RGBColor FromGrey(double value, IRGBWorkingSpace workingSpace) { return new RGBColor(value, value, value, workingSpace); }
/// <param name="vector"><see cref="Vector" />, expected 3 dimensions (range from 0 to 1)</param> /// <param name="workingSpace"> /// <see cref="RGBWorkingSpaces" /> /// </param> public LinearRGBColor(Vector vector, IRGBWorkingSpace workingSpace) : this(vector[0], vector[1], vector[2], workingSpace) { }
/// <param name="color"></param> /// <param name="workingSpace"> /// <see cref="RGBWorkingSpaces" /> /// </param> public RGBColor(Color color, IRGBWorkingSpace workingSpace) : this((double)color.R / 255, (double)color.G / 255, (double)color.B / 255, workingSpace) { }