RecolorShader.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

namespace visLU.Effects
{
    class RecolorShader: Effect
    {
        GraphicsDevice device;
        Effect effect;

        #region EffectParameters

        // convert from RGB to L*a*b*
        private EffectParameter ep_rotationMatrix;
        private EffectParameter ep_rgbTexture;
        private EffectParameter ep_RGBtoXYZmatrix;
        //private EffectParameter ep_whiteRef;

        // PCA1
        private EffectParameter ep_labTexture; // also for LMS
        private EffectParameter ep_noiseTexture;

        // PCA2 and PCA4 reduction
        private EffectParameter ep_reductionTexture;
        private EffectParameter ep_viewport; //for PCA4

        // EigenVectors
        private EffectParameter ep_pcaTexture;

        // Project onto LMS plane
        private EffectParameter ep_eigenTexture;
        //and reuses ep_labTexture

        // ResultColor
        private EffectParameter ep_projSumTexture;
        private EffectParameter ep_projTexture;

        // convert from L*a*b* back to RGB
        // reuses ep_rotationMatrix;
        private EffectParameter ep_resCTexture;
        private EffectParameter ep_XYZtoRGBmatrix;

        #endregion

        #region member variables

        // convert from RGB to L*a*b*
        private Matrix rotation;
        private Texture2D rgbtex;
        private Matrix rgbToXYZ;

        // PCA1
        private Texture2D labTexture; // also for LMS
        private Texture2D noiseTexture;

        // PCA2 and PCA4 reduction
        private Texture2D reductionTexture; //does not have get and set methods

        // EigenVectors
        private Texture2D pcaTexture;

        // Project onto LMS plane
        private Texture2D eigenTexture;
        // and reuses labTexture

        // ResultColor
        private Texture2D projSumTexture;
        private Texture2D projTexture;
        // and reuses labTexture

        // convert from RGB to L*a*b*
        // reuses rotation;
        private Texture2D resultCTex;
        private Matrix xyzToRGB;


        #endregion

        #region properties
        
        public Matrix RotationMatrix
        {
            get { return rotation; }
            set { rotation = value; }
        }

        public Texture2D RGBTexture
        {
            get { return rgbtex; }
            set { rgbtex = value; }
        }

        public Matrix RGBtoXYZ
        {
            get { return rgbToXYZ; }
            set { rgbToXYZ = value; }
        }

        /*public Vector3 WhiteReference
        {
            get { return whiteReference; }
            set { whiteReference = value; }
        }*/

        public Texture2D LabTexture
        {
            get { return labTexture; }
            set { labTexture = value; }
        }

        public Texture2D NoiseTexture
        {
            get { return noiseTexture; }
            set { noiseTexture = value; }
        }

        public Texture2D PCATexture
        {
            get { return pcaTexture; }
            set { pcaTexture = value; }
        }

        public Texture2D EigenTexture
        {
            get { return eigenTexture; }
            set { eigenTexture = value; }
        }

        public Texture2D EnhancedContrast_tex
        {
            get { return resultCTex; }
            set { resultCTex = value; }
        }
        #endregion


        public RecolorShader(GraphicsDevice _device, Effect _effect, string step)
            : base(_effect)
        {
            Console.WriteLine("creating recolorshader");
            device = _device;
            effect = _effect;

            //if(step == "convertToLab")

            switch (step)
            {
                #region LMS

                case "LMS":
                    ep_labTexture = this.Parameters["labTexture"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    break;

                #endregion

                #region convertToLab

                case "convertToLab":
                    //Adobe RGB (1998) D50:
                    rgbToXYZ = new Matrix(0.6097559f,  0.2052401f,  0.1492240f, 0.0f,
                                    0.3111242f,  0.6256560f,  0.0632197f, 0.0f,
                                    0.0194811f,  0.0608902f,  0.7448387f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    #region delete

                    /*xyzToRGB = new Matrix(1.9624274f, - 0.6105343f, - 0.3413404f, 0.0f,
                                    -0.9787684f,  1.9161415f,  0.0334540f, 0.0f,
                                    0.0286869f, -0.1406752f,  1.3487655f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    //almost:
                    rgbToXYZ = new Matrix(0.41242400f, 0.21265600f, 0.01933240f, 0.0f,
                                    0.35757900f, 0.71515800f, 0.11919300f, 0.0f,
                                    0.18046400f, 0.07218560f, 0.95044400f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    xyzToRGB = new Matrix(3.24070846f, -0.96925735f, 0.05563507f, 0.0f,
                                    -1.53725917f, 1.87599516f, -0.20399580f, 0.0f,
                                    -0.49857039f, 0.04155555f, 1.05706957f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    //Lindbloom D50:
                    rgbToXYZ = new Matrix(0.4360747f,  0.3850649f,  0.1430804f, 0.0f,
                                    0.2225045f,  0.7168786f,  0.0606169f, 0.0f,
                                    0.0139322f,  0.0971045f,  0.7141733f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    xyzToRGB = new Matrix(3.1338561f, - 1.6168667f, - 0.4906146f, 0.0f,
                                    -0.9787684f,  1.9161415f,  0.0334540f, 0.0f,
                                    0.0719453f, -0.2289914f,  1.4052427f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    //Lindbloom D65:
                    rgbToXYZ = new Matrix(0.4124564f, 0.3575761f, 0.1804375f, 0.0f,
                                    0.2126729f, 0.7151522f, 0.0721750f, 0.0f,
                                    0.0193339f, 0.1191920f, 0.9503041f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    xyzToRGB = new Matrix(3.2404542f, -1.5371385f, -0.4985314f, 0.0f,
                                    -0.9692660f, 1.8760108f, 0.0415560f, 0.0f,
                                    0.0556434f, -0.2040259f, 1.0572252f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);*/

                    #endregion

                    ep_rotationMatrix = this.Parameters["rotmat"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    ep_rgbTexture = this.Parameters["RGBtexture"];
                    ep_RGBtoXYZmatrix = this.Parameters["mRGBtoXYZ"];
                    break;

                #endregion

                #region ContrastLoss

                case "ContrastLoss":
                    ep_labTexture = this.Parameters["labTexture"];
                    ep_noiseTexture = this.Parameters["noiseTexture"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    break;

                #endregion

                #region PredominantComponent

                case "PredominantComponent":
                    ep_reductionTexture = this.Parameters["redTexture"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    break;

                #endregion

                #region EigenVector

                case "EigenVector":
                    ep_pcaTexture = this.Parameters["pcaTexture"];
                    break;

                #endregion

                #region Project

                case "Project":
                    ep_labTexture = this.Parameters["labTexture"];
                    ep_eigenTexture = this.Parameters["eigenTexture"];
                    break;

                #endregion

                #region MaxProjectionEffect

                case "MaxProjectionEffect":
                    ep_reductionTexture = this.Parameters["redTexture"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    break;

                #endregion

                #region EnhanceContrast

                case "EnhanceContrast":
                    ep_projSumTexture = this.Parameters["projEffectSumTexture"];
                    ep_projTexture = this.Parameters["projEffectTexture"];
                    ep_labTexture = this.Parameters["labTexture"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    break;

                #endregion

                #region convertToRGB

                case "convertToRGB":

                    //Adobe RGB (1998) D50:
                    xyzToRGB = new Matrix(1.9624274f, -0.6105343f, -0.3413404f, 0.0f,
                                    -0.9787684f, 1.9161415f, 0.0334540f, 0.0f,
                                    0.0286869f, -0.1406752f, 1.3487655f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    #region delete

                    //lindbloom D50:
                    /*xyzToRGB = new Matrix(3.1338561f, -1.6168667f, -0.4906146f, 0.0f,
                                    -0.9787684f, 1.9161415f, 0.0334540f, 0.0f,
                                    0.0719453f, -0.2289914f, 1.4052427f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);*/

                    //Lindbloom D65:
                    /*xyzToRGB = new Matrix(3.2404542f, -1.5371385f, -0.4985314f, 0.0f,
                                    -0.9692660f, 1.8760108f, 0.0415560f, 0.0f,
                                    0.0556434f, -0.2040259f, 1.0572252f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);

                    //almost
                    xyzToRGB = new Matrix(3.24070846f, -0.96925735f, 0.05563507f, 0.0f,
                                    -1.53725917f, 1.87599516f, -0.20399580f, 0.0f,
                                    -0.49857039f, 0.04155555f, 1.05706957f, 0.0f,
                                    0.0f, 0.0f, 0.0f, 1.0f);*/

                    #endregion

                    ep_rotationMatrix = this.Parameters["rotmat"];
                    ep_viewport = this.Parameters["viewport"]; // needed for shader model 3.0
                    ep_resCTexture = this.Parameters["ResCtexture"];
                    ep_XYZtoRGBmatrix = this.Parameters["mXYZtoRGB"];
                    break;

                #endregion
            }

                        
            Console.WriteLine("RECOLORSHADER CREATED");
        }

        #region SetEffectParameter

        #region LMS
        public void SetEffectParameter_LMS(Texture2D _labTexture)
        {
            labTexture = _labTexture;
            
            this.ep_labTexture.SetValue(_labTexture);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));

            Console.WriteLine("effect parameters for lms shader set");
        }
        #endregion

        #region convert RGB to L*a*b*
        public void SetEffectParameter_RGBtoLab()    
        {
            this.ep_rotationMatrix.SetValue(rotation);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
            this.ep_rgbTexture.SetValue(rgbtex);
            this.ep_RGBtoXYZmatrix.SetValue(rgbToXYZ);
            //this.ep_whiteRef.SetValue(whiteReference);
            Console.WriteLine("effect parameters for rgb to lab shader set");
        }
        #endregion

        #region PCA1
        public void SetEffectParameter_ContrastLoss(Texture2D _labTexture, Texture2D _noiseTexture)
        {
            labTexture = _labTexture;
            noiseTexture = _noiseTexture;

            this.ep_labTexture.SetValue(_labTexture);
            this.ep_noiseTexture.SetValue(_noiseTexture); 
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
        }

        public void SetEffectParameter_PCA1()
        {
            this.ep_labTexture.SetValue(labTexture);
            this.ep_noiseTexture.SetValue(noiseTexture);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
        }
        #endregion

        #region PCA2
        public void SetEffectParameter_PredominantComponenet(Texture2D _reductionTexture/*, Vector2 _dimension*/)
        {
            reductionTexture = _reductionTexture;
            //dimension = _dimension;

            this.ep_reductionTexture.SetValue(reductionTexture);
            //this.ep_dimension.SetValue(dimension);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
        }
        #endregion

        #region EigenVectors
        public void SetEffectParameter_EigenVectors(Texture2D _pcaTexture)
        {
            pcaTexture = _pcaTexture;
            this.ep_pcaTexture.SetValue(pcaTexture);
        }

        public void SetEffectParameter_EigenVec()
        {
            this.ep_pcaTexture.SetValue(pcaTexture);
        }
        #endregion

        #region Project onto LMS plane
        public void SetEffectParameter_Projection(Texture2D _labTexture, Texture2D _eigenTexture)
        {
            labTexture = _labTexture;
            eigenTexture = _eigenTexture;

            this.ep_labTexture.SetValue(labTexture);
            this.ep_eigenTexture.SetValue(eigenTexture);
        }
        #endregion

        #region PCA4
        public void SetEffectParameter_MaxProjectionEffect(Texture2D _reductionTexture/*, Vector2 _dimension*/)
        {
            reductionTexture = _reductionTexture;
            //dimension = _dimension;

            this.ep_reductionTexture.SetValue(reductionTexture);
            //this.ep_dimension.SetValue(dimension);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
        }
        #endregion

        #region result color
        public void SetEffectParameter_EnhanceContrast(Texture2D _projSumImage, Texture2D _projectedImage, Texture2D _labImage)
        {
            projSumTexture = _projSumImage;
            projTexture = _projectedImage;
            labTexture = _labImage;

            this.ep_projSumTexture.SetValue(projSumTexture);
            this.ep_projTexture.SetValue(projTexture);
            this.ep_labTexture.SetValue(labTexture);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
        }
        #endregion

        #region convert L*a*b* back to RGB
        internal void SetEffectParameter_labToRGB()
        {
            this.ep_rotationMatrix.SetValue(rotation);
            this.ep_viewport.SetValue(new Vector2(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height));
            this.ep_resCTexture.SetValue(resultCTex);
            this.ep_XYZtoRGBmatrix.SetValue(xyzToRGB);

            Console.WriteLine("effect parameters for lab to rgb shader set");
        }
        #endregion

        #endregion




    }
}