MyCaffePythonGym.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Runtime.InteropServices;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using MyCaffe.basecode;
using MyCaffe.basecode.descriptors;
 
namespace MyCaffe.gym.python
{
    public class MyCaffePythonGym : IXMyCaffeGymUiCallback, IDisposable
    {
        int m_nUiId = -1;
        IXMyCaffeGym m_igym = null;
        MyCaffeGymUiProxy m_gymui = null;
        Log m_log = new Log("MyCaffePythonGym");
        Tuple<SimpleDatum, double, bool> m_state = null;
        List<SimpleDatum> m_rgData = new List<SimpleDatum>();
        double[][] m_rgrgActionDistributions = null;
        bool m_bNormalizeOverlay = true;
        Font m_font = null;
        Dictionary<Color, Tuple<Brush, Brush, Pen, Brush>> m_rgStyle = new Dictionary<Color, Tuple<Brush, Brush, Pen, Brush>>();
 
        public MyCaffePythonGym()
        {
        }
 
        public void Dispose()
        {
            if (m_font != null)
            {
                m_font.Dispose();
                m_font = null;
            }
 
            foreach (KeyValuePair<Color, Tuple<Brush, Brush, Pen, Brush>> kv in m_rgStyle)
            {
                kv.Value.Item1.Dispose();
                kv.Value.Item2.Dispose();
                kv.Value.Item3.Dispose();
                kv.Value.Item4.Dispose();
            }
 
            m_rgStyle.Clear();
        }
 
        public int Initialize(string strGym, string strParam)
        {
            m_log.EnableTrace = true;
 
            GymCollection col = new GymCollection();
            col.Load();
 
            m_igym = col.Find(strGym);
            if (m_igym == null)
                throw new Exception("Could not find the gym '" + strGym + "'!");
 
            m_igym.Initialize(m_log, new PropertySet(strParam));
 
            return 0;
        }
 
        public string Name
        {
            get
            {
                if (m_igym == null)
                    throw new Exception("You must call 'Initialize' first!");
 
                return "MyCaffe " + m_igym.Name;
            }
        }
 
        public void SetActionDistributions(double[][] rgrg)
        {
            m_rgrgActionDistributions = rgrg;
        }
 
        public int[] Actions
        {
            get
            {
                if (m_igym == null)
                    throw new Exception("You must call 'Initialize' first!");
 
                List<int> rg = new List<int>();
                Dictionary<string, int> rgActions = m_igym.GetActionSpace();
                int nActionIdx = 0;
 
                foreach (KeyValuePair<string, int> kv in rgActions)
                {
                    rg.Add(nActionIdx);
                    nActionIdx++;
                }
 
                return rg.ToArray();
            }
        }
 
        public string[] ActionNames
        {
            get
            {
                if (m_igym == null)
                    throw new Exception("You must call 'Initialize' first!");
 
                List<string> rg = new List<string>();
                Dictionary<string, int> rgActions = m_igym.GetActionSpace();
 
                foreach (KeyValuePair<string, int> kv in rgActions)
                {
                    rg.Add(kv.Key);
                }
 
                return rg.ToArray();
            }
        }
 
        public bool IsTerminal
        {
            get { return (m_state == null) ? true : m_state.Item3; }
        }
 
        public double Reward
        {
            get { return (m_state == null) ? 0 : m_state.Item2; }
        }
 
        public List<double> Data
        {
            get { return (m_state == null) ? null : m_state.Item1.GetData<double>().ToList(); }
        }
 
        public List<List<List<double>>> GetDataAs3D(bool bGrayscale = false, double dfScale = 1, SimpleDatum sd = null)
        {
            double[] rgData1 = (sd == null) ? Data.ToArray() : sd.GetData<double>();
            int nChannels = (sd == null) ? m_state.Item1.Channels : sd.Channels;
            int nHeight = (sd == null) ? m_state.Item1.Height : sd.Height;
            int nWidth = (sd == null) ? m_state.Item1.Width : sd.Width;
            List<List<List<double>>> rgrgrgData = new List<List<List<double>>>();
 
            for (int h = 0; h < nHeight; h++)
            {
                List<List<double>> rgrgData = new List<List<double>>();
 
                for (int w = 0; w < nWidth; w++)
                {
                    List<double> rgData = new List<double>();
 
                    if (bGrayscale)
                    {
                        double dfSum = 0;
 
                        for (int c = 0; c < nChannels; c++)
                        {
                            int nIdx = (c * nHeight * nWidth) + (h * nWidth) + w;
                            dfSum += rgData1[nIdx];
                        }
 
                        rgData.Add((dfSum / nChannels) * dfScale);
                    }
                    else
                    {
                        for (int c = 0; c < nChannels; c++)
                        {
                            int nIdx = (c * nHeight * nWidth) + (h * nWidth) + w;
                            double dfVal = rgData1[nIdx];
 
                            rgData.Add(dfVal * dfScale);
                        }
                    }
 
                    rgrgData.Add(rgData);
                }
 
                rgrgrgData.Add(rgrgData);
            }
 
            return rgrgrgData;
        }
 
        private SimpleDatum preprocess(SimpleDatum sd, bool bGrayscale, double dfScale)
        {
            if (!bGrayscale && dfScale == 1)
                return sd;
 
            double[] rgData = sd.GetData<double>();
            int nCount = sd.Height * sd.Width;
            int nChannels = sd.Channels;
            bool bIsReal = sd.IsRealData;
            byte[] rgByteData = null;
            double[] rgRealData = null;
 
            if (bIsReal && !bGrayscale)
            {
                nCount *= sd.Channels;
                rgRealData = new double[nCount];
            }
            else
            {
                bIsReal = false;
                nChannels = 1;
                rgByteData = new byte[nCount];
            }
 
            for (int h = 0; h < sd.Height; h++)
            {
                for (int w = 0; w < sd.Width; w++)
                {
                    int nIdx = (h * sd.Width) + w;
                    int nIdxSrc = nIdx * sd.Channels;
 
                    if (rgRealData != null)
                    {
                        for (int c = 0; c < sd.Channels; c++)
                        {
                            double dfVal = rgData[nIdxSrc + c] * dfScale;
                            rgRealData[nIdxSrc + c] = dfVal;
                        }
                    }
                    else
                    {
                        double dfSum = 0;
 
                        for (int c = 0; c < sd.Channels; c++)
                        {
                            dfSum += rgData[nIdxSrc + c];
                        }
 
                        double dfVal = ((dfSum / sd.Channels) * dfScale);
                        if (dfVal > 255)
                            dfVal = 255;
 
                        if (dfVal < 0)
                            dfVal = 0;
 
                        rgByteData[nIdx] = (byte)dfVal;
                    }
                }
            }
 
            SimpleDatum sdResult;
            
            if (rgRealData != null)
                sdResult = new SimpleDatum(bIsReal, nChannels, sd.Width, sd.Height, sd.Label, sd.TimeStamp, rgRealData, sd.Boost, sd.AutoLabeled, sd.Index);
            else
                sdResult = new SimpleDatum(bIsReal, nChannels, sd.Width, sd.Height, sd.Label, sd.TimeStamp, rgByteData, sd.Boost, sd.AutoLabeled, sd.Index);
 
            sdResult.Tag = sd.Tag;
 
            return sdResult;
        }
 
        public List<List<List<double>>> GetDataAsStacked3D(bool bReset, int nFrames = 4, int nStacks = 4, bool bGrayscale = true, double dfScale = 1)
        {
            SimpleDatum sd = preprocess(m_state.Item1, bGrayscale, dfScale);
 
            if (bReset)
            {
                m_rgData.Clear();
 
                for (int i = 0; i < nFrames * nStacks; i++)
                {
                    m_rgData.Add(sd);
                }
            }
            else
            {
                m_rgData.Add(sd);
                m_rgData.RemoveAt(0);
            }
 
            SimpleDatum[] rgSd = new SimpleDatum[nStacks];
 
            for (int i = 0; i < nStacks; i++)
            {
                int nIdx = ((nStacks - i) * nFrames) - 1;
                rgSd[i] = m_rgData[nIdx];
            }
 
            SimpleDatum sd1 = new SimpleDatum(rgSd.ToList(), true);
 
            return GetDataAs3D(false, 1, sd1);
        }
 
        public CurrentState Reset(PropertySet props = null)
        {
            if (m_igym == null)
                throw new Exception("You must call 'Initialize' first!");
 
            Tuple<State, double, bool> state = m_igym.Reset(false, props);
 
            bool bIsOpen = (m_nUiId >= 0) ? true : false;
            Tuple<Bitmap, SimpleDatum> data = m_igym.Render(bIsOpen, 512, 512, true);
            int nDataLen = 0;
            SimpleDatum sd = state.Item1.GetData(false, out nDataLen);
 
            if (data.Item1 != null || data.Item2 != null)
            {
                Observation obs = new Observation(data.Item1, ImageData.GetImage(data.Item2), m_igym.RequiresDisplayImage, sd.GetData<double>(), state.Item2, state.Item3);
 
                if (bIsOpen)
                {
                    if (m_rgrgActionDistributions != null)
                        overlay(obs.ImageDisplay, m_rgrgActionDistributions);
 
                    m_gymui.Render(m_nUiId, obs);
                    Thread.Sleep(m_igym.UiDelay);
                }
 
                if (m_igym.SelectedDataType == DATA_TYPE.BLOB)
                    sd = data.Item2;
                else
                    sd.Clip(nDataLen, null, nDataLen, null);
            }
 
            m_state = new Tuple<SimpleDatum, double, bool>(sd, state.Item2, state.Item3);
 
            return new CurrentState(m_state.Item1.GetData<double>(), m_state.Item2, m_state.Item3);
        }
 
        public CurrentState Step(int nAction, int nSteps = 1, PropertySet props = null)
        {
            if (m_igym == null)
                throw new Exception("You must call 'Initialize' first!");
 
            for (int i = 0; i < nSteps-1; i++)
            {
                m_igym.Step(nAction);
            }
 
            Tuple<State, double, bool> state = m_igym.Step(nAction, false, props);
 
            bool bIsOpen = (m_nUiId >= 0) ? true : false;
            Tuple<Bitmap, SimpleDatum> data = m_igym.Render(bIsOpen, 512, 512, true);
            int nDataLen = 0;
            SimpleDatum sd = state.Item1.GetData(false, out nDataLen);
 
            if (data.Item1 != null || data.Item2 != null)
            {
                Observation obs = new Observation(data.Item1, ImageData.GetImage(data.Item2), m_igym.RequiresDisplayImage, sd.GetData<double>(), state.Item2, state.Item3);
 
                if (bIsOpen)
                {
                    if (m_rgrgActionDistributions != null)
                        overlay(obs.ImageDisplay, m_rgrgActionDistributions);
 
                    m_gymui.Render(m_nUiId, obs);
                    Thread.Sleep(m_igym.UiDelay);
                }
 
                if (m_igym.SelectedDataType == DATA_TYPE.BLOB)
                    sd = data.Item2;
                else
                    sd.Clip(nDataLen, null, nDataLen, null);
            }
 
            m_state = new Tuple<SimpleDatum, double, bool>(sd, state.Item2, state.Item3);
 
            return new CurrentState(m_state.Item1.GetData<double>(), m_state.Item2, m_state.Item3, state.Item1);
        }
 
        private void overlay(Bitmap bmp, double[][] rgData)
        {
            if (bmp == null)
                return;
 
            using (Graphics g = Graphics.FromImage(bmp))
            {
                int nBorder = 30;
                int nWid = bmp.Width - (nBorder * 2);
                int nWid1 = nWid / rgData.Length;
                int nHt1 = (int)(bmp.Height * 0.3);
                int nX = nBorder;
                int nY = bmp.Height - nHt1;
                ColorMapper clrMap = new ColorMapper(0, rgData.Length + 1, Color.Black, Color.Red);
                float[] rgfMin = new float[rgData.Length];
                float[] rgfMax = new float[rgData.Length];
                float fMax = -float.MaxValue;
                float fMaxMax = -float.MaxValue;
                int nMaxIdx = 0;
 
                for (int i = 0; i < rgData.Length; i++)
                {
                    rgfMin[i] = (float)rgData[i].Min(p => p);
                    rgfMax[i] = (float)rgData[i].Max(p => p);
 
                    if (rgfMax[i] > fMax)
                    {
                        fMax = rgfMax[i];
                        nMaxIdx = i;
                    }
 
                    fMaxMax = Math.Max(fMax, fMaxMax);
                }
 
                if (fMaxMax > 0.2f)
                    m_bNormalizeOverlay = false;
 
                for (int i = 0; i < rgData.Length; i++)
                {
                    drawProbabilities(g, nX, nY, nWid1, nHt1, i, rgData[i], clrMap.GetColor(i + 1), rgfMin.Min(p => p), rgfMax.Max(p => p), (i == nMaxIdx) ? true : false, m_bNormalizeOverlay);
                    nX += nWid1;
                }
            }
        }
 
        private void drawProbabilities(Graphics g, int nX, int nY, int nWid, int nHt, int nAction, double[] rgProb, Color clr, float fMin, float fMax, bool bMax, bool bNormalize)
        {
            string str = "";
 
            if (m_font == null)
                m_font = new Font("Century Gothic", 9.0f);
 
            if (!m_rgStyle.ContainsKey(clr))
            {
                Color clr1 = Color.FromArgb(128, clr);
                Brush br1 = new SolidBrush(clr1);
                Color clr2 = Color.FromArgb(64, clr);
                Pen pen = new Pen(clr2, 1.0f);
                Brush br2 = new SolidBrush(clr2);
                Brush brBright = new SolidBrush(clr);
                m_rgStyle.Add(clr, new Tuple<Brush, Brush, Pen, Brush>(br1, br2, pen, brBright));
            }
 
            Brush brBack = m_rgStyle[clr].Item1;
            Brush brFront = m_rgStyle[clr].Item2;
            Brush brTop = m_rgStyle[clr].Item4;
            Pen penLine = m_rgStyle[clr].Item3;
 
            if (fMin != 0 || fMax != 0)
            {
                str = "Action " + nAction.ToString() + " (" + (fMax - fMin).ToString("N7") + ")";
            }
            else
            {
                str = "Action " + nAction.ToString() + " - No Probabilities";
            }
 
            SizeF sz = g.MeasureString(str, m_font);
 
            int nY1 = (int)(nY + (nHt - sz.Height));
            int nX1 = (int)(nX + (nWid / 2) - (sz.Width / 2));
            g.DrawString(str, m_font, (bMax) ? brTop : brFront, new Point(nX1, nY1));
 
            if (fMin != 0 || fMax != 0)
            {
                float fX = nX;
                float fWid = nWid / (float)rgProb.Length;
                nHt -= (int)sz.Height;
 
                for (int i = 0; i < rgProb.Length; i++)
                {
                    float fProb = (float)rgProb[i];
 
                    if (bNormalize)
                        fProb = (fProb - fMin) / (fMax - fMin);
 
                    float fHt = nHt * fProb;
                    float fHt1 = nHt - fHt;
                    RectangleF rc1 = new RectangleF(fX, nY + fHt1, fWid, fHt);
                    g.FillRectangle(brBack, rc1);
                    g.DrawRectangle(penLine, rc1.X, rc1.Y, rc1.Width, rc1.Height);
                    fX += fWid;
                }
            }
        }
 
        public DatasetDescriptor GetDataset(DATA_TYPE type)
        {
            if (m_igym == null)
                throw new Exception("You must first Initialize the MyCaffePythonGym!");
 
            return m_igym.GetDataset(type);
        }
 
        public void OpenUi(bool bStartRecording = false)
        {
            if (m_gymui != null)
                return;
 
            try
            {
                m_gymui = new MyCaffeGymUiProxy(new InstanceContext(this));
                m_gymui.Open();
                m_nUiId = m_gymui.OpenUi(Name, m_nUiId, bStartRecording);
            }
            catch (Exception excpt)
            {
                throw new Exception("You need to run the MyCaffe Test Application which supports the gym user interface host.", excpt);
            }
        }
 
        public void CloseUi()
        {
            if (m_gymui == null)
                return;
 
            m_gymui.CloseUi(0);
            m_gymui.Close();
            m_gymui = null;
            m_nUiId = -1;
        }
 
        public void Closing()
        {
        }
    }
 
    public class CurrentState
    {
        State m_gymState = null;
        SimpleDatum m_rgData;
        double m_dfReward;
        bool m_bTerminal;
 
        public CurrentState(double[] rgData, double dfReward, bool bTerminal, State gymState = null)
        {
            m_rgData = new SimpleDatum(rgData.Length, 1, 1, rgData.Select(p => (float)p).ToArray(), 0, rgData.Length);
            m_dfReward = dfReward;
            m_bTerminal = bTerminal;
            m_gymState = gymState;
        }
 
        public SimpleDatum Data
        {
            get { return m_rgData; }
        }
 
        public double Reward
        {
            get { return m_dfReward; }
        }
 
        public bool Terminal
        {
            get { return m_bTerminal; }
        }
 
        public State GymState
        {
            get { return m_gymState; }
        }
    }
}