// Copyright 2013 - Felix Obermaier (www.ivv-aachen.de)

//

// This file is part of SharpMap.Layers.HeatLayer.

// SharpMap.Layers.HeatLayer is free software; you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// SharpMap.Layers.HeatLayer is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

//

// You should have received a copy of the GNU Lesser General Public License

// along with SharpMap; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

// ***********************************************************************************************

//

// Original idea by Konstantin Vasserman, published on

// http://www.codeproject.com/Articles/5527/Blending-of-images-raster-operations-and-basic-col

//

// ***********************************************************************************************

//

// Modifications

// - ReSharper Renaming

// - removed unsafe constructs

// - removed cloning of bitmaps in

// - PerChannelProcess

// - RgbProcess

// - Changed argument type from Image to Bitmap

//

using System;

using System.Drawing;

using System.Drawing.Drawing2D;

using System.Drawing.Imaging;

namespace SharpMap.Layers

{

/// <summary>

/// Class for image blending operations.

/// </summary>

/// <seealso href="http://www.codeproject.com/KB/GDI-plus/KVImageProcess.aspx"/>

/// <remarks>

/// ToDo This class is neat, but overkill:

/// Only <see cref="BlendOperation.BlendMultiply"/> is used along with the

/// <see cref="BlendImages(System.Drawing.Bitmap,int,int,int,int,SharpMap.Layers.BlendOperation)"/>

/// function</remarks>

internal static class ImageBlender

{

///NTSC defined color weights

private const float NtscRedWeight = 0.299f;

private const float NtscGreenWeight = 0.587f;

private const float NtscBlueWeight = 0.144f;

private const ushort HlsMax = 360;

private const byte RgbMax = 255;

private const byte HueUndefined = 0;

private delegate byte PerChannelProcessDelegate(ref byte nSrc, ref byte nDst);

private delegate void RgbProcessDelegate(byte sR, byte sG, byte sB, ref byte dR, ref byte dG, ref byte dB);

/// <summary>

/// Method to invert an image

/// </summary>

/// <param name="img">The image to invert</param>

public static void Invert(Image img)

{

if (img == null)

throw new Exception("Image must be provided");

var cMatrix = new ColorMatrix(new[]

{

new[] {-1.0f, 0.0f, 0.0f, 0.0f, 0.0f },

new[] { 0.0f,-1.0f, 0.0f, 0.0f, 0.0f },

new[] { 0.0f, 0.0f,-1.0f, 0.0f, 0.0f },

new[] { 0.0f, 0.0f, 0.0f, 1.0f, 0.0f },

new[] { 1.0f, 1.0f, 1.0f, 0.0f, 1.0f }

});

ApplyColorMatrix(img, cMatrix);

}

/// <summary>

/// Method to adjust an image's brightness

/// </summary>

/// <param name="img">The image</param>

/// <param name="adjValueR">Adjustment value for the red channel [-1f, 1f]</param>

/// <param name="adjValueG">Adjustment value for the green channel [-1f, 1f]</param>

/// <param name="adjValueB">Adjustment value for the blue channel [-1f, 1f]</param>

public static void AdjustBrightness(Image img, float adjValueR, float adjValueG, float adjValueB)

{

if (img == null)

throw new Exception("Image must be provided");

var cMatrix = new ColorMatrix(new[]

{

new[] { 1.0f, 0.0f, 0.0f, 0.0f, 0.0f },

new[] { 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },

new[] { 0.0f, 0.0f, 1.0f, 0.0f, 0.0f },

new[] { 0.0f, 0.0f, 0.0f, 1.0f, 0.0f },

new[] { adjValueR, adjValueG, adjValueB, 0.0f, 1.0f }

});

ApplyColorMatrix(img, cMatrix);

}

/// <summary>

/// Method to adjust an image's brightness

/// </summary>

/// <param name="img">The image</param>

/// <param name="adjValue">Adjustment value for all channels [-1f, 1f]</param>

public static void AdjustBrightness(Image img, float adjValue)

{

AdjustBrightness(img, adjValue, adjValue, adjValue);

}

// Saturation. 0.0 = desaturate, 1.0 = identity, -1.0 = complementary colors

public static void AdjustSaturation(Image img, float sat, float rweight, float gweight, float bweight)

{

if (img == null)

throw new Exception("Image must be provided");

var cMatrix = new ColorMatrix(new[] {

new [] { (1.0f-sat)*rweight+sat, (1.0f-sat)*rweight, (1.0f-sat)*rweight, 0.0f, 0.0f },

new [] { (1.0f-sat)*gweight, (1.0f-sat)*gweight+sat, (1.0f-sat)*gweight, 0.0f, 0.0f },

new [] { (1.0f-sat)*bweight, (1.0f-sat)*bweight, (1.0f-sat)*bweight+sat, 0.0f, 0.0f },

new [] { 0.0f, 0.0f, 0.0f, 1.0f, 0.0f },

new [] { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }

});

ApplyColorMatrix(img, cMatrix);

}

// Saturation. 0.0 = desaturate, 1.0 = identity, -1.0 = complementary colors

public static void AdjustSaturation(Image img, float sat)

{

AdjustSaturation(img, sat, NtscRedWeight, NtscGreenWeight, NtscBlueWeight);

}

// Weights between 0.0 and 1.0

public static void Desaturate(Image img, float redWeight, float greenWeight, float blueWeight)

{

AdjustSaturation(img, 0.0f, redWeight, greenWeight, blueWeight);

}

// Desaturate using "default" NTSC defined color weights

public static void Desaturate(Image img)

{

AdjustSaturation(img, 0.0f, NtscRedWeight, NtscGreenWeight, NtscBlueWeight);

}

public static void ApplyColorMatrix(Image img, ColorMatrix colMatrix)

{

using (var gr = Graphics.FromImage(img))

{

var attrs = new ImageAttributes();

attrs.SetColorMatrix(colMatrix);

gr.DrawImage(img, new Rectangle(0, 0, img.Width, img.Height),

0, 0, img.Width, img.Height, GraphicsUnit.Pixel, attrs);

}

}

#region BlendImages functions ...

/*

destImage - image that will be used as background

destX, destY - define position on destination image where to start applying blend operation

destWidth, destHeight - width and height of the area to apply blending

srcImage - image to use as foreground (source of blending)

srcX, srcY - starting position of the source image

*/

public static void BlendImages(Bitmap destImage, int destX, int destY, int destWidth, int destHeight,

Bitmap srcImage, int srcX, int srcY, BlendOperation blendOp)

{

if (destImage == null)

throw new Exception("Destination image must be provided");

if (destImage.Width < destX + destWidth || destImage.Height < destY + destHeight)

throw new Exception("Destination image is smaller than requested dimensions");

if (srcImage == null)

throw new Exception("Source image must be provided");

if (srcImage.Width < srcX + destWidth || srcImage.Height < srcY + destHeight)

throw new Exception("Source image is smaller than requested dimentions");

Bitmap tempBmp = null;

using (var gr = Graphics.FromImage(destImage))

{

gr.CompositingMode = CompositingMode.SourceCopy;

switch (blendOp)

{

case BlendOperation.SourceCopy:

gr.DrawImage(srcImage, new Rectangle(destX, destY, destWidth, destHeight),

srcX, srcY, destWidth, destHeight, GraphicsUnit.Pixel);

break;

case BlendOperation.RopMergePaint:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, MergePaint);

break;

case BlendOperation.RopNotSourceErase:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, NotSourceErase);

break;

case BlendOperation.RopSourceAnd:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, SourceAnd);

break;

case BlendOperation.RopSourceErase:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, SourceErase);

break;

case BlendOperation.RopSourceInvert:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, SourceInvert);

break;

case BlendOperation.RopSourcePaint:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, SourcePaint);

break;

case BlendOperation.BlendDarken:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendDarken);

break;

case BlendOperation.BlendMultiply:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendMultiply);

break;

case BlendOperation.BlendScreen:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendScreen);

break;

case BlendOperation.BlendLighten:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendLighten);

break;

case BlendOperation.BlendHardLight:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendHardLight);

break;

case BlendOperation.BlendDifference:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendDifference);

break;

case BlendOperation.BlendPinLight:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendPinLight);

break;

case BlendOperation.BlendOverlay:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendOverlay);

break;

case BlendOperation.BlendExclusion:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendExclusion);

break;

case BlendOperation.BlendSoftLight:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendSoftLight);

break;

case BlendOperation.BlendColorBurn:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendColorBurn);

break;

case BlendOperation.BlendColorDodge:

tempBmp = PerChannelProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendColorDodge);

break;

case BlendOperation.BlendHue:

tempBmp = RgbProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendHue);

break;

case BlendOperation.BlendSaturation:

tempBmp = RgbProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendSaturation);

break;

case BlendOperation.BlendColor:

tempBmp = RgbProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendColor);

break;

case BlendOperation.BlendLuminosity:

tempBmp = RgbProcess(destImage, destX, destY, destWidth, destHeight,

srcImage, srcX, srcY, BlendLuminosity);

break;

}

if (tempBmp != null && tempBmp != destImage)

{

gr.DrawImage(tempBmp, 0, 0, tempBmp.Width, tempBmp.Height);

tempBmp.Dispose();

}

}

}

public static void BlendImages(Bitmap destImage, Bitmap srcImage, BlendOperation blendOp)

{

BlendImages(destImage, 0, 0, destImage.Width, destImage.Height, srcImage, 0, 0, blendOp);

}

public static void BlendImages(Bitmap destImage, BlendOperation blendOp)

{

BlendImages(destImage, 0, 0, destImage.Width, destImage.Height, null, 0, 0, blendOp);

}

public static void BlendImages(Bitmap destImage, int destX, int destY, BlendOperation blendOp)

{

BlendImages(destImage, destX, destY, destImage.Width - destX, destImage.Height - destY, null, 0, 0, blendOp);

}

public static void BlendImages(Bitmap destImage, int destX, int destY, int destWidth, int destHeight, BlendOperation blendOp)

{

BlendImages(destImage, destX, destY, destWidth, destHeight, null, 0, 0, blendOp);

}

#endregion BlendImages functions ...

#region Private Blending Functions ...

private static Bitmap PerChannelProcess(Bitmap destImg, int destX, int destY, int destWidth, int destHeight,

Bitmap srcImg, int srcX, int srcY,

PerChannelProcessDelegate channelProcessFunction)

{

var dst = destImg; // new Bitmap(destImg);

var dstData = dst.LockBits(new Rectangle(destX, destY, destWidth, destHeight), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

var dstStride = Math.Abs(dstData.Stride);

var dstScan0 = dstData.Scan0;

var dstBuffer = new byte[dstStride];

var src = srcImg; //new Bitmap(srcImg);

var srcData = src.LockBits(new Rectangle(srcX, srcY, destWidth, destHeight), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

var srcStride = Math.Abs(srcData.Stride);

var srcScan0 = srcData.Scan0;

var srcBuffer = new byte[srcStride];

for (var y = 0; y < destHeight; y++)

{

System.Runtime.InteropServices.Marshal.Copy(srcScan0 + y * srcStride, srcBuffer, 0, srcStride);

System.Runtime.InteropServices.Marshal.Copy(dstScan0 + y * dstStride, dstBuffer, 0, dstStride);

for (var x = 0; x < 3* destWidth; x++)

{

dstBuffer[x] = channelProcessFunction(ref srcBuffer[x], ref dstBuffer[x]);

}

System.Runtime.InteropServices.Marshal.Copy(dstBuffer, 0, dstScan0 + y * dstStride, dstStride);

}

//unsafe

//{

// byte* pDst = (byte*)(void*)dstScan0;

// byte* pSrc = (byte*)(void*)srcScan0;

// for (int y = 0; y < destHeight; y++)

// {

// for (int x = 0; x < destWidth * 3; x++)

// {

// pDst[x + y * dstStride] = channelProcessFunction(ref pSrc[x + y * srcStride], ref pDst[x + y * dstStride]);

// }

// }

//}

src.UnlockBits(srcData);

dst.UnlockBits(dstData);

return dst;

}

private static Bitmap RgbProcess(Bitmap destImg, int destX, int destY, int destWidth, int destHeight,

Bitmap srcImg, int srcX, int srcY,

RgbProcessDelegate rgbProcessFunction)

{

var dst = destImg; //new Bitmap(destImg);

var dstData = dst.LockBits(new Rectangle(destX, destY, destWidth, destHeight), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

var dstStride = Math.Abs(dstData.Stride);

var dstScan0 = dstData.Scan0;

var dstBuffer = new byte[dstStride];

var src = srcImg; //new Bitmap(srcImg);

var srcData = src.LockBits(new Rectangle(srcX, srcY, destWidth, destHeight), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

var srcStride = Math.Abs(srcData.Stride);

var srcScan0 = srcData.Scan0;

var srcBuffer = new byte[srcStride];

for (var y = 0; y < destHeight; y++)

{

System.Runtime.InteropServices.Marshal.Copy(srcScan0 + y * srcStride, srcBuffer, 0, srcStride);

System.Runtime.InteropServices.Marshal.Copy(dstScan0 + y * dstStride, dstBuffer, 0, dstStride);

for (var x = 0; x < destWidth; x += 3)

{

rgbProcessFunction(srcBuffer[x + 2], srcBuffer[x + 1], srcBuffer[x],

ref dstBuffer[x + 2], ref dstBuffer[x + 1], ref dstBuffer[x]);

}

System.Runtime.InteropServices.Marshal.Copy(dstBuffer, 0, dstScan0 + y * dstStride, dstStride);

}

//unsafe

//{

// byte* pDst = (byte*)(void*)dstScan0;

// byte* pSrc = (byte*)(void*)srcScan0;

// for (int y = 0; y < destHeight; y++)

// {

// for (int x = 0; x < destWidth; x++)

// {

// rgbProcessFunction(

// pSrc[x * 3 + 2 + y * srcStride], pSrc[x * 3 + 1 + y * srcStride], pSrc[x * 3 + y * srcStride],

// ref pDst[x * 3 + 2 + y * dstStride], ref pDst[x * 3 + 1 + y * dstStride], ref pDst[x * 3 + y * dstStride]

// );

// }

// }

//}

src.UnlockBits(srcData);

dst.UnlockBits(dstData);

return dst;

}

#endregion Private Blending Functions ...

#region HLS Conversion Functions ...

private static void RgbToHls(byte red, byte green, byte blue, out ushort hue, out ushort lightness, out ushort saturation)

{

/* calculate lightness */

var cMax = Math.Max(Math.Max(red, green), blue);

var cMin = Math.Min(Math.Min(red, green), blue);

lightness = (ushort)((((cMax + cMin) * HlsMax) + RgbMax) / (2 * RgbMax));

if (cMax == cMin)

{ /* r=g=b --> achromatic case */

saturation = 0; /* saturation */

hue = HueUndefined; /* hue */

}

else

{ /* chromatic case */

/* saturation */

if (lightness <= (HlsMax / 2))

saturation = (ushort)((((cMax - cMin) * HlsMax) + ((cMax + cMin) / 2)) / (cMax + cMin));

else

saturation = (ushort)((((cMax - cMin) * HlsMax) + ((2 * RgbMax - cMax - cMin) / 2)) / (2 * RgbMax - cMax - cMin));

/* hue */

var redDelta = (((cMax - red) * (HlsMax / 6f)) + ((cMax - cMin) / 2f)) / (cMax - cMin);

var greendelta = (((cMax - green) * (HlsMax / 6f)) + ((cMax - cMin) / 2f)) / (cMax - cMin);

var blueDelta = (((cMax - blue) * (HlsMax / 6f)) + ((cMax - cMin) / 2f)) / (cMax - cMin);

if (red == cMax)

hue = (ushort)(blueDelta - greendelta);

else if (green == cMax)

hue = (ushort)((HlsMax / 3) + redDelta - blueDelta);

else /* B == cMax */

hue = (ushort)(((2 * HlsMax) / 3) + greendelta - redDelta);

//if (hue < 0)

// hue += HlsMax;

if (hue > HlsMax)

hue -= HlsMax;

}

}

private static void HlsToRgb(ushort hue, ushort lightness, ushort saturation, out byte red, out byte green, out byte blue)

{

if (saturation == 0)

{/* achromatic case */

red = green = blue = (byte)((lightness * RgbMax) / HlsMax);

}

else

{/* chromatic case */

/* set up magic numbers */

float magic2; /* calculated magic numbers (really!) */

if (lightness <= (HlsMax / 2))

magic2 = (lightness * (HlsMax + saturation) + (HlsMax / 2f)) / HlsMax;

else

magic2 = lightness + saturation - ((lightness * saturation) + (HlsMax / 2f)) / HlsMax;

var magic1 = 2 * lightness - magic2; /* calculated magic number 1 (really!) */

/* get RGB, change units from HLSMAX to RGBMAX */

red = (byte)((HueToRgb(magic1, magic2, hue + (HlsMax / 3)) * RgbMax + (HlsMax / 2)) / HlsMax);

green = (byte)((HueToRgb(magic1, magic2, hue) * RgbMax + (HlsMax / 2)) / HlsMax);

blue = (byte)((HueToRgb(magic1, magic2, hue - (HlsMax / 3)) * RgbMax + (HlsMax / 2)) / HlsMax);

}

}

/* utility routine for HLStoRGB */

private static float HueToRgb(float n1, float n2, float hue)

{

/* range check: note values passed add/subtract thirds of range */

if (hue < 0)

hue += HlsMax;

if (hue > HlsMax)

hue -= HlsMax;

/* return r,g, or b value from this tridrant */

if (hue < (HlsMax / 6))

return n1 + (((n2 - n1) * hue + (HlsMax / 12)) / (HlsMax / 6));

if (hue < (HlsMax / 2))

return n2;

if (hue < ((HlsMax * 2) / 3))

return n1 + (((n2 - n1) * (((HlsMax * 2) / 3) - hue) + (HlsMax / 12)) / (HlsMax / 6));

return n1;

}

#endregion HLS Conversion Functions ...

#region Raster Operation Functions ...

// (NOT Source) OR Destination

private static byte MergePaint(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min((255 - src) | dst, 255), 0);

}

// NOT (Source OR Destination)

private static byte NotSourceErase(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(255 - (src | dst), 255), 0);

}

// Source AND Destination

private static byte SourceAnd(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(src & dst, 255), 0);

}

// Source AND (NOT Destination)

private static byte SourceErase(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(src & (255 - dst), 255), 0);

}

// Source XOR Destination

private static byte SourceInvert(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(src ^ dst, 255), 0);

}

// Source OR Destination

private static byte SourcePaint(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(src | dst, 255), 0);

}

#endregion Raster Operation Functions ...

#region Blend Pixels Functions ...

// Choose darkest color

private static byte BlendDarken(ref byte src, ref byte dst)

{

return ((src < dst) ? src : dst);

}

// Multiply

private static byte BlendMultiply(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min((src / 255.0f * dst / 255.0f) * 255.0f, 255), 0);

}

// Screen

private static byte BlendScreen(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min(255 - ((255 - src) / 255.0f * (255 - dst) / 255.0f) * 255.0f, 255), 0);

}

// Choose lightest color

private static byte BlendLighten(ref byte src, ref byte dst)

{

return ((src > dst) ? src : dst);

}

// hard light

private static byte BlendHardLight(ref byte src, ref byte dst)

{

return ((src < 128)

? (byte)Math.Max(Math.Min((src / 255.0f * dst / 255.0f) * 255.0f * 2, 255), 0)

: (byte)Math.Max(Math.Min(255 - ((255 - src) / 255.0f * (255 - dst) / 255.0f) * 255.0f * 2, 255), 0));

}

// difference

private static byte BlendDifference(ref byte src, ref byte dst)

{

return (byte)((src > dst) ? src - dst : dst - src);

}

// pin light

private static byte BlendPinLight(ref byte src, ref byte dst)

{

return (src < 128) ? ((dst > src) ? src : dst) : ((dst < src) ? src : dst);

}

// overlay

private static byte BlendOverlay(ref byte src, ref byte dst)

{

return ((dst < 128)

? (byte)Math.Max(Math.Min((src / 255.0f * dst / 255.0f) * 255.0f * 2, 255), 0)

: (byte)Math.Max(Math.Min(255 - ((255 - src) / 255.0f * (255 - dst) / 255.0f) * 255.0f * 2, 255), 0));

}

// exclusion

private static byte BlendExclusion(ref byte src, ref byte dst)

{

return (byte)(src + dst - 2 * (dst * src) / 255f);

}

// Soft Light (XFader formula)

private static byte BlendSoftLight(ref byte src, ref byte dst)

{

return (byte)Math.Max(Math.Min((dst * src / 255f) + dst * (255 - ((255 - dst) * (255 - src) / 255f) - (dst * src / 255f)) / 255f, 255), 0);

}

// Color Burn

private static byte BlendColorBurn(ref byte src, ref byte dst)

{

return (src == 0) ? (byte)0 : (byte)Math.Max(Math.Min(255 - (((255 - dst) * 255) / src), 255), 0);

}

// Color Dodge

private static byte BlendColorDodge(ref byte src, ref byte dst)

{

return (src == 255) ? (byte)255 : (byte)Math.Max(Math.Min((dst * 255) / (255 - src), 255), 0);

}

// use source Hue

private static void BlendHue(byte sR, byte sG, byte sB, ref byte dR, ref byte dG, ref byte dB)

{

ushort sH, sL, sS, dH, dL, dS;

RgbToHls(sR, sG, sB, out sH, out sL, out sS);

RgbToHls(dR, dG, dB, out dH, out dL, out dS);

HlsToRgb(sH, dL, dS, out dR, out dG, out dB);

}

// use source Saturation

private static void BlendSaturation(byte sR, byte sG, byte sB, ref byte dR, ref byte dG, ref byte dB)

{

ushort sH, sL, sS, dH, dL, dS;

RgbToHls(sR, sG, sB, out sH, out sL, out sS);

RgbToHls(dR, dG, dB, out dH, out dL, out dS);

HlsToRgb(dH, dL, sS, out dR, out dG, out dB);

}

// use source Color

private static void BlendColor(byte sR, byte sG, byte sB, ref byte dR, ref byte dG, ref byte dB)

{

ushort sH, sL, sS, dH, dL, dS;

RgbToHls(sR, sG, sB, out sH, out sL, out sS);

RgbToHls(dR, dG, dB, out dH, out dL, out dS);

HlsToRgb(sH, dL, sS, out dR, out dG, out dB);

}

// use source Luminosity

private static void BlendLuminosity(byte sR, byte sG, byte sB, ref byte dR, ref byte dG, ref byte dB)

{

ushort sH, sL, sS, dH, dL, dS;

RgbToHls(sR, sG, sB, out sH, out sL, out sS);

RgbToHls(dR, dG, dB, out dH, out dL, out dS);

HlsToRgb(dH, sL, dS, out dR, out dG, out dB);

}

#endregion Blend Pixels Functions ...

}

}