Image.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using visLU.Effects;
using visLU.CVD;
using System.IO;
using Microsoft.Xna.Framework.Graphics.PackedVector;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;

namespace visLU.CVD
{
    class Image
    {
        #region variables

        private GraphicsDevice device;
        SpriteBatch spriteBatch;

        private Matrix rotationFromLMS;
        private Matrix rotationToLMS;
        private float angle;
        private string colorVisionDeficency;
        private int width;
        private int height;

        private RenderTarget2D target_lms;

        private RenderTarget2D target_rgbToLab;
        private RenderTarget2D target_contrastLoss;
        private RenderTarget2D target_predominantComponent;
        private RenderTarget2D target_eigenVector;
        private RenderTarget2D target_projection;
        private RenderTarget2D target_maxProjectionEffect;
        private RenderTarget2D target_enhanceContrast;
        private RenderTarget2D target_labToRGB;

        private RecolorShader shader_lms;

        private RecolorShader shader_rgbToLab;
        private RecolorShader shader_contrastLoss;
        private RecolorShader shader_predominantComponent;
        private RecolorShader shader_eigenVector;
        private RecolorShader shader_projection;
        private RecolorShader shader_maxProjectionEffect;
        private RecolorShader shader_enhanceContrast;
        private RecolorShader shader_labToRGB;       

        private Texture2D toSimulate;
        private Texture2D referenceImageRGB; //rendered image

        private Texture2D noiseTexture; //contains neighbourhood information for contrast loss shader

        private Texture2D tex_lab;
        private Texture2D tex_contrastLost;
        private Texture2D tex_predominantComponent;
        private Texture2D tex_eigenVectors;
        private Texture2D tex_projected;
        private Texture2D tex_maxProjectedEffect;
        private Texture2D tex_enhancedContrast;

        private Texture2D recoloredImage;

        #region debug stuff
        bool saveDebugTextures = false;
        bool debugOutput = false; // console output
        #endregion

        #endregion

        #region properties
        
        public Matrix RotationFromLMS
        {
            set { rotationFromLMS = value; }
            get { return rotationFromLMS; }

        }
        public Matrix RotationToLMS
        {
            set { rotationToLMS = value; }
            get { return rotationToLMS; }

        }
        
        public Texture2D ImageToSimulate
        {
            set { 
                toSimulate = value;
                width = toSimulate.Width;
                height = toSimulate.Height; 
            }
            get { return toSimulate; }
        }

        public Texture2D RecoloredImage
        {
            set { recoloredImage = value; }
            get { return recoloredImage; }
        }

        public string ColorVisionDeficency
        {
            set { colorVisionDeficency = value; SetAngle(); SetMatrix(); }
            get { return colorVisionDeficency; }
        }

        public Texture2D ReferenceImageRGB
        {
            set { 
                referenceImageRGB = value;
                //recoloredImage = referenceImageRGB; // TODO: only for debug!
                width = referenceImageRGB.Width; 
                height = referenceImageRGB.Height; 
                //ExtractColors();
            }
            get { return referenceImageRGB; }
        }

        public Texture2D LabImage
        {
            set { tex_lab = value; }
            get { return tex_lab; }
        }

        public Texture2D NoiseTexture
        {
            set { noiseTexture = value; Console.WriteLine("noise texture initialized"); }
            get { return noiseTexture; }
        }

        public RecolorShader LMSShader
        {
            set { shader_lms = value; }
            get { return shader_lms; }
        }

        public RecolorShader RGBtoLab_Shader
        {
            set { shader_rgbToLab = value; }
            get { return shader_rgbToLab; }
        }

        public RecolorShader ContrastLoss_Shader
        {
            set { shader_contrastLoss = value; }
            get { return shader_contrastLoss; }
        }

        public RecolorShader PredominantComponent_Shader
        {
            set { shader_predominantComponent = value; }
            get { return shader_predominantComponent; }
        }

        public RecolorShader EigenVector_Shader
        {
            set { shader_eigenVector = value; }
            get { return shader_eigenVector; }
        }

        public RecolorShader Projection_Shader
        {
            set { shader_projection = value; }
            get { return shader_projection; }
        }

        public RecolorShader MaxProjectionEffect_Shader
        {
            set { shader_maxProjectionEffect = value; }
            get { return shader_predominantComponent; }
        }

        public RecolorShader EnhanceContrast_Shader
        {
            set { shader_enhanceContrast = value; }
            get { return shader_enhanceContrast; }
        }

        public RecolorShader LabToRGB_Shader
        {
            set { shader_labToRGB = value; }
            get { return shader_labToRGB; }
        }
        
        #endregion

        #region constructor

        public Image(GraphicsDevice _device, string _colorVisionDeficency)
        {
            if (!saveDebugTextures)
            {
                saveDebugTextures = GameProperties.Instance.shaderDebugMode;
            }

            device = _device;

            this.colorVisionDeficency = _colorVisionDeficency;
            SetAngle();
            SetMatrix();

            #region create render targets
            PresentationParameters pp = device.PresentationParameters;
            //SurfaceFormat format = pp.BackBufferFormat;
            SurfaceFormat format = SurfaceFormat.Rgba64;
            int bbwidth = pp.BackBufferWidth;
            int bbheight = pp.BackBufferHeight;
            DepthFormat depthStecilFormat = pp.DepthStencilFormat;
            int multiSample = pp.MultiSampleCount;

            target_lms = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                    depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);


            target_rgbToLab = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                    depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_contrastLoss = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_predominantComponent = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_maxProjectionEffect = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_eigenVector = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_projection = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_enhanceContrast = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);

            target_labToRGB = new RenderTarget2D(device, bbwidth, bbheight, false, format,
                depthStecilFormat, multiSample, RenderTargetUsage.DiscardContents);
            #endregion

            #region create textures
            //referenceImageRGB = new Texture2D(device, width, height, true, SurfaceFormat.HdrBlendable);  //rendered image
            //labImage = new Texture2D(device, width, height, true, SurfaceFormat.HdrBlendable); 
            //noiseTexture = new Texture2D(device, width, height, true, SurfaceFormat.Rgba64);
            //pcaImage;
            //pingPongTex;
            //eigenImage;
            //projectedImage;
            //projSumImage;
            //resultColorImage = new Texture2D(device, width, height, true, SurfaceFormat.HdrBlendable); 
            //recoloredImage = new Texture2D(device, width, height, true, SurfaceFormat.HdrBlendable); 
            
            
            #endregion

            if (debugOutput)
            {
                Console.WriteLine("Image class instanciated");
            }
        }

        #endregion

        #region methods

        #region initialization stuff

        #region set angle
        private void SetAngle()
        {
            switch (colorVisionDeficency)
                    {
                        case "protanopy":
                            angle = -11.47f; //-11.4783f;
                            break;

                        case "deuteranopy":
                            angle = -8.1f; //-8.10959f;
                            break;

                        case "tritanopy":
                            angle = 46.37f;
                            break;

                        default: //Deuteranopy
                            angle = -8.1f;
                            break;
                    }

            if (debugOutput)
            {
                Console.WriteLine("angle set to " + angle);
            }
        }
        #endregion

        #region set matrix
        private void SetMatrix()
        {
            rotationFromLMS = Matrix.CreateRotationX(MathHelper.ToRadians(angle));
            rotationToLMS = Matrix.CreateRotationX(MathHelper.ToRadians(-1.0f * angle));

            if (debugOutput)
            {
                Console.WriteLine("rotation matrix set to: " +rotationFromLMS);
            }
        }
        #endregion
        
        #region noise texture
        private void SetNoiseTexture() //gaussian pairing. 
        {
            if (debugOutput)
            {
                Console.WriteLine("setting noise texture");
            }

            Color[] noise = new Color[width * height];

            double variance = Math.Sqrt(2.0f*Math.Min(width,height));
            float scale = (float)(variance*(2.0f/Math.PI));

            //debug:
            Color old = new Color(0.0f, 0.0f, 0.0f, 1.0f); //debug
            int count = 0; //debug

            for (int x=0; x<width; x++) {
                for (int y = 0; y < height; y++)
                {
                    #region create random gauss
                    // for rx
                    Random randx = new Random(); //reuse this if you are generating many
                    double u1x = randx.NextDouble(); //these are uniform(0,1) random doubles
                    double u2x = randx.NextDouble();
                    double randStdNormalx = Math.Sqrt(-2.0 * Math.Log(u1x)) * Math.Sin(2.0 * Math.PI * u2x); //random normal(0,1)

                    //for ry
                    Random randy = new Random(); //reuse this if you are generating many
                    double u1y = randy.NextDouble(); //these are uniform(0,1) random doubles
                    double u2y = randy.NextDouble();
                    double randStdNormaly = Math.Sqrt(-2.0 * Math.Log(u1y)) * Math.Sin(2.0 * Math.PI * u2y); //random normal(0,1)
                    #endregion

                    int index = y*width+x;
                    int rx = (int)Math.Floor(Math.Max(Math.Min(x + scale*randStdNormalx,width-1.0f),0.0f));
                    /*double c = y + scale * randStdNormal;
                    double b = Math.Min(c, height - 1.0f);
                    double a = Math.Max(b, 0.0f);
                    int ry = (int)Math.Floor(a);*/
                    int ry = (int)Math.Floor(Math.Max(Math.Min(y + scale * randStdNormaly, height - 1.0f), 0.0f));

                    try
                    {
                        Vector4 currentColor = new Vector4((rx + 0.5f)/width, (ry + 0.5f)/height, 0.0f, 1.0f);

                        noise[index] = new Color(currentColor);

                        if (saveDebugTextures)
                        {
                            Color newC = noise[index];
                            if (newC.R > old.R) { old.R = newC.R; }
                            if (newC.G > old.G) { old.G = newC.G; }
                            if (newC.B > old.B) { old.B = newC.B; }

                            if (newC.R >= 255 && newC.G >= 255 && newC.B >= 255)
                            {
                                count++;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine("index="+index+"  EXCEPTION!!!!!!!!!!!!!!!!!!!!!! " + e);
                        throw;
                    }
                }
            }
            try
            {
                if (debugOutput)
                {
                    Console.WriteLine("max =" + old);
                    Console.WriteLine("count =" + count);
                    Console.WriteLine("set values to texture");
                }
                noiseTexture.SetData<Color>(noise); 
            }
            catch (Exception e)
            {
                
                Console.WriteLine("  EXCEPTION!!!!!!!!!!!!!!!!!!!!!! " + e);
                throw;
            }
            if (debugOutput)
            {
                Console.WriteLine("noise texture set");
            }
        }
        #endregion

        #endregion

        #region Simulate Perception
        public void SimulatePerception(GraphicsDevice _device)
        {
            if (debugOutput)
            {
                Console.WriteLine("start simulatin perception");
            }
            device = _device;
            device.DepthStencilState = DepthStencilState.None;

            colorVisionDeficency = GameProperties.Instance.CVD;
            SetAngle();
            SetMatrix();

            spriteBatch = new SpriteBatch(device);
            
            ConvertRGBtoLab(toSimulate);

            ProjectToReducedLMS();

            ConvertLabToRGB();
        }
        #endregion

        #region Recolor
        public void Recolor(GraphicsDevice _device)
        {
            if (debugOutput)
            {
                Console.WriteLine("start recoloring");
            }
            device = _device;
            device.DepthStencilState = DepthStencilState.None;

            colorVisionDeficency = GameProperties.Instance.CVD;
            SetAngle();
            SetMatrix();

            spriteBatch = new SpriteBatch(device);

            ConvertRGBtoLab(referenceImageRGB);

            ContrastLoss();

            PredominantComponent();

            ComputeEigenVectors();

            ProjectOntoLMSplane();

            MaxProjectionEffect();

            EnhanceContrast();

            ConvertLabToRGB();
           
            // ---------------------------------------------------------------------------------------

            device.DepthStencilState = DepthStencilState.Default;
        }
        #endregion

        #region methods for each recoloring/simulation step

        #region Simulate Perception
        private void ProjectToReducedLMS()
        {
            tex_lab = target_rgbToLab;
    
            InitLMSShader();

            device.SetRenderTarget(target_lms);
            DrawSprite(tex_lab, shader_lms);
            device.SetRenderTarget(null);

            tex_enhancedContrast = target_lms; // pass directly to Lab->RGB shader        

            if (saveDebugTextures)
            {
                saveScreenshot(tex_enhancedContrast, "0_simulated", "png"); // for debug
            }
            
            if (debugOutput)
            {
                Console.WriteLine("ProjectToReducedLMS done");
            }
        }
        #endregion

        #region  RGB -> Lab
        private void ConvertRGBtoLab(Texture2D _imageToConvert)
        {
            InitRGBToLab_Shader(_imageToConvert);

            device.SetRenderTarget(target_rgbToLab);
            DrawSprite3(_imageToConvert, shader_rgbToLab);
            device.SetRenderTarget(null);

            tex_lab = target_rgbToLab;

            if (saveDebugTextures)
            {
                saveScreenshot(_imageToConvert, "1_reference", "png");
                saveScreenshot(tex_lab, "2_rgbToLab", "png"); //for debug
            }
            
            if (debugOutput)
            {
                Console.WriteLine("ConvertRGBtoLab done");
            }

        }
        #endregion

        #region contrast loss 
        private void ContrastLoss()
        {
            noiseTexture = new Texture2D(device, width, height, true, SurfaceFormat.Color);
            SetNoiseTexture();
            
            InitContrastLoss_Shader();

            device.SetRenderTarget(target_contrastLoss);
            DrawSprite3(tex_lab, shader_contrastLoss);
            device.SetRenderTarget(null);

            tex_contrastLost = target_contrastLoss;

            /*Rgba64[] testColros = new Rgba64[pca1Target.Height * pca1Target.Width];
            pca1Target.GetData<Rgba64>(testColros);

            Texture2D noiseTexture2 = new Texture2D(device, width, height, true, SurfaceFormat.Rgba64);

            noiseTexture2.SetData<Rgba64>(testColros);
            saveScreenshot(noiseTexture2, "noiseTexture2", "png");*/

            if (saveDebugTextures)
            {
                saveScreenshot(tex_contrastLost, "3_ContrastLoss", "png"); // for debug
                saveScreenshot(noiseTexture, "noiseTexture", "png"); // for debug
            }

            if (debugOutput)
            {
                Console.WriteLine("ContrastLoss done");
            }
        }
        #endregion
        
        #region PCA: predominant component
        private void PredominantComponent()
        {
            initPredominantComponenet_Shader();

            device.SetRenderTarget(target_predominantComponent);
            DrawSprite3(tex_contrastLost, shader_predominantComponent);
            device.SetRenderTarget(null);

            tex_predominantComponent = target_predominantComponent;

            if (saveDebugTextures)
            {
                saveScreenshot(tex_predominantComponent, "4_PredominantComponent", "png"); // for debug
            }

            if (debugOutput)
            {
                Console.WriteLine("PCAPredominantComponent done");
            }
        }
        #endregion

        #region eigen vectors
        private void ComputeEigenVectors()
        {
            InitEigenVector_Shader();

            device.SetRenderTarget(target_eigenVector);
            DrawSprite(tex_predominantComponent, shader_eigenVector); //TODO: check shader
            device.SetRenderTarget(null);

            tex_eigenVectors = target_eigenVector;

            if (saveDebugTextures)
            {
                saveScreenshot(tex_eigenVectors, "5_EigenVectors", "png"); // for debug
            }

            if (debugOutput)
            {
                Console.WriteLine("ComputeEigenVectors done");
            }
        }
        #endregion

        #region project onto LMS plane
        private void ProjectOntoLMSplane()
        {
            InitProjection_Shader();

            device.SetRenderTarget(target_projection);
            DrawSprite(tex_eigenVectors, Projection_Shader);
            device.SetRenderTarget(null);

            tex_projected = target_projection;

            if (saveDebugTextures)
            {
                saveScreenshot(tex_projected, "6_Projections", "png"); // for debug
            }
            if (debugOutput)
            {
                Console.WriteLine("ProjectOntoLMSplane done");
            }
        }
        #endregion

        #region max projection effect
        private void MaxProjectionEffect()
        {            
            initMaxProjectionEffect_Shader();

            device.SetRenderTarget(target_maxProjectionEffect);
            DrawSprite3(tex_projected, shader_maxProjectionEffect);
            device.SetRenderTarget(null);

            tex_maxProjectedEffect = target_maxProjectionEffect;

            if (saveDebugTextures)
            {
                saveScreenshot(tex_maxProjectedEffect, "7_MaxProjectionEffect", "png"); // for debug
            }

            if (debugOutput)
            {
                Console.WriteLine("MaxProjectionEffect done");
            }
        }
        #endregion

        #region enhance contrast
        private void EnhanceContrast()
        {
            InitEnhanceContrast_Shader();

            device.SetRenderTarget(target_enhanceContrast);
            DrawSprite3(tex_maxProjectedEffect, shader_enhanceContrast);
            device.SetRenderTarget(null);

            tex_enhancedContrast = target_enhanceContrast;

            if (saveDebugTextures)
            {
                saveScreenshot(tex_enhancedContrast, "8_EnhanceContrast", "png"); // for debug
            }

            if (debugOutput)
            {
                Console.WriteLine("EnhanceContrast done");
            }
        }
        #endregion

        #region Lab -> RGB
        private void ConvertLabToRGB()
        {            
            InitLabtoRGB_Shader();

            device.SetRenderTarget(target_labToRGB);
            DrawSprite3(tex_enhancedContrast, shader_labToRGB);
            device.SetRenderTarget(null);

            recoloredImage = target_labToRGB;

            if (saveDebugTextures)
            {
                if (GameProperties.Instance.simulate)
                {
                    saveScreenshot(recoloredImage, "9_SimulatedImage", "png");
                }
                else
                {
                    saveScreenshot(recoloredImage, "9_RecoloredImage", "png");
                }
            }

            if (debugOutput)
            {
                Console.WriteLine("ConvertLabToRGB done");
            }
        }
        #endregion

        #endregion

        #region set effect parameters for shader

        private void InitLabtoRGB_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing L*a*b* to RGB shader");
            }

            shader_labToRGB.EnhancedContrast_tex = tex_enhancedContrast;
            shader_labToRGB.RotationMatrix = rotationFromLMS;

            shader_labToRGB.SetEffectParameter_labToRGB();
        }

        private void InitEnhanceContrast_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing Result Color shader");
            }

            shader_enhanceContrast.SetEffectParameter_EnhanceContrast(tex_maxProjectedEffect, tex_projected, tex_lab);
        }

        private void initMaxProjectionEffect_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing PCA4 Reduction shader");
            }

            shader_maxProjectionEffect.SetEffectParameter_MaxProjectionEffect(tex_projected);
        }

        private void InitProjection_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing Projection shader");
            }

            shader_projection.SetEffectParameter_Projection(tex_lab, tex_eigenVectors);
        }

        private void InitEigenVector_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing EigenVector shader");
            }

            shader_eigenVector.SetEffectParameter_EigenVectors(tex_predominantComponent);
        }

        private void initPredominantComponenet_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing Predominant Component shader");
            }

            shader_predominantComponent.SetEffectParameter_PredominantComponenet(tex_contrastLost);
        }

        private void InitContrastLoss_Shader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing Contrast Loss shader");
            }

            //pca1Shader.SetEffectParameter_PCA1(referenceImageRGB, noiseTexture);
            shader_contrastLoss.SetEffectParameter_ContrastLoss(tex_lab, noiseTexture);
        }

        private void InitRGBToLab_Shader(Texture2D _imageToConvert)
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing RGB to lab shader");
            }

            shader_rgbToLab.RGBTexture = _imageToConvert;
            shader_rgbToLab.RotationMatrix = rotationToLMS;
            
            shader_rgbToLab.SetEffectParameter_RGBtoLab();            
        }

        private void InitLMSShader()
        {
            if (debugOutput)
            {
                Console.WriteLine("initializing LMS shader");
            }
            shader_lms.SetEffectParameter_LMS(tex_lab);
        }

        #endregion

        #region draw sprite

        public void DrawSprite(Texture2D tex, RecolorShader shader)
        {
            //Console.WriteLine("drawing sprite: " + tex.Name);

            device.Clear(Color.Black);
            device.BlendState = BlendState.NonPremultiplied;

            spriteBatch.Begin(0, BlendState.NonPremultiplied, null, null, null, shader);

            spriteBatch.Draw(tex, new Rectangle(0, 0, width, height), Color.Black);
            
            spriteBatch.End();
        }

        private void DrawSprite3(Texture2D tex, RecolorShader shader)
        {
            Console.WriteLine("drawing sprite: " + tex.Name);

            device.Clear(Color.Black);
            device.BlendState = BlendState.AlphaBlend;

            try
            {
                spriteBatch.Begin(0, BlendState.AlphaBlend, null, null, null, shader);
            }
            catch (Exception e)
            {
                Console.WriteLine("EXCEPTION!!!!!!!!!!!!!!!!" + e);
                throw;
            }

            spriteBatch.Draw(tex, new Rectangle(0, 0, width, height), Color.White);

            spriteBatch.End();
        }

        #endregion

        #endregion

        #region save screenshot
        private void saveScreenshot(Texture2D texture, String name, String ext)
        {
        Console.WriteLine("saving " + name);
            try
            {
                if (!name.ElementAt(name.Length - 4).Equals(".")) name = name + "." + ext;
                FileStream stream = File.OpenWrite(name);
                switch (ext)
                {
                    case "png":
                        texture.SaveAsPng(stream, texture.Width, texture.Height);
                        break;
                    case "jpg":
                        texture.SaveAsJpeg(stream, texture.Width, texture.Height);
                        break;
                    default:
                        if (name.ElementAt(name.Length - 4).Equals(".")) name = name.Substring(0, name.Length - 4);
                        name = name + ".png";
                        texture.SaveAsPng(stream, texture.Width, texture.Height);
                        break;
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("Save Screenshot: ");
                Console.WriteLine(e);
            }
        }
        #endregion
    }
}