EncodeFloatToColor.cs

Go to the documentation of this file.

using UnityEngine;
using System.Collections;



public class EncodeFloatToColor: MonoBehaviour {


    //Simplified float to Color4 ranged from -500 to 500 / Precision lost but way faster

    // Encoding/decoding [0..1) floats into 8 bit/channel RGBA. Note that 1.0 will not be encoded properly.
    public static Vector4 Frac(Vector4 vector_a)
    {
        vector_a.x = (float)((double)vector_a.x - System.Math.Truncate((double)vector_a.x));
        vector_a.y = (float)((double)vector_a.y - System.Math.Truncate((double)vector_a.y));
        vector_a.z = (float)((double)vector_a.z - System.Math.Truncate((double)vector_a.z));
        vector_a.w = (float)((double)vector_a.w - System.Math.Truncate((double)vector_a.w));

        return vector_a;
    }
    public static Vector4 EncodeFloatRGBA( float v )
    {

        if(v<-500f||v>500f){
            Debug.LogError("Cannot encode float < -500 or > 500");
            return Vector4.zero;
        }

        v /= 1000.0f;
        v = v + 1.0f;
        Vector4 kEncodeMul = new Vector4(1.0f, 255.0f, 65535.0f, 16777215.0f);
        float kEncodeBit = 1.0f / 255.0f;
        Vector4 enc = kEncodeMul * v;
        enc = Frac(enc);
        enc -= new Vector4(enc.y, enc.z, enc.w, enc.w) * kEncodeBit;
        return enc;
    }


    
    //IEEE754 encoding 32 bits float to 32 bits Color4
    public static string IntToBinaryString(float number, bool fraction, int padding)
    {
        string s;
        float number_float;
        float quotient_float;
        int number_int;
        int quotient;
        int reminder;
        s = "";
        
        if (fraction)
        {
            int j = 1;
            number_float = number;
            while (j<30)
            {
                quotient_float = number_float * 2.0f;
                if (quotient_float>=1.0f)
                {
                    s += '1';
                    quotient_float -= 1.0f;
                } else
                {
                    s += '0';
                }
                number_float = quotient_float;
                j++;
                if (quotient_float==0.0f)
                {
                    j = 100;
                    s += "0";
                }
            }
        } else
        {
            number_int = (int)number;
            while (0<number_int)
            { 
                quotient = (int)Mathf.Floor(number_int / 2);
                reminder = (number_int-(quotient*2));
                number_int = quotient;
                if (reminder==0)
                {
                    s = '0' + s;
                } else
                {
                    s = '1' + s;
                }
                if (number_int==0)
                {
                    number_int = -100;
                }
            }
            if (padding>0)
            {
                s = "0000000000000000000000000000000000000000000000" + s;
                s = s.Substring(s.Length-padding);
            }
        }
        return s;
    }
    public static string FloatToBinaryString(float f)
    {
        string s;
        char c;
        char[] ca;
        int i;
        string si;
        string sf;
        string ss;
        
        if (f==0.0f)
        {
            return "00000000000000000000000000000000";
        }
        if (f==-0.0f)
        {
            return "10000000000000000000000000000000";
        }
        if (float.IsPositiveInfinity(f))
        {
            return "01111111100000000000000000000000";
        }
        if (float.IsNegativeInfinity(f))
        {
            return "11111111100000000000000000000000";
        }
        if (float.IsNaN(f))
        {
            return "11111111110000000000000000000000";
        }
        
        bool is_significant;
        
        int exponent = 0;
        
        if (Mathf.Sign(f)>=0)
        {
            ss = "0";
        } else
        {
            ss = "1";
        }
        
        si = "";
        sf = "0.";
        s = f.ToString("0.#############################");
        int l = s.Length;
        is_significant = true;
        exponent = 0;
        ca = s.ToCharArray();
        int izero = -1;
        
        for (i=0; i<l; i++)
        {
            c = ca[i];
            
            if (c=='.')
            {
                izero = i;
                si += ".0";
            }
            if ((c=='0') || (c=='1') || (c=='2') || (c=='3') || (c=='4') || (c=='5') || (c=='6') || (c=='7') || (c=='8') || (c=='9'))
            {
                is_significant = (izero<0);
                if (is_significant)
                {
                    si += c;
                } else 
                {
                    sf += c;
                }
            }
        }
        int biased_exponent;
        if (si=="")
        {
            si = "0.0";
        }
        string si2bin = IntToBinaryString(float.Parse(si), false, 0);
        string sf2bin = IntToBinaryString(float.Parse(sf), true, 0);
        
        if (si2bin=="")
        {
            si2bin = "0.0";
        }
        if (si2bin=="0.0")
        {
            exponent = -(sf2bin.IndexOf("1")+1);
        } else
        {
            exponent = si2bin.Length-1;
        }
        
        int last_index = 0;
        string sbe2bin;
        biased_exponent = 127 + exponent;
        sbe2bin = IntToBinaryString(biased_exponent, false, 0);
        sbe2bin = "00000000" + sbe2bin;
        sbe2bin = sbe2bin.Substring(sbe2bin.Length-8, 8);       
        string stotal = ss + sbe2bin;
        if (si2bin=="0.0")
        {
            last_index = sf2bin.LastIndexOf('1');
            stotal += sf2bin.Substring(-exponent);
            stotal += "0000000000000000000000000000000000000000000000";         
            if (last_index>0)
            {
                stotal = stotal.Substring(0, 31) + '1';
            } else
            { 
                stotal = stotal.Substring(0, 32);
            }
        } else 
        {
            stotal += si2bin.Substring(1) + sf2bin;
            if (stotal.Length>32)
            {
                stotal = stotal.Substring(0, 31) + '1';
            } else
            {
                stotal += "0000000000000000000000000000000000000000000000";
                stotal = stotal.Substring(0, 32);
            }
        }
        //Debug.Log("INPUT=" + f.ToString() + " SignBin=" + ss + " sbe2bin=" + sbe2bin + " Exponent=" + exponent + " Biased exponent=" + biased_exponent + " si=" + si + " si2bin=" + si2bin + " sf=" + sf + " sf2bin=" + sf2bin + " stotal=" + stotal);        
        return stotal;
    }
    public static Color BinaryStringToColor(string b)
    {
        Color cl = Color.black;
        char ch;
        int len = b.Length-1;
        float ic = 0.0f;
        int ii = 0;
        int ib = 1;
        
        if (len!=31)
        {
            return cl;
        }
        for (int i=len; 0<=i; i--)
        {
            ch = b[i];
            if (ch=='1')
            {
                ic += Mathf.Pow(2.0f, ii);
            }
            ii++;
            if ((ib==1) && (ii==8))
            {
                // alpha
                cl.a = Mathf.Floor(ic) / 255;
                ii = 0;
                ic = 0.0f;
                ib++;
            } else
            if ((ib==2) && (ii==8))
            {
                // blue
                cl.b = Mathf.Floor(ic) / 255;
                ii = 0;
                ic = 0.0f;
                ib++;
            } else
            if ((ib==3) && (ii==8))
            {
                // green
                cl.g = Mathf.Floor(ic) / 255;
                ii = 0;
                ic = 0.0f;
                ib++;
            } else
            if ((ib==4) && (ii==8))
            {
                // red
                cl.r = Mathf.Floor(ic) / 255;
                ii = 0;
                ic = 0.0f;
                ib++;
            }           
        }
        return cl;
    }
    public static Color FloatToColor(float f)
    {
        return BinaryStringToColor(FloatToBinaryString(f));
    }

}